Reasoning on the graph, not retrieving from it.
Most memory systems for language models save information so a single agent can fetch it back later: a note is written, then searched for by similarity when it might be relevant. Substrate memory instead treats the reasoning itself as the record: the decisions, the reversals, the questions, and the links between them. An agent does not query it for passages; it reads back a structure that already reflects what mattered.
Retrieval re-derives relevance on every query: it ranks the same pile of text again and hopes the ranking holds up. A substrate settles relevance once, in the edges between entries: what replaced what, what answered what, what caused what. Nothing already carried by the graph needs to be worked out again.
Four primitives.
Substrate memory is built from four primitives, set out formally in the Vinculum Standard.
| Primitive | Description |
|---|---|
| the typed entry | A decision, a finding, a question, a plan. Each entry carries a type and metadata rather than a paragraph an agent has to re-read to classify. |
| typed links | Connections between entries carry their own meaning: references, supersedes, replies-to. The graph is as much the links as the entries themselves. |
| supersession | Entries are append-only. A changed decision is never edited in place; a later entry supersedes it, and the earlier one stays in the record rather than being scrubbed. |
| branches & threads | Work is grouped into branches and threads, each thread holding the full history of one topic, rather than reconciled from separate branches after the fact. |
Where the term comes from.
The word substrate marks a layer underneath: the ground work is written onto, rather than a capability attached to one model. Substrate memory names an inversion of the more common arrangement, in which a memory store is bolted onto an agent after the fact. Here, the reasoning is written to a shared graph as it happens, and other agents read and reason over that same graph.
Academic surveys of language-model memory generally describe a write-manage-read loop over stores, distinguishing mechanisms such as context-resident compression, retrieval-augmented stores, and reflective self-improvement. Those describe where information is kept and how it is fetched. Substrate memory sits on a different axis: what the graph records (decisions, reversals, and the causal links between them) and when it is written (during the work, not assembled from it afterward). The formal definition lives in the Vinculum Standard; what follows here is its plain-language companion.
Implementations.
The reference implementation is Vinculum, licensed under the AGPLv3. It exposes a substrate over the Model Context Protocol, so any MCP-compatible model or agent can read and write the graph, stores entries in PostgreSQL, and renders the graph as a live visual map.
Because it runs continuously rather than existing only as a specification, its own graph doubles as an example of the model in continuous use, accumulated across months of parallel work by a population of agents.
Common questions.
How does this relate to RAG?
Retrieval-augmented generation fetches passages and inserts them into a prompt. Substrate memory describes the structure an agent reasons on, a layer beneath retrieval. The two can be combined, with retrieval running against the substrate rather than against an unstructured document store.
Is it a knowledge graph?
It shares the graph form. The distinction is in what the graph records (decisions, supersession, and provenance) and in entries being written as the reasoning happens rather than extracted from documents afterward.
Is it just a database?
A database usually stores the graph underneath (PostgreSQL, in the reference implementation). Substrate memory refers to what those rows represent and mean to an agent reading them back, not to the storage engine itself.