How the NovelCanon Consistency Engine Works

The Consistency Engine tracks the factual claims your story makes and cross-references them across the whole manuscript, in three tiers: instant on-device checks as you type, per-scene fact extraction that builds a story bible from your prose, and a full-book deep scan that surfaces contradictions, dropped plot threads, and broken world rules.

Most writing tools that mention "consistency" mean one of two things: a grammar checker, or a story-bible document you fill in by hand and hope the AI reads. NovelCanon's Consistency Engine is a different kind of thing — a system whose entire job is to notice when your story contradicts itself. This post is an honest look at how it actually works, because a claim that specific deserves to be shown, not just asserted.

Key takeaways

• The engine runs in three tiers, from instant on-device checks to a full-manuscript deep scan, each doing a different job at a different cost.
• Your story bible is a derived registry: facts are extracted from your prose, not typed in by hand, and they self-heal — fix the text and the flag clears itself.
• The deep scan shows a cost estimate and asks for approval before it runs, and uses your own AI key at cost.
• Every finding is a suggestion you review, never a silent edit — the engine fails open by design.
• The full engine is part of NovelCanon Pro; it complements a human editor rather than replacing one.

What does the Consistency Engine do?

It answers one question, continuously: does anything in your story contradict anything else in your story? To do that it has to know what your story claims — that a character has never left the capital, that a journey takes three days, that magic costs a life — and then watch for any later scene that violates one of those claims.

The hard part isn't the checking; it's the knowing. A tool can't cross-reference facts it hasn't captured. So most of the engine is really about turning your prose into a structured set of claims it can reason over — and doing that cheaply enough to run constantly, and accurately enough to be worth trusting. The three tiers are three different trade-offs between speed, cost, and depth.

The three tiers at a glance

Tier	When it runs	What it does	Cost
Tier 1	As you type (after auto-save)	Instant on-device micro-checks — name variants, obvious detail slips	Free, no AI call
Tier 2	When you finish a scene	Extracts the scene's facts into a living registry; classifies contradictions	Small, uses your key
Tier 3	On demand, whole manuscript	Multi-phase deep scan across every tracked fact, thread, and rule	Priced + approved first

Tier 1 — instant checks as you type

The first tier runs entirely on your device, a couple of seconds after your writing auto-saves, and finishes in well under half a second. It makes no AI call and costs nothing, so it can run constantly without touching your provider bill or your flow.

It catches the cheap, high-frequency slips — most usefully, name variants. If you've written "Katherine" ninety times and just typed "Katharine," the engine notices the near-match (it treats small spelling distances as suspicious) and underlines it right in the editor. It's the continuity equivalent of a spell-checker: not clever, but instant, free, and catching the error before you've finished the paragraph.

Tier 2 — the story bible that writes itself

The second tier is where the engine earns its name. When you finish a scene, a background job reads it and extracts the factual claims it contains — who was present, what they now know, where they are, what was established about the world — and files them into a registry. Over a manuscript, that registry becomes a story bible you never had to write: characters, their knowledge, the timeline, the world rules, all derived from the prose itself.

It also classifies what it finds. A new fact that agrees with the record is just added. A new fact that disagrees with the record — she's suddenly in a city the timeline says she can't have reached — is flagged as a candidate contradiction for you to look at. Because this runs as a background job, it never blocks your writing; you keep going while the registry updates behind you.

Tier 3 — the full-manuscript deep scan

The third tier is the one that catches the errors human editors miss: the contradiction four hundred pages apart. It's a multi-phase deep scan that reads the whole manuscript and cross-references every tracked fact, every plot thread, and every world rule against every other. Out come three kinds of finding: contradictions (two facts that can't both be true), dropped threads (a gun on the mantel that never fires), and rule-breaks (magic that stopped costing what you said it costs).

Because it reads the entire book through your AI key, a deep scan has a real cost — so the engine estimates that cost and asks you to approve it before running, and defaults to an economical analysis model to keep the number small. It's resumable, so a long scan can pick up where it left off, and it's designed to fail open: if a phase is uncertain, it surfaces the question rather than pretending it found nothing.

What a finding actually looks like

It's easier to trust when you can picture the output. A deep-scan finding isn't a vague "something might be off." It's specific and sourced: it names the two places in your manuscript that disagree and states the claim each one makes.

A contradiction might read as "Chapter 3 establishes Elena has never left the capital; Chapter 12 has her recalling the coast at Varn." A dropped thread might read as "The sealed letter introduced in Chapter 5 is never opened or referenced again." A rule-break might read as "Chapter 4 establishes that healing magic costs the caster a memory; Chapter 22 heals a wound with no stated cost." In every case you get the two anchors and the conflict between them — enough to jump to the exact scenes and decide, as the author, which one is right. The engine finds the disagreement; you make the call.

Why the facts are "derived," and why that matters

Here's the design decision that makes the whole thing trustworthy: your story bible is not a database you edit. It's a projection of your prose. Every fact in the registry exists because one or more scenes support it. A fact is alive only as long as at least one scene still says so.

This has a property most story-bible tools don't: it self-heals. Suppose the engine flags a contradiction — chapter thirty says brown eyes, chapter three said green. You fix the prose. On the next pass, the scene that supported "brown eyes" no longer does, that fact loses its support and retires itself, and the contradiction it caused simply disappears. You never open a settings panel to reconcile anything. The record follows the text, because the record is the text, structured.

The alternative — a story bible you maintain by hand — has the opposite failure mode: the moment your prose and your bible disagree, the bible is lying to you, and to the AI reading it. A derived registry can't drift from the manuscript, because it has no independent existence to drift to.

Why not just ask a chatbot to check?

A fair question: you could paste chapters into a general AI chatbot and ask it to find contradictions. It'll even catch some. But it has two structural disadvantages for this job. First, no persistent memory — every conversation starts fresh, so it has no durable, structured record of what your story has established across a hundred thousand words. Second, a limited context window — it can only "see" so much text at once, so it physically can't hold your whole manuscript in view to compare a claim in chapter three against one in chapter thirty.

The Consistency Engine is built around those two gaps: it keeps a durable registry of your story's facts that persists between sessions, and it works through the manuscript systematically, in phases, rather than hoping the relevant two scenes happen to be in the same prompt. It uses AI models to do the reading and reasoning — but wrapped in the memory and structure that a raw chat lacks.

What about the AI's own drafts?

There's an obvious risk in any tool that also generates prose: the AI could introduce the very contradictions the engine exists to catch. So generation is wired into the same discipline. When you accept an AI-written passage, it's auto-checked against your characters, timeline, and point of view first — the little Names, Timeline, and POV badges you see are that self-audit reporting back. The AI checks its own draft against your story before you keep it.

And nothing the AI writes is silently committed. Generated text stays highlighted until you accept, dismiss, or regenerate it. You are always the one who decides a sentence is now part of the book. The engine's job is to make sure you're deciding with full information — not to decide for you.

What the engine deliberately doesn't do

An honest explanation has to include the limits, because a checker you over-trust is worse than none.

• It doesn't replace a human editor. It catches mechanical contradictions — facts that disagree. It has no opinion on whether your prose sings, your pacing works, or your ending lands. Those are human judgements and always will be.
• It doesn't edit your text. Every finding is a suggestion. The engine will never rewrite a sentence to "fix" a contradiction on its own — it surfaces the conflict and lets you resolve it in the way the story needs.
• It doesn't delete your work when you revise. Because facts are tied to the scenes that support them, editing a scene retires the facts it no longer supports rather than hard-deleting anything a different scene might still rely on.
• It fails open. When it isn't sure, it raises the question rather than guessing. A missed flag is a disappointment; a wrong silent edit would be a betrayal, so the engine is built to err toward showing you more, not doing more.

Your key, your words

Two last things that matter as much as the checking. First, the deeper tiers run through your own AI provider key — OpenAI, Anthropic, Google, or OpenRouter — so you pay model costs at your provider's rate with no markup, and you can pick a cheaper model for analysis than you'd use for drafting. Second, your manuscript is only ever sent to the provider you chose, under their API terms; NovelCanon never trains on your writing, your key is encrypted and decrypted only in memory for the request you asked for, and you can export or delete everything whenever you want.

That's the engine: three tiers, a story bible derived from your own prose, and a full-book audit you approve and control. If you want the craft context behind why it's built this way, start with the complete guide to story consistency. If you're weighing tools, see how this approach compares in NovelCanon vs Sudowrite and NovelCanon vs Novelcrafter. And if you just want to try it, the workflow is free to start and the full engine lives in Pro.