Best AI for Writing a Novel? It's the Wrong Question
You have four tabs open and they disagree. One says Claude for prose, one says Gemini for the context window, one says a local model if you care about your manuscript staying on your machine, and the fourth is a comparison table whose checkmarks dissolve the moment you read the footnotes. Meanwhile you're 60,000 words into something real. Last month you switched models because chapter 22 forgot your protagonist's sister was dead, and for about three chapters the new one was better. Then it gave your dockhand — a man who has spoken in fragments for two hundred pages — a monologue in complete, well-punctuated sentences.
So you went back to reading tabs.
Before you spend another evening on that: a pair of recent papers on long-form story generation suggest you're shopping in the wrong aisle. The thing that breaks first at novel length isn't the model's talent. It's whether anything in your setup is holding the model to what it already decided.
The short answer: the system around the model beats the model
For a full-length novel, the workflow you wrap around a model matters at least as much as which model you pick. The same base model, run scene by scene against a maintained record of story facts and character states, produces dramatically fewer continuity errors than the same model asked to keep writing. Choosing a better model raises the ceiling on any individual scene. Choosing a better system is what stops chapter 31 from contradicting chapter 9.
That's not a vibe. It's roughly what the numbers show.
What the research actually found
In ConWriter, researchers built a training-free framework that makes a model write incrementally at the scene level while maintaining static story requirements, an evolving narrative memory, and symbolic checks on what each new scene is allowed to change. When it detects a contradiction, it repairs the offending sentences instead of regenerating the whole passage.
They measured Consistency Error Density — errors per 10,000 words — against plain direct generation, for three base models at three target lengths:
- Qwen3.5-Plus: 78.76% fewer errors at 3,000 words, 82.28% at 6,000, 50.68% at 12,000
- DeepSeek-V4-Flash: 87.48% at 3,000, 53.78% at 6,000, 50.61% at 12,000
- GPT-5.4-nano: 78.38% at 6,000, 59.14% at 12,000
Read the shape of that, not just the size. Every model improved, which is the headline. But the gain erodes with length: by 12,000 words all three had fallen to a 50–59% reduction, down from 78–87% at 3,000. Structure buys you a lot of consistency, and it buys less of it the further you go.
The caveats are real and the paper states them: 20 evaluation cases, an automated judge model rather than human readers, and a longest test length of 12,000 words — five or six chapters. Nobody has shown this holds across a finished 90,000-word novel.
The companion benchmark is arguably more useful to a working novelist. Lost in Stories ran 2,000 long-story prompts and built a taxonomy of five error categories with 19 subtypes. Three findings are worth pinning above your desk:
Errors cluster in the middle. Not the opening, where the model has everything fresh, and not the ending, where it's steering toward resolution. The middle — which is exactly where your beta reader said "it goes a bit slow around chapter fifteen" and couldn't say why.
Factual and temporal errors dominate. Not tonal drift, not character voice. The boring stuff: who has what, who is where, how long since the coronation.
Higher token-level entropy segments contain more errors. In plain terms, the model is measurably less certain in the passages where it's about to get something wrong. Its own hesitation is a signal — which is why ConWriter uses uncertainty to decide which passages to scrutinize hardest, rather than auditing everything equally.
A big context window is not binding memory
Here is the distinction that reframes the whole "which model" question: a model seeing a fact is not the same as a model being bound by it.
You can put your entire 90,000-word manuscript inside a million-token window. The model will still write a scene where your pacifist picks up a gun, because in the local logic of that scene, the gun is the most narratively satisfying object in the room. Nothing in the architecture makes chapter 9's decision binding on chapter 31. It's context, not custody.
This is why model-switching feels like it works and then stops working. A stronger model has better recall and better local judgment, so it holds the line longer. It's still holding the line by inclination rather than by rule, and inclination degrades with distance. One commenter in the r/WritingWithAI thread on the paper put the practical version of this well: the advertised million-token windows tend to fall apart well before they're full, which is why the tooling around the model ends up mattering more than the number on the box.
The same thread has a writer describing a 250,000-word draft in Claude where the story bible itself became the problem — it kept trying to re-tell the whole manuscript and log its own changes until the bloat ate the context it was meant to protect. Not a model failure. A filing failure.
What this looks like on a Tuesday night
Say you're Nadia, 47 chapters into book two, roughly 82,000 words. Chapter 29 is due. The relevant state is not "everything that has happened" — it's about nine facts: Emeric knows about the harbor ledger but Sela does not; Sela's brother died in book one, chapter 31; the frost has been on the ground for eleven days; Emeric's left hand is scarred; Sela has never called him by his first name in dialogue.
Direct generation means pasting some of that into a prompt and hoping. The structured version is three moves you can do by hand tonight:
- Write the scene's preconditions. What must be true entering chapter 29. Nine lines, not nine pages.
- Write what it's allowed to change, and what it isn't. Chapter 29 may reveal the ledger to Sela. It may not put Emeric outside the city, and it may not have anyone reference her brother in the present tense.
- Check the draft against those two lists before you move on, and patch the sentences that fail — not the chapter.
That third move is the one people skip, and it's the one the research is pointing at. Regenerating a whole chapter because one sentence contradicts your timeline reintroduces four new opportunities to drift. Fixing the sentence costs you ninety seconds and changes nothing else.
If Nadia does this for chapters 29 through 47, she does it nineteen times. The lists take four minutes each. Call it eighty minutes of bookkeeping across the back half of a novel, against the alternative — which is finding the contradiction in copyedits, in a manuscript where it has been load-bearing for twelve chapters.
This is roughly what a maintained story bible or lorebook is for, except most writers keep one as an archive rather than as a contract. The archive version tells you what's true. The contract version tells the model what it isn't allowed to do next. In NovelMage the Codex is doing the first job automatically — entries for characters, locations, and world rules get referenced while it writes — and the second job is the discipline you add on top: a short scene contract per chapter, checked before you move on.
Where you keep the record matters more than you'd think
This workflow usually collapses for a boring reason: the record lives in six places — a Google Doc, a spreadsheet, the model's project memory, three chat threads — and reconciling them is worse than the drift. One durable location beats a clever system spread across four apps.
There's also a cost wrinkle. Checking nineteen chapters against a state list is a lot of low-glamour model calls, and on metered cloud pricing that's exactly the pass you quietly start skipping. Running it on a local model through Ollama or LM Studio removes the pressure — sweep as often as you like, and the manuscript never leaves the machine. The continuity-drift piece covers why the forgetting happens in the first place, and for a series the same logic scales up into its own series bible problem.
So does the model matter at all?
Yes, and this is where the "wrong question" framing can be taken too far. Models differ real amounts on sentence-level quality, on dialogue that sounds like a person, on whether they'll write your morally ugly antagonist without editorializing. If your complaint is flatness at 2,000 words rather than contradictions at 60,000, close this tab and go read about narrative distance and deep POV instead — the workflow here won't touch that problem.
The honest division of labor: the model decides how good any single scene can be; the system decides whether 300 scenes can be the same book. They are different problems, they fail differently, and only one of them gets solved by opening another comparison table.
One boundary on the evidence: ConWriter drove three specific base models — Qwen3.5-Plus, DeepSeek-V4-Flash and GPT-5.4-nano — not the frontier flagships most novelists are choosing between. It shows structure helped every model tested. It says nothing about whether yours needs more help or less.
What to do differently this week
Concretely, if you have a draft in progress:
- Stop auditing the whole manuscript. Audit the middle. That's where the errors cluster, and you've been rereading your opening chapters for months anyway.
- Convert your story bible from an archive into a contract. Every entry should be phrased as something a scene may not violate, not as something that is merely true.
- Write the forbid list. It's the part nobody does and the part that catches the pacifist with the gun.
- Patch sentences, not chapters. Every regeneration is a fresh roll of the dice on details you'd already gotten right.
- Watch the passages where the draft goes vague. The model's own uncertainty tracked with its error rate in the benchmark data, and you can feel that hedging quality when you read it back.
None of this requires a particular tool. You can run all of it in a text file and a spreadsheet, and writers do. What a purpose-built app changes is how much of the bookkeeping survives a Tuesday when you're tired — entries referenced automatically instead of pasted, manuscript and state record in one place rather than five.
If that's the setup you want without a monthly bill attached to it, NovelMage is a desktop app for Windows and macOS at $99.99 one time, covering three devices, with a 7-day free trial — and it runs your local models through Ollama or LM Studio, or your own Claude, GPT, or Gemini keys, so the model question stays yours to change your mind about later.
Frequently asked questions
Which AI is best for writing a novel in 2026?
There's no single answer, and the more useful reframing is that model choice determines scene quality while your workflow determines whether the book holds together. The ConWriter results showed large consistency improvements across three different base models from the same structural changes, which means the gains were not model-specific. Pick a model whose prose you like, then build the state-tracking around it.
Does a bigger context window solve AI continuity problems?
No. A large window means the model can see earlier material; it doesn't mean earlier decisions constrain later ones. In the r/WritingWithAI discussion of the paper, writers report drift well inside advertised window limits, and the paper's own approach isn't "show the model more" but "check each scene against explicit state before continuing."
Where do AI continuity errors actually happen?
The Lost in Stories benchmark, built on 2,000 long-story prompts, found errors cluster in the middle sections of narratives, that factual and temporal inconsistencies are the most common categories, and that higher-entropy passages contain more errors. Practically: audit your middle acts, and check dates, possessions, and who-knew-what before you check tone.
How much does NovelMage cost compared to subscription tools?
$99.99 as a one-time lifetime purchase, which includes all future updates and use on up to three devices; there's also a 7-day free trial with no credit card. Monthly billing exists at $9.99/month if you'd rather not pay up front. Because it runs local models via Ollama or LM Studio, or your own API keys, there's no per-word AI surcharge layered on top of the license.