AI Characters That Remember You, or Just Your Name

AI characters that remember you are usually remembering two different things at once, and most apps are only good at one of them. A character can hold a steady idea of who she is and who you are — your name, your face, the shape of your acquaintance — and still forget the promise she made you three scenes ago. Almost every continuity failure you meet comes down to which of those two an app stores.

• Three separate things get called character memory: the dossier of who someone is, the transcript of what was said, and the record of what happened.
• A character card holds personality and scenario, so it keeps a voice consistent but cannot notice that a promise was broken.
• A larger context window is not a larger memory; Anthropic’s documentation calls the decay of recall across a long context “context rot”.
• Parser interactive fiction handled a narrow version of this decades ago by tracking, character by character, which facts each one knew.
• Four moves, run in a single sitting, will tell you which kind of memory the app in your hand has.

Three separate things get called character memory

The first is the dossier. A community format for AI character files, the V2 character card specification, defines a character as a bundle of fields: a description, a personality, a scenario, an opening message, and an optional character_book that frontends “MUST use by default.” All of it is written before you arrive, and all of it is true on turn one and turn four hundred alike.

The second is the transcript: the scenes themselves, carried forward as text. It is complete and it is fragile, because it grows without limit while the space it must fit into does not. Something eventually gets dropped, summarized, or simply read less carefully than the paragraph immediately before the model’s reply.

The third is the record: a structured account of what has happened, kept apart from the prose. Facts, the people who hold them, places, obligations still outstanding. Fabledrift, an interactive fiction app for Android, keeps this third kind and hands it to the narrator on every turn, alongside the scenes themselves.

Do AI characters that remember you also remember the story?

Often not, because the two problems have different shapes. AI characters that remember you are solving a profile problem: a small set of durable attributes that rarely change and can be written down once. Remembering the story is an event problem, where the important facts are created as you go, contradict each other, and belong to particular people rather than to the world at large.

The failure this produces is specific enough to recognize. A character greets you warmly by name, in a voice that has not drifted since the first scene, and has no idea that she agreed to meet you at the ford. The warmth is the dossier working. The forgotten meeting is the absence of a record.

It is a harder failure to spot than plain amnesia, because everything on the surface looks correct. Nobody calls you by the wrong name. Nobody suddenly speaks in a different register. The character simply has no history with you, and the story flattens into a series of well-acted first meetings.

Why a bigger context window is not a bigger memory

Vendors advertise a million tokens of memory and readers hear a million tokens of recall. Anthropic’s own documentation on context windows is more careful, describing the window as “working memory” and warning that “as token count grows, accuracy and recall degrade, a phenomenon known as context rot.” Room is not the same as attention.

That page draws the conclusion plainly: curating what is in context matters as much as how much space is available. A story that has been running for forty scenes does not need all forty in front of the narrator. It needs the six facts that scene forty-one can contradict, and it needs them stated rather than buried.

There is a second reason the size figure misleads. Context is per request, and a story you return to next week is not one long request. Something has to survive the gap in a form that can be rebuilt, which makes continuity a storage question before it is a model question. No context length answers it.

How parser interactive fiction tracked what a character knew

The problem is older than language models, and the old solutions are instructive. Threaded Conversation, an extension for Inform 7, describes itself as “a conversation system tracking facts known, phrases spoken, and subjects of conversation” — three registers kept deliberately apart.

What matters is where the knowledge lives. The extension defines a fact-awareness relation between characters and facts, so learning something during a scene is recorded as the listener knowing that fact, and a separate relation with the verb “to recollect” tracks which lines a character has already heard. One rule holds that if the current speaker recollects a line, offering it again is implausible.

That is a per-character index of knowledge, not a shared pool. It is why a well-built parser game can let you tell one character a secret and watch a second character stay ignorant of it. The cost is that a human author had to enumerate every fact in advance. An AI narrator has to derive them from prose as the prose is written, which is the harder half of the work.

Who knows what, and why it matters

Continuity that readers actually notice is nearly always relational. She promised. He was not told. They saw you leave. A single global memory of “what happened” gets the events right and the ownership wrong, which produces a character who knows something she was never present for. The Emberwood, our fantasy world, is described as a forest that remembers every promise made beneath its branches; a promise with no one attached to it is not much of a promise.

A five-minute test for character memory

You can settle the question yourself without reading any marketing copy. Run these four moves in one sitting, in whatever app you are evaluating, and watch what the replies depend on.

Move	What a dossier gives you	What a record gives you
Ask a character about something she told you two scenes ago, without restating it	A plausible answer invented fresh, often subtly different	The same detail, in the same terms she used
Break a small promise, then return to her	Ordinary warmth, unchanged	A cooler greeting, or the promise raised
Tell character B something character A told you privately	No distinction; the world knows what you know	A reaction that treats it as news
Close the app for a week, then open the story	A clean, friendly restart	The outstanding obligation still outstanding

The third move is the sharpest of the four, because it separates a genuine per-character record from a single pile of story facts. The fourth separates memory from session context: an app that forgets across a week was holding the conversation, not the story.

None of this requires you to be adversarial. Written as ordinary moves in the fiction rather than as questions aimed at the machine, the test costs you nothing narratively — a point we have made about how to talk to characters in AI stories instead of talking to the narrator about them.

What a character should still know in scene forty

AI characters that remember you are cheap to build; characters that still remember scene five are not. By scene forty a good story has accumulated obligations, and the test of an AI narrator is whether its people are still carrying them. Two things make that checkable rather than a matter of faith. The first is a journal you can open to see what the AI narrator remembers about each person, and correct when it has drifted. The second is a note of your own that outranks the record when the two disagree.

Both exist because memory that cannot be inspected cannot be trusted, and neither is something we charge for. If you want to audit a finished story end to end, the plainest method is still to export the story as text and read it as a document, watching for the promise that was made in one scene and quietly dropped by the next.