Why your AI game master forgets — and what we did about it

If you've played an AI text adventure for more than an hour, you've met the failure. You spend three turns searching a study for a ledger. On the fourth, the narrator writes that you slip the ledger into your coat. Two turns later you go to read it and the story has no idea what you're talking about.

The ledger was never real. It was a sentence.

This gets called a memory problem, and the usual fix is more memory — bigger context windows, rolling summaries, retrieval over past turns. Those help at the margins. They don't solve it, because the model didn't forget. The model was allowed to decide, in prose, that something had happened, and nothing checked.

Prose is not a record

A language model writing a scene is doing one thing well: producing plausible, atmospheric, in-voice text. Asking that same pass to also maintain an accurate ledger of world state is asking for two incompatible things at once.

Plausibility is the enemy of accounting. A model will write that you're unharmed because it reads better there, three turns after it wrote that you took a knife between the ribs. It isn't lying. It's optimising for the sentence, which is what it was built to do.

So in Unwritten the two jobs are split. A backend runs the game; a model narrates it. The backend owns health, stress, gold, skill domains, rank, reputation, relationships, dice, combat rounds and act transitions. It hands the narrator a state and receives a scene back. It does not take the narrator's word for what changed.

Two ways to observe a fact

Story milestones — the things that move you from one act to the next — get confirmed one of two ways, and never by asking the storyteller.

Most are checked directly against state. Did your reputation cross a threshold? Is that character dead? Are you carrying the thing? These are deterministic questions with deterministic answers, and no amount of persuasive prose can talk the check into a different result.

The genuinely narrative ones get a second pass. "Did you actually confront her about the letter" isn't a number. So a separate evaluation runs after the turn is written, reads the finished scene, and answers that one question — with no stake in moving the plot along, because advancing the story isn't its job. It re-evaluates every turn, so a milestone can't be missed just because it happened in an unexpected order.

What we never do is ask the narrating model to raise its own hand. Any design that depends on the storyteller remembering to flag its accomplishments will fail — quietly, intermittently, and at the worst possible moment. It's the single most common architectural mistake in this category.

The same rule, pointed at the reverse problem

Once you take the principle seriously, it starts applying in the other direction too.

If the engine only accepts facts the story has genuinely shown, then it also has to prevent the interface from leaking facts the story hasn't shown. The choices offered each turn are generated text like anything else, and generated text is perfectly capable of offering you the option to "ask about the Kestrel contract" before anyone has said the word Kestrel in front of you.

So secrets are gated. Specific names, numbers and revelations are locked until the narrative has actually delivered them, and the release is detected the same deterministic way — did this token appear in the story text, or didn't it. If it hasn't, it cannot appear in your options, and there's a scrubbing pass behind that as a safety net.

What this looks like from the inside

The visible result isn't a feature you can point to on a list. It's an absence — the absence of the moment where the illusion drops.

The companion who warned you about the mine still remembers the warning forty turns later, because that warning was recorded as a promise with a creditor and a deadline, not as a nice paragraph. The wound you took in act one still matters in act three, because it was a number. The oath you broke costs you at a door you haven't reached yet, in a conversation with someone who wasn't there.

None of that requires the model to recall anything. It requires the model to be told, every single turn, exactly what is true right now — and to be prevented from inventing the rest.

The trade we accepted

This costs freedom, and it would be dishonest not to say so.

An open-ended sandbox will let you do literally anything, because nothing is tracked and therefore nothing can be contradicted. Unwritten won't. Its worlds are authored in advance with a defined cast, a defined bestiary, and a secret that comes apart in a particular order. You act freely inside that frame. You can't rewrite the frame.

If unconstrained improvisation is what you're after, a sandbox is the better tool and we'd genuinely point you at one — the comparison is here. If what you want is a story that still holds together on turn two hundred, that's the trade we made, and we'd make it again.