Archived draft — this is the v0.1 snapshot, kept for the record. See /standard for the current version.
the vinculum standardv0.1working draft
an open specification for substrate memory

Memory built for the model, not the human.

The model reasons on it. It isn't a log to read, a summary to skim, or a store to search.

This document specifies substrate memory: a typed, append-only graph of a project's decisions that a language model writes to and reasons on across sessions. It defines the entry shape, the core operations, and the epistemic guarantees a conformant implementation must provide, and nothing about how any one product is built on top. The goal is a primitive small enough that anyone can adopt it, and complete enough that a model built on it stops starting from zero.

Draft
The key words MUST, MUST NOT, SHOULD, and MAY are used in the sense of RFC 2119. A conformant implementation is one that satisfies every MUST in §8. Everything else is guidance.
§1 · what it is

A record that reasons back.

For as long as people have written work down (the ledger, the lab notebook, the commit log, the wiki), the record has been dead storage. It holds what you wrote and waits for a mind to come read it and do the thinking. Substrate memory inverts that: the mind is already reading. A session writes a decision, and the next session reads it back, connects it, catches where it breaks something older, and picks up the thread.

The distinction decides the shape. A record written for a human to read later drifts toward prose and summary. A record written for a model to reason on now is typed, linked, and append-only. This specification describes the second and sets the first aside.

it is not

a log

A log is append-only but untyped and unlinked, a stream you scroll. Substrate memory is a graph you traverse.

it is not

a summary

A summary is a gist written once and frozen, stale the moment after. Substrate memory is the record itself, written as the work happens.

it is not

a vector store

Retrieval rediscovers relevance on every query. Substrate memory keeps the structure (types, links, supersession), so relevance is already encoded.

§2 · the three axioms

Everything else follows from these.

A conformant implementation MUST hold to all three. They aren't features layered on top; they're what the word means. Remove one and what's left is an older kind of record.
  1. axiom 1The reader is the model.Every design decision resolves in favor of what the model needs to reason well, not what a human needs to browse. Where the two conflict, the model wins. That reverses a decade of memory built for the human.
  2. axiom 2Append-only. Supersede, never overwrite.A decision that changes is never edited or deleted. The old entry is kept, and a new entry supersedes it, with the link between them preserved. The changed mind is the record, and the lineage between old and new is the product.
  3. axiom 3Typed, not prose.Every entry carries a type and structured metadata, so the model reasons on structure instead of re-parsing haze. A decision isn’t a paragraph that happens to contain one. It’s an entry of type decision, and the model acts on the type without re-reading the prose.
§3 · the entry

The atomic unit.

The graph is made of entries. An entry is a single typed statement (a decision, an implementation, a question, a note) authored by a human or a model, and linked to the entries it relates to. A conformant entry MUST carry the following fields.
entry · required shape
idMUSTA stable, unique identifier. Once assigned, never reused, even after supersession.
typeMUSTThe kind of statement. Implementations define their own vocabulary; decision, implementation, question, note, spec are recommended baseline types.
contentMUSTThe payload. Free text, structured for the model to read: the actual decision, finding, or question.
authorMUSTWho or what wrote it: a human or a model identity. This carries provenance, which §6 builds on.
created_atMUSTA timestamp. Ordering carries meaning the model needs.
linksSHOULDTyped relationships to other entries: supersedes, replies_to, references. An entry with no links is a leaf; the value compounds with the edges.
metadataMAYAn open key-value space for implementation-specific structure: grouping, status, trust, targeting.
§4 · the operations

The five operations.

A conformant implementation MUST support these five operations, and MAY support no others at the primitive layer. Everything richer is built above the standard, not inside it.
write(type, content, author, links?) → id

WRITE

Append a typed entry. Never mutates an existing entry; writing is the only way the graph grows.

read(id | by type | by thread | recent) → entries

READ

Retrieve entries by identity, type, grouping, or recency. Reads never alter state.

link(from, to, relation) → edge

LINK

Record a typed relationship between two entries. Edges are first-class; the graph is the edges as much as the nodes.

reason_on(scope) → briefing

REASON-ON

Return a coherent, model-shaped slice of the graph for a given scope: a briefing, not a search result. The operation that makes it memory the model thinks in, rather than a database it queries.

SUPERSEDE · supersede(old_id, new_id) → keeps both, linked

Mark an entry replaced by a newer one, and keep both, with the edge between them intact. This is the operation the whole standard turns on. An implementation that overwrites instead of superseding satisfies none of the axioms and conforms to nothing here. Keep the changed mind and the record can reason about its own history; overwrite it and you're left with storage.

§5 · supersession, illustrated

The old decision stays in the graph.

When a project changes its mind, most systems overwrite the old value and move on, and the reasoning that made the change is gone. Under this standard, both entries live, linked by a supersedes edge. The model reading the graph months later sees not just the current decision but the decision it replaced and why, which is exactly the context that stops it from re-deriving, or re-making, a mistake already settled.
decision · retiredUse SQLite for the store:single file, zero ops.supersedesdecision · currentPostgres: six sessionswrite at once; SQLite locks.
both entries queryable · the edge carries the why · that is the lineage
§6 · the epistemic layer

What makes it more than storage.

A key-value store with good search is still storage. Three guarantees lift substrate memory into something a model can trust and grow on. A conformant implementation SHOULD provide all three.

Kept contradictions

A superseded decision isn’t an error to erase. The disagreement between old and new is signal. Real reasoning is born from contradiction, and the graph keeps it available rather than smoothing it away.

Provenance over content

Trust is derived from who wrote an entry, not from what the text claims. A poisoned entry can forge a citation; it cannot forge the identity that authored it. Trust travels on the author field.

Reasoning traces

The thinking that produced a decision MAY be captured as its own entry, linked to what it produced, so a later session inherits not just the conclusion but the road to it.

§7 · scope

The primitive alone.

This standard specifies a memory a single model reasons on for a single project, and that's the whole surface it covers. Everything that makes a product (coordinating many agents, spawning workers, the dashboard, the hosting) is built on the standard, and is deliberately outside it. Keeping the line sharp is what lets the primitive be universal while the products above it stay distinct.
in scope · the standard
  • The entry shape (§3)
  • The five operations (§4)
  • Append-only supersession (§2, §5)
  • The epistemic guarantees (§6)
  • Single model, single project
  • What a model, an assistant, or an app embeds to remember
out of scope · built on top
  • Multi-agent coordination
  • Spawning and orchestration
  • Roles, hierarchy, routing
  • Dashboards and visualization
  • Hosting, tenancy, billing
  • Everything a vendor competes and charges on

The standard is the ground. What you build to stand on it is yours to sell.

§8 · conformance

What “substrate-memory compatible” means.

An implementation MAY claim conformance with this standard if, and only if, all of the following hold. Conformance is all-or-nothing. A system that overwrites, or strips lineage, isn't a lighter version of substrate memory. It's an older kind of record wearing the name.
Every entry carries the required fields of §3.
The five operations of §4 are supported, and writes are append-only.
Supersession keeps both entries, linked. Nothing is overwritten or destroyed.
Entry types are first-class; the model reasons on structure, not prose.
Provenance is preserved on every entry, so the author is always answerable.
§9 · why it's open

The primitive is free so that everything can stand on it.

A memory the model reasons on should be infrastructure, the kind of layer every model, every assistant, and every long-running project can adopt without asking permission or paying a toll. Behind a license, it stays one company's product. Given away, it becomes a floor everyone can build on. The value was never in the schema, which anyone can copy in an afternoon. It's in what gets built on top, and that only grows when the floor is everywhere.

the standard, like Postgres

Free. Open. Universal.

The primitive above. Adopt it, embed it, re-implement it. A model can bake it into its weights; an assistant can ship it on a billion devices. No license, no toll, no permission. It has to win on merit, the way a standard does.

what stands on it, like the cloud built on Postgres

The cathedral. Where the work is.

Coordination, the fleet, the dashboard, the years of accreted lineage: a system with a time-moat rather than a schema. You can't copy it, because it isn't a spec. This is what a vendor builds, and what a vendor sells.

vinculumsubstrate memory for ai

Latin for bond, link, that which binds. In mathematics, the bar over a repeating decimal — the mark that says these digits recur, indefinitely, as a unit. That's the architectural claim: a substrate that accumulates a project's intent across its whole life, holding parallel sessions together not by syncing them, but by giving them one authoritative surface to read from and write to. The sessions are ephemeral. The graph is not.

— the substrate that persists —