Case Study · Design & Development
A persistent, self-managed memory engine for AI agents, so a model still knows who you are and what you're building across sessions, weeks, and the life of a project.
Large language models don't remember. Each conversation runs inside a context window that holds the present exchange and nothing else. End the session, start again, and the names, the decisions, the preferences, the whole history are gone. The window is a rolling buffer, not a memory. For anything meant to run longer than a single sitting, an assistant you talk to for months, an agent working a project over weeks, that's the wall you hit first.
The usual patches don't hold. Paste the old transcript back into the prompt and you pay for it on every turn until it overflows. Dump every message into a vector store and you can retrieve text, but you can't tell what happened from what's currently true, or which fact quietly replaced which. What's missing isn't a bigger buffer. It's memory with structure, and an agent able to keep it in order itself.
The Recallatron is a persistent memory server for AI agents, exposed over the Model Context Protocol. Any MCP-compatible agent, whether Claude Desktop or a custom agent running on Claude, GPT, or Gemini, reads and writes its memory directly, with no bespoke integration. It's built and running in production behind the studio's own tools; a public exhibition is forthcoming.
Memory is organized as five strata, mapped onto the three faculties cognitive science names: episodic (what happened), semantic (what's true), and procedural (how things are done). An append-only ledger is the source of record. Everything above it is derived, versioned, and curated.
How it's built
No single trick. A record that never loses anything, structured memory derived from it, and a set of tools the agent uses to keep the whole thing in order.
An append-only record of every exchange. Each turn is written once and never edited or deleted, searchable to the word. It's the source of truth the other four strata derive from, so nothing downstream can invent a past that didn't happen.
Every session is distilled into a structured précis: the topics raised, the people involved, the decisions reached. An agent picks up where it left off from the digest, without replaying the whole transcript to get its bearings.
Recurring concerns are indexed and cross-referenced under stable names, so scattered mentions of the same matter, weeks apart and across different sessions, find each other instead of living as disconnected fragments.
People, projects, deadlines, preferences, and the relationships between them, held as a graph and versioned through time. When a fact changes, the old one is superseded rather than overwritten. The prior truth stays on a reviewable chain, so nothing is silently corrupted.
Twenty-six MCP tools by which the agent retrieves, writes, and curates its own memory, on its own initiative. This is memory the model manages, not context injected into its prompt by a wrapper it can't see.
A scheduled pass prunes, compacts, and curates the archive on its own: merging duplicates, retiring stale threads, keeping recall fast and the graph clean without a hand laid on it.
Model Context Protocol · 26-tool agent surface · append-only episodic ledger · versioned entity graph · automated session digests · self-scheduled maintenance.
What this shows
Keeping text is easy. The work is in the rest: knowing the difference between what happened and what's true, versioning every fact so nothing is quietly corrupted, and handing the agent the tools to maintain its own archive. The Recallatron is built on the episodic, semantic, and procedural split from cognitive science and current agent research, not a single embedding store with search bolted on.
This is the kind of infrastructure Novadiem builds: model-agnostic systems that sit around the LLM and make it useful past the demo. Persistent memory, agentic tooling, and the MCP surfaces that connect them, running in production on our own property. A public release is coming; the engine already works.
Model-agnostic LLM layers, agentic tooling, and the memory and web platforms they run on, designed and built from one practice.
