Skip to content

CRI Platform

Give characters a history. See why they changed. Test what caused it.

CRI Platform combines persistent character state with the developer tools needed to understand why behaviour changed, alter the cause and replay the result. It is in development, and its core mechanisms run first inside Luminids, our own game.

Talk to us See the recorded proof

What the layer is for

  • Persistent history Identity, memory, beliefs and relationships can carry across sessions.
  • Individual knowledge Each character knows what actually reached them rather than inheriting the whole simulation.
  • Inspectable causality Trace a response back to the experience and state behind it.
  • Intervention and replay Change one internal cause and test whether the result changes.

01 Why another layer exists

Characters can talk. Keeping them coherent over time is still bespoke.

Persistent characters still force teams to connect memory, relationships, save state, world events, model context, authoring, debugging and behavioural testing.

Context is assembled for a moment. Character state is held by the individual, saved with it and revised by what happens next, where developers can inspect and revise it.

  • Each character sees only part of the world.

  • Memory has to survive a save.

  • Every relationship has two sides.

  • Character updates share the game’s frame budget.

These layers can work together. CRI provides the persistent character state underneath the model interaction.
Character architecture Prompt and context layer CRI character state
Continuity History can be assembled for a model interaction History stays with the character across interactions and saves
Knowledge Retrieved context informs the current model turn Character-specific evidence defines what this individual can know
Memory Memory can inform generated output Memory can revise beliefs, expectations and other persistent state
Inspection Inspect context and generated output Inspect evidence, state, response and revision
Model role Interpret the character context it receives Express state held outside the model

02 The platform

CRI sits between world state and expression.

Events come in from your game, character state carries them forward, and a response goes back. A language model is optional, and sits at the end.

CRI Engine updates the character. The character’s state carries what it remembers and believes.

Author what a character starts believing. Open a live one and read why it acted, using character state and CRI Trace.

Snapshot a situation, change one thing and run it again. Keep the difference as a test, using character state and CRI Trace.

Your game

The platform is designed to sit under the engine you already use.

  • Unity
  • Unreal Engine
  • Godot
  • Your own engine

Target environments. No integration is shipped.

World adapters

Events in what happened, to whom, where Behaviour out what the character does next

CRI Engine runtime
  1. saw only what reached it
  2. remembered and can forget
  3. believed and can be wrong
  4. responded from what it holds
Character state

One per character: memory, belief, expectation, relationship. It survives saving and loading, so a character is the same one when the player comes back.

CRI Trace

The shared record of events, character state and consequences, used by Studio and Bench.

  1. evidence What reached this character, and nothing it did not see.
  2. state What it now holds: memory, belief, expectation, relationship.
  3. intent What it means to do next, given that state.
  4. action What it did, back into the world.
  5. outcome What the world returned.
  6. revision What changed in the character because of it.

Connectors optional

Model connectors are designed to turn a character's state into words. The character keeps its history and beliefs when the model changes.

  • Anthropic Claude
  • OpenAI GPT
  • Google Gemini
  • Open-weight, run locally

Follow one event through the platform Follow the reaction recorded in Luminids at 123.3 s

  1. 01 / 9 Your game 123.3 s into the recorded day: Astra is caught again. The game records it once.
  2. 02 / 9 Events in World adapters connect game events to individual characters. In this example, the record follows what happened to Astra.
  3. 03 / 9 Saw Astra lives the moment: Astra is caught again.
  4. 04 / 9 Remembered The leg is stored as first-hand evidence against the idea that Astra is the fast one.
  5. 05 / 9 Believed The belief is dropped: two contradictions in a row and Astra no longer holds it.
  6. 06 / 9 Responded Astra shows the question and a quiet pause, and the day goes into their life story as "The day the fast one got caught".
  7. 07 / 9 Character state Her record changes: the belief is dropped and shaken once. The catch adds one line to her life story.
  8. 08 / 9 CRI Trace Every step above is on the record. Replay the day with the belief cleared and the log reads: Nothing to contradict: Astra holds no belief about being the fast one, so the loss lands as an ordinary event.
  9. 09 / 9 Behaviour out She reacts, and the behaviour goes back to the game: no spoken line, and "The day the fast one got caught" in her life story.
Open the recorded run

03 The workflow

When a character changes, know why.

Persistent characters create a new development workflow.

Teams need to see what changed, understand what caused it, and replay the situation after making a fix. Author, run, inspect, intervene, replay, test.

  1. Author and run

    CRI Studio + CRI Engine

    Set starting beliefs, relationships and what each character can know. Run the character in the game, keeping its identity and history across saves.

  2. Inspect and intervene

    CRI Studio

    Follow a decision back to its evidence. Change one belief by hand while keeping the world unchanged, so you can isolate its effect.

  3. Replay and test

    CRI Bench

    Replay the same events from the same starting conditions. Compare the result and keep the difference as a test for future builds.

Inside Luminids, one belief was cleared, the same day replayed, and the reaction disappeared.

Open the recorded run What runs today

From Luminids to CRI Platform

Core CRI mechanisms already run inside Luminids. The next step is to extract a portable Engine and productise the developer workflow for external game teams.

See the roadmap See the evidence

04 Customer zero

Built where it has to work: inside a real game.

Luminids is customer zero, where CRI has to survive saves, frame budgets and real player behaviour.

How CRI becomes a business

The commercial direction starts with low-friction adoption of CRI Engine, then paid studio tooling around Studio, Bench and Trace, production licensing for shipped games, and managed persistence, telemetry and evaluation infrastructure later.

During the design-partner phase we intend to test whether a commercial SDK or open-core model creates the strongest adoption path.

Studio, engine, strategic and investment conversations are welcome. Tell us what your characters need to know, carry forward and change because of.

Talk to us

Built for these games first

  • Life / colony simulation

  • Systemic RPG

  • Social sandbox

  • Companion-led game

And for these roles

  • Technical Director

  • Gameplay / AI Lead

  • Narrative Systems Lead

  • Studio Founder / Engine or Platform Lead