Skip to content

CRI Platform

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

CRI Platform is character AI middleware for your game, with an SDK for your characters and tools to shape, inspect and test their behaviour. It is in development, built first inside Luminids, our own game.

Talk to us See the recorded proof

What CRI gives your characters

  • 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 One platform

Give every character a point of view.

Connect CRI to your game. Shape who your characters become, and understand why they change.

Character AI middleware

CRI Engine

The intelligence behind your characters.

  • Memory Experiences carried across saves.
  • Beliefs Their own view of the world.
  • Relationships Their history with others.

Game events in. Character responses out. World adapters connect CRI to your behaviour trees, state machines or GOAP.

Developer workspace

CRI Studio

Build, inspect and test your characters.

  • Author

    Shape beliefs and relationships.

  • Inspect

    Follow a response back to its cause.

    With CRI Trace

  • Test

    Change one cause. Replay and compare.

    With CRI Bench

02 Built for continuity

The conversation ends. The character continues.

Keep each character’s memory, beliefs and relationships across encounters, with the tools to inspect and change them.

Model context and character state, working together.
Character architecture For each interaction Prompt and context layer Across the character’s life CRI character state
Continuity Receives history as context for an interaction. Keeps history across interactions and saves.
Knowledge Works with the context you supply. Tracks the evidence that reaches each character.
Memory Uses memory to inform generated output. Lets memory revise beliefs, expectations and persistent state.
Inspection Inspect context and generated output. Follow evidence, state, response and revision.
Model role Interprets character context to generate expression. Holds the state a model gives language to.

  • 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.

03 Inside the platform

Follow an event through CRI.

See how a moment in your game reaches a character, changes a belief and becomes a response. Explore the layers below.

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
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

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