Today’s AI roleplay is gone the moment you stop playing

You spend three hours with an AI character. She remembers that you saved her, remembers the argument in carriage four, remembers the lie you told. Then you close the window.

You come back the next day. She’s still there — but she isn’t that her anymore. Context truncated, memory compressed, character reset. Those three hours aren’t a history you can return to. They’re a conversation that evaporated.

This is the shared flaw of almost every AI roleplay product today: play state is a side effect of the conversation, not a first-class citizen. You can’t save at a specific moment, can’t go back to a fork and re-choose, can’t hand “my Elena already reached the dark ending” to a friend so they can continue from there.

Our answer: make both the world and the soul version-controlled

WorldLines borrows a well-proven idea from software engineering — the commit-tree.

Anyone who writes code knows git: each meaningful change is a commit, commits form a branchable tree, any node can be reproduced exactly, branched from, or pushed to someone else.

We apply the same thing to narrative. Three kinds of things carry versions in WorldLines:

  • World — a playable story stage. An author publishes dark-train@2.0 — that’s its “creator version.”

  • Soul — a character with a personality kernel. She has her own memory, values, and limits; she can be your avatar or an NPC in the world.

  • Play itself — this is the key. Every meaningful turn you play generates a commit: the world state at that moment + each character soul’s state + every agent’s full conversation context, hashed into a tamper-proof identity.

The hash isn’t a label stuck on afterward — the hash is the identity of that state. The same content computes to the same hash on any machine. Which means:

  • Save at any moment — not “the last autosave,” but every turn, on the record.

  • Return to a fork — branch a new storyline from any commit; the original history stays intact.

  • Truly portable — take a commit to another machine (even a browser), continue from that moment, and the result is identical to the original machine.

  • Shareable — “I got this far, continue from here” becomes a single commit hash.

A soul doesn’t forget just because you closed the window

A Soul is more than a character card. Her memory splits into short-term and long-term, consolidates or fades based on emotion and importance, draws closer through intimacy and pulls away on value conflict — and these states go into her own independent commit chain, every turn.

She doesn’t know which world she’s in (her commits never record world information), so the same “Elena who has already lived through the dark-train ending” can be carried into a completely different story. A soul is an asset that circulates independently.

What actually happens — Elena, file by file

You import a character card. WorldLines unpacks it into a soul folder. Who Elena is — core traits, values, backstory — lands in persona/ and background/, and those are frozen: nothing overwrites them after creation. That’s the part a character card already gives you today; we just stop letting it rot.

Then you play, and every action touches a specific file that a specific agent is the only one allowed to write:

  • You buy a sword. soul-action writes character/inventory.json and character/wallet.json. Gold down, blade in the bag — on disk, not in a context window.

  • You talk to her. soul-dialogue and soul-memory write short-term-memo/ (conversation_cache.json, recent_events.json) — the working memory of this session.

  • Something lands emotionally — she starts to trust you, or you crossed her. soul-memory consolidates it up into long-term-memo/: important_events.md, and the part you’re really asking about — how close Elena feels to you lives in long-term-memo/emotional_memories.json, rewritten as the relationship moves. The persona/relationships.json baseline never changes; the felt distance is long-term memory, not persona.

Every turn, that whole soul state is hashed into one commit on Elena’s own chain — a chain that never records which world she’s in.

Iterating across world versions

The world author ships dark-train@2.0. You bring the same Elena in. Because her commit chain is hers and carries no world data:

  • persona/ / background/ — identical. She is the same person.

  • long-term-memo/ — comes with her. She still remembers the dark-train ending, still feels what she felt about you.

  • short-term-memo/ — a fresh instance starts clean; session scratch doesn’t bleed across playthroughs.

  • character/ — your call at fork time: start her gear fresh or carry it. It’s just files you choose to include.

Short-term is per-playthrough scratch; long-term and persona are her; the world is a separate chain she never points back at.

What this changes for everyday AI chat

In Character.AI or a SillyTavern session, everything above is one single thing: tokens in a context window. Your inventory, how close she feels, what happened three hours ago — it exists only until the window fills or you close the tab. There is no inventory.json. There is no commit. “Continue from where we were” is best-effort re-summarization.

WorldLines makes each of those a file you own and a hashed commit you can save at any turn, branch from, hand to a friend, and replay identically on another machine. Same character-card start — the difference is that everything after the first message stops evaporating.

The endgame: a world that’s been played becomes a community

The real ambition of this system lies further out.

When a single commit of a world can be distributed, it stops being “a static story module.” It’s a living node: others can fork it, continue from where you stopped, check their continuation back in, and form discussion underneath it. The worldview itself can be maintained, expanded, and continued on a schedule — by a group of people, not a single author.

That’s what WorldLines’ hub system is ultimately growing into: not a story store, but a narrative tree everyone can graft onto. Git let programmers worldwide collaborate on the same codebase; we want players and creators worldwide to collaborate on the same continuously growing story world.

Where we are now

The WorldHub and SoulHub distribution pipelines, the three-axis version model (creator version / instance / commit), and cross-machine reproducible commit snapshots — the foundation is design-locked and being implemented. The multi-agent runtime (one world agent coordinating N character agents, each with an independent mind running its own model) is the core engineering work coming next.

Those three hours of yours shouldn’t evaporate. They should be a node you can go back to — a tree that can keep growing.

— Ludic Dynamics

Ludic Dynamics
Ludic Dynamics Building AI-driven worlds from Tokyo.