Agent Smith as the Hippocampus

Published Mar 28, 2026

LLMs feel intelligent right up until continuity matters. A larger context window delays forgetting, but it does not solve it. The context window is working memory: fast, useful, and temporary. Identity requires something else: a durable way to decide what from the present should survive into the future.

That is why the hippocampus is the right metaphor for Agent Smith. The hippocampus is not the whole mind, and it is not permanent storage. It is the structure that helps experience become memory, and helps memory return when needed. Agent Smith should be understood the same way: not as a mystical super-agent, but as the continuation layer that mediates between live computation and persistent datom streams.

What the Hippocampus Actually Does

If Agent Smith is the hippocampus, its job is not to replace model inference. Its job is to manage the passage between immediate experience and durable memory. In practice, that means three stream operations:

Selective encoding : observe interaction and execution streams, identify datoms worth preserving, and emit candidate memory assertions
Consolidation : transform episodic slices into more stable summaries, indexes, and links while preserving the original stream
Contextual reconstruction : when an active continuation needs relevant context, query bounded memory streams and assemble a fresh memory from the datoms required to continue

The third operation is where the hippocampal metaphor stops being decoration. Human memory is not retrieval from storage. It is reconstruction: the brain rebuilds each recalled memory from traces, shaped by the present context in which it is needed. Datom.world works the same way. Nothing sits in storage as a finished memory waiting to be fetched. Every recall is a fresh construction over the stream, built in real time by whichever interpreter the current continuation requires.

Each of these is just stream processing. Nothing magical happens behind the curtain. A memory write is a datom emission. A recall is a query, a reconstruction, and a resumed continuation.

One Stream, Many Materializations

Agents today store memory in many substrates. Prompt fragments, vector indexes, knowledge graphs, fine-tuned weights, execution logs, markdown notes, and mutable runtime objects are all in active use, often in combination. None of these are wrong in themselves. Each captures something real about how an agent relates to its past.

The problem is not the substrate. The problem is treating any one substrate as the ground truth. When a vector store or a weight update is primary, the stream of events that produced it becomes implicit. Nothing can replay it, migrate it, or reinterpret it under a different ontology. The substrate is frozen at the moment of its materialization, and every later query is a negotiation with that frozen shape. This is structural decoherence in the memory layer: without a canonical stream as source of truth, the substrate and the events that produced it drift apart, and nothing can reconcile them.

Datom.world inverts this relationship. The stream is primary, and it is one-dimensional: an ordered sequence of transactions, base reality with a single time axis. Everything else is a construction of the stream, built by adding dimensions the stream does not carry on its own. A knowledge graph constructs a graph-topology space, assembling explicit nodes and edges from tuples that carry no graph structure. A vector index constructs a geometric similarity space, where distance between encoded content approximates semantic relatedness. Fine-tuned weights, when used as memory, construct a high-dimensional parameter space, dynamically rebuilt from the stream on demand rather than stored as a fixed artifact. Summaries and logs construct interpretive or temporal framings, selecting and shaping slices for a particular consumer. The same stream can support all of these at once. Each construction adds dimension to the same underlying one. That means a materialization can be destroyed without fear, because the facts are still in the stream. The materialization can always be reconstructed as needed from those facts.

Because the knowledge base exists as a persistent, append-only stream of datoms, memory can be constructed and reconstructed from this continuous flow. It is a temporal fabric that can be traversed in any direction, even backwards in time, to recover the exact context of a past decision.

Consider markdown memory as an illustration. When notes are stored as natural language and that prose is the primary record, retrieval forces the LLM to re-parse the language every time. Part of the model's computation is spent recovering structure from prose before it can even begin reasoning about the content. This is not a property of markdown itself. It is a property of treating markdown as the ground truth instead of as a view over a stream that already carries the structure.

Datom.world's answer is to make memory appear as data first. If a system learns something, that learning exists as datoms in a stream, and prose or markdown views become constructions of that stream rather than replacements for it. An ontology over attributes acts like a type system for memory: it gives the a position stable meaning, constrains what kinds of values belong there, and lets interpreters query explicit facts directly. Instead of asking the model to reconstruct semantics from prose, the system can operate on already-structured memory. This also minimizes hallucination by narrowing the space of valid interpretations: the model has less latent structure to invent, and the runtime has clearer grounds to reject invalid assertions.

Raw observations remain immutable datoms in append order
Promoted memories are explicit assertions with transaction and metadata context
Summaries, indexes, and graphs are interpretable constructions over the stream, not replacements for it

Running through all of this is a single architectural commitment: memory is not the model's hidden state. It is data the runtime can inspect, replay, migrate, and query. Agent Smith is the part of the system that keeps it that way.

Mapping the System

Once memory is explicit, the architecture becomes much easier to reason about. The roles are separate:

Model runtime : a predictive coprocessor that consumes bounded context and emits proposals
Context window : working memory for the current inference, not the durable source of truth
Active continuation : the current control state, captured environment, and point of suspension
DaoStream : append-only history in transaction order
DaoDB : bounded, queryable memory built from those streams
Agent Smith : one or more continuations that watch streams, decide what matters, and route relevant datoms back into execution

This division matters because it preserves the central invariant of the system: interpretation is local and explicit. Storage does not decide meaning. Interpreters do.

Episodic Memory and Semantic Memory

Not every fact should enter long-term memory in the same form. Some datoms are episodic: this page was visited, this tool call failed, this continuation paused at a specific transaction. Others are semantic: this person prefers a style, this node has a capability, this code entity has a specific content hash.

The important point is that semantic memory does not overwrite episodic memory. It is built from it. The raw stream remains available. A summary is a construction, not a replacement. The same bounded stream can support multiple interpretations without forcing them into one ontology.

Agents Are Continuations, Not Sessions

The strongest consequence of this architecture is also the simplest one: agents are continuations, and Agent Smith is no exception. When memory is needed, the active continuation can park. A retrieval continuation can query DaoDB. Execution then resumes with the returned datoms.

What resumes is not a session token and not merely a stream offset. It is the suspended control state plus captured bindings plus references into the surrounding streams. That is why memory access belongs inside the VM model rather than outside it as an opaque API call. The pause, query, and resume cycle is explicit, inspectable, and portable.

Why Restrictions Matter

This only works if the system keeps its restrictions. If memory can leak into hidden globals, mutable caches, or callback side channels, the architecture stops being explicit and auditable. It becomes a system of informal conventions rather than one grounded in datoms and streams.

No hidden global state : memory is asserted into streams, not smuggled into singleton objects
No implicit control flow : retrieval and consolidation happen as continuations or interpreters with explicit boundaries
No assumed graph : associations are constructed from tuples and queries, not baked into storage
No collapse of interpretation and execution : one interpreter may build summaries while another executes code over the same facts

These constraints are not aesthetic preferences. They are what make the memory system auditable. They are what let the same stream support debugging, replay, safety checks, and migration without inventing a second hidden runtime.

From Memory to Governance

Once memory is explicit, governance becomes tractable. Agent Smith can fork speculative continuations, retrieve different memory slices for each branch, and compare outcomes before anything is committed back into durable storage.

Structurally, this resembles Feynman's path integral. Instead of treating the future as one privileged trajectory, the system can materialize multiple candidate histories, run them under explicit constraints, inspect their effects, and then commit one realized history back into the stream. The analogy is not literal physics. There are no amplitudes here, only speculative continuations and policy-checked outcomes. But the history-first shape is the same.

Fork : branch the current continuation into candidate futures
Retrieve : gather the relevant datoms for each branch from bounded memory streams
Simulate : run each branch under explicit capability constraints
Evaluate : inspect effects and choose which branch, if any, should survive
Commit : append the selected results as new datoms

That is a much stronger model than hoping a prompt remembers enough context to behave. It places creativity in proposal generation and authority in the interpreter layer.

A Better Way to Think About AI Memory

The wrong question is how to stuff more tokens into a prompt. The better question is how to give a system durable, causal memory without sacrificing auditability or mobility. Datom.world answers by keeping the model narrow and the memory explicit.

Agent Smith is the hippocampus because it sits between now and forever. It watches live streams, helps decide what should persist, and returns the right fragments of the past when the present needs them. Not by hiding memory inside a bigger black box, but by making memory itself part of the same datom world as code, state, and effects.