We ran one AI roleplaying world to 5,011 turns and published its event record.

There is one world artifact sealed at turn 5,011. Its indexed player actions and displayed mechanical receipts are available in a public record you can page through right now (jump straight to the record). Not a highlight claim of every raw prompt, response, or database row. The artifact runs from the opening beat to turn 5,011. We did not publish it because reaching that number was hard. We published it because you can check it. The honest short version: go look, then decide whether the rest of this is credible.

Why these games fall apart the longer you play

A transcript-only setup has a known long-context challenge. The model does not hold a durable memory of your game. It holds a conversation, and it re-reads that conversation every time it writes the next line. As the conversation grows, the model's ability to reliably use everything inside it degrades. Independent research has documented the effect and given it a name: context rot. Recall does not fall off a cliff, it erodes. Details from early on get summarized, then approximated, then quietly contradicted. A merchant you robbed on turn 40 greets you like a stranger on turn 900. A faction you dismantled is running the city again. The world does not break in one loud moment. It drifts.

This is not a description of every dedicated product. Many add summaries, memory banks, embeddings, authored lore, and structured state. If the story's truth lives only inside the model's context, the story's truth is subject to the same erosion as everything else in that context. Length is the enemy, and roleplaying campaigns are the longest-running use these systems get.

How the field handles memory today

The common approaches are reasonable, and I want to describe them fairly rather than knock down strawmen.

One is the rolling summary: periodically compress the history into a shorter recap and carry the recap forward. It keeps the window small, and it loses resolution every time it compresses, because a summary is a lossy thing by definition.

Another is a small pinned context: a handful of facts the system always keeps in front of the model. It is reliable for exactly those facts and blind to everything you did not think to pin.

A third is a retrieval memory bank: store past events, and when a new turn comes in, pull back the ones that look most relevant and hand them to the model. It scales better than the other two, and it is only as good as the match on any given turn. When it fetches the wrong slice, or nothing, the model is back to improvising.

These can all work, and serious services combine several of them. Their results should be compared with the same repeatable probe and stated configuration. A public artifact adds evidence for one run, but it is not a substitute for a controlled head-to-head benchmark.

What we did differently

We stopped asking the model to be the keeper of the record.

In Creation OS, the state of the world lives on our servers, not in the model's context. The AI reads the world and narrates from it. It does not own it, and it cannot silently overwrite it. When something becomes true in a supported system, such as currency, inventory, quests, factions, relationships, properties, or production, that change can be written to a record the model does not control. The Narrator receives a curated view of current state plus retrieved narrative context.

The consequence of that arrangement is the whole point. Supported mechanical state does not have to be re-derived from a compressed transcript. The language model is treated as a stateless engine for reasoning and prose: excellent at deciding how a scene should read and how a character should speak, never trusted to remember what happened. Narrative is its job. Truth is not. That separation is the guarantee. I am describing the shape of it, not the build, and the shape is the part that matters: the world is a record the model reads, not a memory the model keeps. That record is read the same way on turn 5,000 as on turn 5. The design does not treat a large number as a special case, which is the whole reason a large number is not a problem.

End to end at 5,011 turns

So here is one world artifact at turn 5,011. It indexes player actions and displayed mechanical receipts in order; it is not every raw input and output from the run. This is the campaign we put on the public record, so you can inspect the evidence it actually exposes. It supports claims about this run, not every detail or every campaign.

Here is what the artifact and audit support. The campaign's characters, factions, quests, and locations were all still present and intact at turn 5,011, and the published artifact was generated from server-held data. Indexed actions and displayed receipts are in the record, page by page, in the order it happened.

When I say “verified,” I want to be precise, because this is exactly the sort of word people use loosely. We did not ask the AI whether it remembered. Asking a language model whether it remembers something is worthless: it will confidently answer either way. Instead we compared the server's own records at turn 5,011 against the state of the world at the start of the run, and confirmed the audited entity categories persisted. The check is mechanical. It does not run through the narrator's confidence at all. That is the difference between a claim and a receipt, and it is the entire reason we published the ledger instead of a testimonial.

What this proves, what it does not, and what we are keeping to ourselves

Two honest caveats, because a piece like this loses its point the moment it overreaches.

First, on scope. This is proof of persistence, verified at 5,011 turns. It is not a claim of flawless recall at every single moment of the story. The narrator is still a language model. It can phrase something loosely, lean on a detail, or color a scene in a way you would have written differently. That is precisely why we do not let it own the truth. When the prose gets loose, the record does not move. The persistence is the strong, exact claim. The narration is good, and by design it is not perfect, and I would rather say that plainly than sell you an absolute I cannot back.

Second, this is not an independent third-party audit. Creation OS produced the run and checked it against its server records. The published artifact makes the stated result inspectable, but it does not expose every internal input or establish competitor performance.

Go check it

I am not going to close by asking you to sign up. I would rather you open the record.

Pull up the 5,011-turn ledger and page through it. Find a consequence early in the run and trace it forward. See whether the world still holds it thousands of turns later. Then run the same probe in the service you are considering and compare the results yourself.