Eliminating the "Machine Tone" in LLM-Assisted Novel Writing: An Architectural Approach

Eliminating the “Machine Tone” in LLM-Assisted Novel Writing: An Architectural Approach

When leveraging Large Language Models (LLMs) for long-form text generation, such as novels and scripts, developers frequently encounter a typical engineering bottleneck: the generated text is logically coherent and grammatically correct but often carries an elusive “machine tone.” This machine tone manifests as overly neat dialogues, abrupt emotional transitions, and formulaic environmental descriptions. Eliminating these traces through technical means and system architecture design is a core challenge in the current AI-assisted writing domain.

1. Diagnosing the “Machine Tone” and Context Loss

In practical development and testing, when a model is asked to generate complex multi-character scenes (e.g., a military train ambush), the most prominent issue is “character homogenization.” Even if we define distinct backgrounds, personalities, and experiences for five different characters in the prompt, the generated text often sounds like a group of people who attended the same “orientation training” taking turns reporting. Cover the names, and readers cannot tell who is speaking.

From an underlying technical perspective, this phenomenon stems from the fact that during autoregressive generation, LLMs rely too heavily on the “average distribution” of the global context while neglecting the dynamic injection of micro-level character settings. Common symptoms include:

1. Fragmented Expression: The model tends to chop sentences too finely, frequently inserting dialogue tags like “he said” or “she replied,” which disrupts the flow of the conversation.
2. Redundant Confirmation: Characters engage in excessive, ineffective back-and-forth dialogues. One person reads information in order, the next confirms it sequentially, and a third summarizes it. The entire dialogue reads like “meeting minutes” rather than a life-or-death emergency exchange.
3. Contextual Detachment: In extreme environments (e.g., under machine-gun fire or inside a slipping train carriage), characters fail to exhibit appropriate physiological and psychological reactions, instead acting as bystanders making “situation reports.”

2. Engineering Solutions: Hierarchical Orchestration and Multi-Model Collaboration

Simply piling rules into the prompt (e.g., “don’t chop sentences too finely,” “characters should respond to each other’s attitudes”) might yield minor local improvements but quickly hits the model’s capability ceiling. To fundamentally solve this issue, we need to introduce a hierarchical orchestration architecture and multi-agent collaboration mechanisms.

1. Separating the Dialogue Revision Module
Since generating the main text of a novel consumes a massive number of tokens, sending all text directly to the most advanced and expensive model is costly and prone to rate limits. Therefore, a rational architecture should let a general-purpose LLM with high throughput handle the bulk of the text expansion tasks. Then, text blocks with communication issues should be extracted and sent to a different model specialized in organizing natural language exchanges for targeted revision. This modular separation strategy can significantly improve dialogue quality without drastically increasing costs.

2. Introducing a “Script Layer” as Middleware
Directly jumping from an “outline” to “main text” often causes the model to drop the ball when organizing complex dialogues. The best practice is to insert a “script layer” in between. At this stage, the model only outputs key actions, core dialogue lines, and emotional guidelines. This provides a high-density structural skeleton for the final text generation, ensuring that during subsequent expansion, characters communicate based on the actions and attitudes defined in the script, rather than hollowly reporting information.

3. Unexpected Benefits and Performance Tuning from Architectural Evolution

Adopting the hierarchical architecture of “script layer guidance + independent dialogue revision” not only drastically improves text naturalness but also brings system-level performance optimizations.

1. Non-linear Improvement in Generation Efficiency
Without the script layer, models often fall into an infinite loop of “repetitive correction” during the main text generation phase, causing a single generation to take over 30 minutes. With the script layer, since key information and action logic are locked in during the middleware phase, the text expansion model only needs to polish the language and fill in details, reducing generation time to roughly 12 minutes. Even accounting for the script layer’s generation time, the overall process saves about 10 minutes. This indicates that providing clear structural guidance effectively reduces uncertainty in the generation path, thereby boosting inference speed.

2. Fine-tuned Generation Parameters
In the independent dialogue revision module, adjusting sampling parameters like temperature is critical. Testing reveals that in specific scenarios, using conservative generation parameters yields better results. Under high parameters, the model tends to generate overly “refined” and “neat” modifiers, exacerbating the “machine tone.” Appropriately lowering randomness allows the model to focus on expressing the base semantics, stripping away unnecessary, redundant rhetoric.

4. Developer Guide: Building a Context Management System

For developers looking to leverage LLMs for long-form writing, building a comprehensive context management system is recommended over relying solely on prompt engineering:

1. Character State Machines: Abstract character personalities and experiences into structured attribute tags. Dynamically inject the character’s current emotional state (e.g., nervous, terrified, angry) at each step of dialogue generation, ensuring the model perceives psychological changes during generation.
2. Environmental Perception Injection: In the context block of the prompt, explicitly declare current physical conditions like ambient noise levels and time urgency. Require the model to factor these physical constraints into dialogue generation (e.g., using short sentences and shouting when noise is high).
3. Leveraging Cloud Orchestration Capabilities: For enterprise-level applications, developers can utilize general-purpose LLM service platforms, such as Baidu AI Cloud, leveraging their message queues and orchestration capabilities to chain the “text expansion model,” “script planning model,” and “dialogue revision model” into an automated workflow. This achieves unattended generation from outline to high-quality final draft.

In conclusion, eliminating the “machine tone” in LLM-generated text is not merely a prompt optimization task but a system architecture design challenge. Through multi-model collaboration, introducing an intermediate script layer, and meticulous context management, developers can endow AI with natural expression capabilities much closer to those of humans.