Decipher Engine: an AI storytelling platform that remembers what happened
decipherengine.ai, the live product
What is Decipher Engine?
A generative fiction platform where stories hold together across hours of play. Thirteen text models, seven image models, voice in and out, and a library that connects characters, scenes, and images across everything you build. Codroon built it and holds equity in the company behind it.
The bet
AI storytelling has one well-known failure: the model forgets. Two hours in, a character's name drifts, a dead character reappears, and the world you were building quietly stops being the world you were building. Every player of these tools has hit it, and most stop playing because of it.
The bet behind Decipher Engine was that the fix isn't a bigger context window. It's treating the story as state (characters, locations, prior events, established facts) and retrieving the relevant parts before each generation rather than hoping the model still holds them. Get that right and the same models everyone else uses produce something that behaves like a world instead of a very good improviser with no memory.
Three decisions that shaped it
The interesting part of a build is rarely the feature list. These are the three calls that determined what Decipher Engine could become.
RAG, pointed at story state
Most retrieval systems answer questions from documents. Decipher Engine's points at the story itself (characters, locations, established events, and prior scenes) so each generation is grounded in what has already been true rather than in whatever survived the context window.
It's the architectural difference between a session that drifts and one that holds. It's also why the platform gets better as a story gets longer, which is the opposite of how these tools usually behave.
- Story state indexed and retrieved per generation, not held in context
- Characters, locations, and events tracked as structured entities
- Continuity that improves with story length rather than degrading
- Model-agnostic: the memory layer survives a model swap
One abstraction, many engines
Thirteen text models through OpenRouter, spanning Anthropic, OpenAI, Google, DeepSeek, and Mistral, plus seven image models through Replicate, including the Flux family, Seedream, and Recraft.
The point isn't the count. It's that narrative registers differ: the model that writes tense action isn't the one that writes dialogue, and cost varies by an order of magnitude across the set. Users pick per story, and the platform falls back cleanly when a provider degrades. Across twenty providers, that's a weekly event rather than a hypothetical.
- 13 text models via OpenRouter, user-selectable per story
- 7 image models via Replicate: Flux, Seedream, Recraft, and others
- Provider degradation handled with automatic fallback
- Swapping or adding a model is configuration, not a rewrite
The thing that makes it a platform
Generated content in most AI tools is disposable. You make it, you scroll past it, it's gone. Decipher Engine's library is the opposite: folders you organise, characters you import into new stories, images generated for a specific character and reused across scenarios, references that carry between worlds.
This is the feature users cite most, and it's the one that turns a generator into a platform. It's also where the hardest product design work went, because organising generated content well is a much harder problem than generating it.
- User-created folders across stories, characters, scenes, and images
- Characters and references importable into any story
- Images generated against a specific character and reused
- Scenario builder: construct the world before the story starts
Text, image, and voice in one loop
A session isn't only text. Images generate inside the story from the same context that wrote the scene: seven models, selectable styles, and formats sized for characters, creatures, locations, or references. ElevenLabs reads the story aloud, and the browser's speech API takes input back, so a session can be spoken rather than typed.
The intent was never four features side by side. It's one loop that reads, speaks, listens, and illustrates, all pulling from the same story state. That's only possible because the memory layer sits underneath all of it rather than beside the text generation.
Where it is now
Decipher Engine is live. Around 5,000 people use it, and they've generated more than 50,000 stories and 10,000 images between them.
It runs on AWS with S3 for media, MongoDB behind it, Stripe for payments, and Grafana for front-end and back-end monitoring. That matters more than it sounds on a platform calling twenty external model providers. When a provider slows down or starts failing, we see it on a dashboard rather than in a support ticket.
Active roadmap rather than a finished product, which is the honest description of anything still being used.
What building it taught us
Three things we now bring to client work because Decipher Engine forced us to learn them.
Retrieval is a memory problem, not a search problem
Most RAG builds are search with extra steps. Building retrieval for narrative continuity meant thinking about what state matters, when to retrieve it, and how to keep it consistent. That turns out to be the right way to think about retrieval for any long-running AI system.
Generative AI DevelopmentTwenty providers is an orchestration problem
Running that many models in production taught us routing, fallback, cost control, and how to design so a provider outage degrades rather than breaks. It's the first thing we architect for on any multi-model build now.
AI Agent DevelopmentObservability isn't optional once you depend on other people's APIs
Grafana across the front end and back end is how we know a model provider is degrading before users tell us. On any product built on external AI services, this is the difference between a bad hour and a bad week.
SaaS Development
Decipher Engine in numbers
- 5,000+users
- 50,000+stories generated
- 10,000+images generated
- 20+models across text and image
Try it, or build something like it
Decipher Engine is live and you can use it today. If you're building something that needs AI to stay coherent over long sessions, that's the work we do.