Substrate

The graph is the memory. Sessions are ephemeral. This is the core insight that everything else in Vinculum follows from.

Scaffolding vs substrate

Scaffolding is temporary. You put it up to do work, and when the work is done, you take it down. Chat threads are scaffolding. So is shared context passed between sessions via copy-paste, or a Notion doc that captures decisions for a while before going stale.

Substrate is load-bearing. It's what you build on. Concrete is substrate. The ground is substrate. When you pour a foundation, it stays — future construction references it, builds on it, and it remains even when the builders leave.

Vinculum is the substrate for parallel Claude sessions. Every decision, directive, implementation, and review is a typed entry in a shared graph. Sessions start, read the graph to orient themselves, work, write their outputs to the graph, and end. The session is gone. The graph is not.

Why this matters for LLMs

LLMs have a context window. It's not tiny anymore, but it's still finite, and more importantly, it's ephemeral. When a session ends, the context goes with it. If coordination depends on that context — if the shared state only exists in the chat thread — you've built on scaffolding.

The graph doesn't fit in one session's context window, and it doesn't need to. Each session loads what's relevant: its inbox, its directive, recent activity on its branch. The rest of the graph stays out of context but remains readable via tool calls. The model doesn't need to hold everything — it needs to know where to look.

Typed entries

Everything in Vinculum is an entry. Entries have types: directive, implementation, review, checkpoint, decision, question, spec, convention, and others. The type is not just metadata — it drives routing, display, and tool behavior.

A directive is something to be done. An implementation is the output of doing it. A reviewis the lieutenant's verdict. This typed structure means the graph isn't just a log — it's a queryable record of work.

Sessions are ephemeral by design

This is a feature, not a bug. A session that ends cleanly — writing its outputs to the graph before the window closes — is a session that did its job. The grunt is not a persistent agent. It's a stateless worker that claims a directive, implements it, and hands off to the graph.

This means you can kill a session mid-work and restart it. The new session reads the graph, finds the checkpoint entries the previous session wrote, and picks up from there. No lost state. The graph held it.

The graph is horizontal

Vinculum is a graph, not a hierarchy. Entries link to other entries: implements, supersedes, blocks, references. A directive links to the implementations that fulfilled it. An implementation links to the review that approved it. A convention entry links to the decisions that gave rise to it.

This horizontal structure means you can trace any output back to its origin and understand why decisions were made — not from memory, but from the graph itself.

Next: Roles

The substrate doesn't care who writes to it — but the three-role model gives structure to who writes what. Read about roles →