Canon Guardian: Giving Shared Cinematic Universes a Memory

Devendiran K — Wed, 12 Aug 2026 12:46:21 +0000

Built during the Hindsight hackathon — how persistent memory turned a generic script-coverage idea into something that actually catches mistakes a stateless AI never could.

The problem nobody's solving

Ask anyone who's worked on a long-running franchise — comics, TV, film — and they'll tell you the same thing: keeping continuity straight across a shared universe is genuinely hard. A character died in film three. A magic system has a specific cost. A timeline only makes sense in a certain order. None of that lives in any single script — it lives in the accumulated history of everything that came before.

AI script-coverage tools already exist, and they're good at what they do: read a script, flag pacing issues, predict market fit. But every one of them analyzes a single document in isolation. None of them know what happened in the other fourteen films in your universe, because they have no memory between sessions. Ask the same tool about the same universe twice, and it starts from zero both times.

That's the gap Canon Guardian is built to close.

The idea

Canon Guardian is an AI agent for shared cinematic universes. A director submits a one-line pitch. The agent checks it against everything established in the universe so far — every character, every death, every world rule, every timeline marker — and against that specific director's own history of past pitches and decisions. Only then does it move on to the parts a normal coverage tool does well: comparable stories, benefits, risks, and a recommendation.

The differentiator isn't the analysis step. It's that the agent actually remembers.

Why Hindsight, specifically

We built this on Hindsight, a memory system with three core operations: Retain, Recall, and Reflect. This mapped onto the problem more precisely than we expected going in.

Retain doesn't just store text — it extracts entities and temporal data automatically. When we retained a fact like "Lyra Voss dies sealing a magical rift in 'The Fifth Age: Requiem'", Hindsight resolved "Lyra Voss" as an entity and the event as something tied to a specific point in the universe's timeline, not just a string of text sitting in a database.

Recall runs against that structured memory using multiple strategies, not just keyword matching. In testing, this meant it could surface a director's prior pitch even when the new pitch's wording had almost nothing in common with the old one — because the connection was the entity (the same character, the same rule), not the phrasing.

Reflect is the part that made this feel like more than a lookup table. After a handful of decisions accumulated in the memory bank, we triggered a reflect() call and got back a genuinely synthesized statement — not a list of past decisions, but an inferred policy: that pitches touching cost-free magic or unresolved character deaths in this universe consistently required revision. Nobody wrote that rule explicitly. The system noticed it.

The test that actually proved it

Talk is cheap, so we ran a controlled comparison. We created two memory banks with identical missions and identical directives — one seeded with our test universe's canon, one left completely empty. Then we ran the exact same pitch through both:

"Lyra Voss returns using a new spell that costs her nothing, to help resurrect Osric Bellweather and defeat a new threat."

Against the empty bank, the agent caught one conflict — the cost-free magic, since that's stated directly in the directive text. But it had no idea Lyra Voss had died. It treated her as available for the story beat, because nothing told it otherwise.

Against the seeded bank, the same model, same directives, caught both violations by name — citing the specific film where each rule was established — and additionally surfaced the submitting director's near-identical prior pitch on this exact character, along with the note they'd received last time.

The empty-bank run wasn't just a weaker answer. It was wrong. That's the whole argument for persistent memory in one side-by-side test: without it, a fluent AI system can sound confident while being factually incorrect about the world it's supposed to know.

What we'd build next

Given more time, the natural extensions are a rights/IP conflict layer alongside the story-canon check, a cross-director overlap alert so two writers pitching similar ideas independently get flagged before they collide, and a visual timeline showing where a new pitch would sit relative to the rest of the universe.

But the core lesson from this build stands on its own: memory isn't a feature you bolt onto an agent to make it feel smarter. In a domain like continuity tracking, it's the difference between an agent that's occasionally right by coincidence and one that's actually accountable to the facts it's supposed to know.

Built with Hindsight (Retain/Recall/Reflect) and Groq for inference. Code and full write-up available on GitHub.

DEV Community: Devendiran K

Canon Guardian: Giving Shared Cinematic Universes a Memory