Substrate memory vs. the memory MCPs

Mem0 is a memory layer added to an existing agent. Letta is a runtime in which the agent's memory is part of its own execution state. Zep builds a temporal knowledge graph from conversation history. Each is real, shipping software, and none of the three is built around a graph that a population of agents write to and reason on together.

Coverage of this category is usually organized around recall accuracy: how much of what was said earlier a tool can retrieve when asked. LongMemEval, a benchmark built for that question, reports Zep’s Graphiti backend at 63.8% and Mem0 at 49.0%, both measured against GPT-4o. Those figures describe a real property: single-user, single-agent recall over a conversation history. Substrate memory is not built for that axis and has not been measured against it.

The question this page asks instead is who is allowed to write to the memory, and what happens to a write that later turns out to be wrong.

Letta’s shared memory blocks come closest to what a substrate provides: a block can be created independently of any one agent, attached to several agents by ID, and read and written by all of them. The distinction is in what a write does. Letta’s own documentation describes updating a block as a full replacement of its content: the previous text is gone, and the same documentation flags concurrent updates to a shared block as an anti-pattern that can lose data, recommending that callers partition the string by agent ID to avoid collisions. Substrate memory’s equivalent of a wrong call is a new entry linked to the one it replaces with a supersedes relation; the earlier entry stays in the record, dated and attributed, rather than being overwritten. Both hold shared work memory. One is an append-only typed graph where a wrong call is superseded, not overwritten, and where a fleet of sessions writes concurrently; the other is a pinned flat string that a small number of agents take turns overwriting.

The same design difference shows up at scale. A shared memory block is documented as a primitive for a small number of attached agents. Vinculum’s own graph, by contrast, has recorded concurrent writes from a fleet peaking at 192 sessions in an hour. And because a shared block is pinned into every attached agent’s context window, it is bounded by that window’s size. Letta’s documentation recommends archiving older content or having an agent periodically summarize it once it grows too large, the same compaction problem a substrate avoids by keeping history outside the context window entirely.

Zep’s Graphiti engine timestamps facts pulled from conversation and models state changes explicitly. A user who says they used to live in London and later moved to Tokyo produces a graph where the earlier fact is marked as superseded by the later one, rather than two facts a similarity search might return as equally current. That mechanism is close in spirit to how a substrate treats a reversed decision.

The difference is scope and authorship. Zep’s temporal facts describe one user’s attributes as understood by one agent across that user’s sessions, a personalization record. Substrate memory’s supersede chains describe decisions made by many different sessions and authors working on a shared project. The mechanism rhymes; the subject matter and the population writing to it do not.

Mem0 follows the more common pattern in this field: an extraction step reads a conversation after it ends and writes a summarized memory to a store, later retrieved for a single agent by similarity or recency. It offers an optional graph mode over that store, but its default is vector-first — retrieval by similarity, not traversal of relations an author asserted.

The deeper difference is not vector versus graph but when a memory is written, and by whom. Mem0’s model extracts memories from a transcript after a conversation ends, an instance of post-hoc extraction. Substrate memory’s entries are written as the reasoning happens, by the same session that made the call, a difference in timing and authorship rather than in whether a graph is involved.

Mem0, Letta, and Zep read as three answers to the same design question: how much of its own memory an agent should manage, and how. Mem0 answers by adding a layer outside the agent. Letta answers by making memory part of the agent’s own runtime. Zep answers by tracking one user’s facts over time. Each keeps the agent as the unit the memory belongs to.

Substrate memoryanswers a related but distinct question. It does not extend one agent’s memory; it describes a graph that a population of agents, each one short-lived, reads and reasons on together, and to which any of them may write. The graph, not any single agent, is what persists.