Eliminating the Mechanical Tone in LLM-Assisted Novel Writing

5 hr ago0 views

Large Language Models often produce coherent but mechanical text when assisting with long-form novel writing, suffering from formulaic dialogues and homogenized characters. This article explores a multi-agent architecture that decomposes the writing process into planning, scripting, prose expansion, and independent dialogue revision to systematically eliminate the mechanical feel, optimize resource allocation, and improve generation efficiency.

Eliminating the Mechanical Tone in LLM-Assisted Novel Writing

When using Large Language Models (LLMs) to assist with long-form novel writing, developers often encounter a typical technical bottleneck: the generated text is logically coherent but lacks a human touch. This phenomenon manifests as overly neat dialogues, abrupt emotional transitions, and formulaic environmental descriptions. From an engineering perspective, this occurs because the model, while optimizing for instruction adherence, falls into statistical preferences for high-frequency vocabulary, leading to a convergence in output style. This article explores how to systematically resolve this issue through architecture-level process decomposition and multi-agent collaboration mechanisms.

1. Diagnosing the Root Cause: Instruction Dependency and Context Dilution

When we require a model to perform multiple tasks within a single prompt—such as advancing the plot, developing characters, and rendering the environment—the model tends to adopt the safest, most logical structured expression. This leads to two prominent issues:

“Meeting Minutes” Style Dialogue: Character interactions focus too heavily on information transfer. Each character states facts and confirms information in turn, losing the interruptions, hesitations, emotional venting, and evasiveness found in real conversations.
Character Homogenization: Even with differentiated backgrounds set for different characters, the model’s primary focus on achieving task objectives dilutes individual personality traits. If you hide the character names, dialogues from different characters sound as if they were spoken by the same person.

Repeatedly patching a single prompt (e.g., “use shorter sentences,” “avoid frequent use of ‘he said’,” “require responding to the other’s attitude”) only alleviates the symptoms locally without addressing the root cause. We need to reconstruct the generation chain architecture.

2. Architecture Reconstruction: Multi-Model Collaboration and Task Layering

The core approach to solving compute allocation and model capability differences is to decompose the complex novel generation task into sub-tasks. These are handled by models specialized in different domains or by independent sessions, constructing a three-layer generation architecture: “Script Layer — Prose Layer — Dialogue Revision Layer.”

1. Planning Layer: Global Settings and Outline Arrangement
A model with high reasoning capabilities (or a designated planning model) acts as the “architect,” solely responsible for structuring chapter outlines, character motivations, conflict focal points, and pacing. This serves as the top-level system design, ensuring subsequent expansions do not deviate from the main storyline.

2. Script Layer: Pre-arrangement of Dialogues and Key Actions
This is a critical step in eliminating the mechanical tone. Before directly generating the prose, have the model output the dialogue and actions for the scene in a script format. Scripts naturally strip away complex modifiers, forcing the model to focus on the characters’ authentic reactions in specific contexts. For example, in a high-pressure “military train ambush” scenario, the script layer explicitly defines the “shouting to be heard” action required during machine-gun fire and the distress calls when a train car is about to slide off, rather than standing by and giving dry situation reports.

3. Prose Layer: Script-Based Expansion
The generated script is fed as context into the prose generation model. Since the plot skeleton and dialogue are already determined, the prose model only needs to focus on environmental rendering, detail description, and paragraph transitions. This significantly reduces the cognitive load of the model handling multiple tasks simultaneously, resulting in richer text.

# Architecture workflow pseudocode example
def generate_chapter(scene_setting, characters):
    # 1. Planning layer generates the outline
    outline = planner_model.generate(scene_setting, characters)
    # 2. Script layer generates dialogues and actions
    script = script_model.generate_dialogues(outline, character_profiles)
    # 3. Prose layer expands the script into full text
    content = writer_model.expand_to_prose(script, outline)
    # 4. Revision layer polishes dialogues independently
    refined_content = reviser_model.refine_dialogues(content)
    return refined_content

3. Independent Dialogue Revision: The Last Line of Defense Against Formulaic Expression

Even after script layer arrangement, the prose expansion model may still assimilate dialogues into its own linguistic style. Therefore, introducing an “independent dialogue revision” stage is crucial.

1. Local Rewriting Detached from Global Context
Extract dialogue segments exhibiting the “mechanical tone” separately and hand them over to an independent session window for revision. This isolation prevents the model from being distracted by preceding lengthy environmental descriptions, refocusing it on character personality and immediate emotions.

2. Exploring Low-Temperature and Low-Instruction Dependency Generation
Early tests revealed that appropriately lowering the model’s instruction adherence level (e.g., using lower-tier parameters) actually keeps it away from being “overly polished and neat,” producing sentence breaks and expressions closer to real spoken language. Although this might lead to minor information omissions, manual intervention or subsequent rule-based completion can retain its natural fluency.

3. Practical Strategy to Avoid Bottlenecks
In actual development and creation, using the most expensive, high-performance models with tight quotas for full-text generation is impractical. A reasonable approach is to let general-purpose, high-compute models handle the massive workload of prose expansion, extract segments with obviously stiff interactions, and utilize free quotas or lightweight models for targeted dialogue revision. This not only improves text quality but also unexpectedly speeds up the overall generation chain—reducing the time from over 30 minutes of repeated retries and stalls with a single model to about 12 minutes for the entire “script + expansion + revision” pipeline.

4. Conclusion and Best Practices

To eliminate the “mechanical tone” in LLM-assisted writing, the core lies in mapping the human writing process of “conceiving — drafting — polishing” into a multi-step agent workflow:

Separate Dialogue and Description: Write the script first, then expand it into prose to prevent the model from juggling information transfer and literary description simultaneously.
Character Awakening Mechanism: When generating dialogues, provide not only character settings but also their physiological and psychological states in the current scene (e.g., exhaustion, panic, anger) to break the homogenized response pattern.
Hierarchical Resource Scheduling: Do not expect a single model to solve everything. Utilize a planning model to control structure, a general model to fill in content, and specific sessions to polish details. This is the best engineering practice balancing cost, efficiency, and quality.

Through this pipeline reconstruction, developers can effectively eliminate the mechanical feel of the text and establish a controllable, efficient, and highly realistic intelligent long-form text generation system.

Eliminating the Mechanical Tone in LLM-Assisted Novel Writing