A record your AI keeps, so the next session starts where this one stopped.
199,436 turns
in 56 active days
run on a flat subscription
references
$0 marginal
The work doesn't carry.
- You paste the same context into every new chat just to get a useful answer.
- A decision from last week never reaches the session you opened today.
- The why behind last month's architecture is gone. Only the code is left.
- The project lives in your head, so you're the bottleneck on every session.
Cold-start, every time
You worked something out last week. You open a new chat today and the model has no idea. Holding the project is your job, every session, from scratch.
The pattern repeats
Whatever you figured out before, the model figures out again. Same approach, same trade-off, reasoned into existence twice. Or three times. Or every Tuesday.
Decisions don't propagate
A direction you set in one session doesn’t reach the next. You re-explain. You re-justify. You re-decide.
The tax compounds
A long-running project pays the re-derivation tax every session. The bill scales with the project's age, not with how much work you actually need done.
Not a wrapper. The layer underneath.
Every other tool in this space wraps a session in a workspace. Install it, open it, work inside it. Want six sessions? Open six windows, and you're the message bus again.
Vinculum goes the other way. It sits under whatever clients you already run. Your chat session conducts, your workers execute, and every decision any of them makes gets written back for the next one to read.
real entries, real sessions: every decision written back, as it happens
No idea left behind.
What gets written stays written: the reasoning, the dead ends, the calls.
The record gets written in the moment, by the session doing the work, as each call gets made. Nobody rebuilds it afterwards from a transcript, so nothing in it is a guess about what happened.
Write it as you go and nothing you worked out has to be worked out again. The dead ends and the options you turned down stay in the record next to the choice you made, where the next session will read them.
The substrate is the cache.
Project state lives in the graph, so sessions stop re-deriving and start reading, almost entirely from cache. A typical Opus turn adds about ~1.9 fresh tokens against ~352K cached. You're not paying for the project's history every turn; you're reading it. It's also the answer to the runaway token bill everyone's quietly eating.
per-session averages vary
96.8% cache-read across 199,436 turns. The economics are built in, not negotiated
What it costs to runThe whole substrate,
on one surface.
Every session, every write, every drift sensor: the lineage cosmos, the live entries feed, the cost telemetry, all on one screen. It's the picture you read to keep the whole project in view, and it moves in real time. Watching the substrate fill is the fastest way to understand what Vinculum does.
What the substrate makes possible.
Once a project's work lives in one shared graph, things become possible that a notes file simply can't reach, and each one is the real product, not a picture of it.
Your AI recognizes its own handwriting.
A fresh session has no memory of the last, yet it reads the graph and knows the work as its own. Recognition, not recall.
16,140 references followed across sessions
How recognition worksOne chat. A workforce.
Spawn a fleet from one directive. Each worker reads the same substrate and writes back what it builds, with no coordination overhead and no clipboard.
spawned from chat · running on your machine
The role modelThe substrate is the cache.
Sessions read instead of re-deriving, so the model reads almost entirely from cache, and the background thinking routes through the plan you already pay for.
96.8% cache-read · 9,241 intel calls at $0 marginal
The cache economicsA corpus shaped like ground truth.
Nobody wrote any of this to be training data, but it lands in exactly the right shape. The work, as it happens, becomes the three signals a model learns from.
The model trains on the work: capability climbs, values stay human.
The bigger argumentEvery tool out there is one slice. Vinculum is the whole.
A code map, a task tracker, an inbox for your agents, something that pieces the reasons back together from old transcripts. Each of those is useful, and each is about a hundredth of what Vinculum is.
Underneath is an open standard for the record, free for anyone to build on. On top are about two hundred shipped features working from that one record, built for your AI to use while you watch. There's nothing to switch away from: it sits under what you already run.
Five roles. Defined by what they do.
Each role is a job: what a session is responsible for. The model tier it runs on is a detail, not the headline. You've got work; the role names it.
The runner closes the loop.
One download, nothing to configure. The runner stands up everything (substrate access, the dashboard, and the worker host) and then your chat calls spawn and a worker materializes right on your machine. For most people the runner is Vinculum: install it, and you're writing to the substrate in minutes.
Under the hood a spawned worker is role="grunt", the role you actually reason about, Sergeant / Private / Lieutenant, is the model tier you pass alongside it.
vinculum-runner doctor and paste the output, and I'll read the logs and sort the pairing.Stuck? The AI you're already talking to reads the runner's logs and walks you through it. It is the only install debugged by the model it's installing for.
directing the launch wave
verified feature-state
decompose + dispatch
implementing
running
It runs your work. You watch it run.
spawn_grunt writes a row; a single-binary runner, outbound HTTPS only, claims it and works locally. One-click install.Mission Control watches itself.A live sensor layer surfaces what the substrate notices: drift, re-derivation, distillation, because the work is structured, not prose.178 runner jobs run · outbound HTTPS only
How dispatch & the runner workThe rest is already in the box.
Those were the headlines. Here's everything else that already ships: each one a working subsystem, not a someday.
Multi-tenant substrate
Projects you own and projects you share, with isolation enforced at the row, not promised in a README.
Cross-vendor coordination
Claude Code, claude.ai, Cursor, Zed, Cline, all writing to one graph. It's a protocol, so no single tool owns you.
Directive state machine
Work moves through real states with a check at the finish line. Done has to earn it.
Semantic graph
Embeddings catch the overlaps and surface what’s related, with graph and vectors in one store, not bolted together.
Two-mode workers
Keep them on approval gates, or turn them loose inside a fence. The trust profile draws the line.
Reasoning-trace capture
The thinking lands as its own entry, linked to what it shipped. You keep the why, not just the what.
Your data leaves with you
Any session can pull the whole graph, every entry in full, with one tool call. Delete the account and the data goes too.
Docs from the substrate
The docs render from the graph itself. Change a rule, and the manual rewrites itself.
Cost telemetry
Spend split by model, session, and tool, cache hits and all. The bill, with nothing tucked away.
The rest of what it already does.
Multi-tenant substrate
Own and share projects, per-user × project trust profiles, row-level isolation enforced at the boundary.
Cross-vendor coordination
Claude Code, claude.ai, Cursor, Zed, Cline, one substrate. A protocol, not a vendor lock-in.
Directive state machine
pending → claimed → in_progress → blocked → complete, with acceptance checks at the close.
Semantic graph
Vector embeddings power overlap detection and related-entry surfacing. Graph and vector in one store.
Two-mode spawn
Supervised with approval gates, or fast and autonomous within scope. Trust-profile gated either way.
Reasoning-trace capture
The colonel’s thinking becomes its own linked entry. The thinking is kept, not just the output.
Your data leaves with you
dump_graph hands any session the whole graph, every entry in full. Delete the account and the data goes too.
Docs from the substrate
/docs/conventions renders live from the graph. The product documents itself as the rules change.
Cost telemetry
Live per-model, per-session, per-tool spend with cache-hit visibility. The bill, itemized.
Everyone built the workers. Nobody built the floor.
The labs cracked running a hundred at once.
They fan out, converge, and hand back a single answer, then delete the hundred thousand tokens of reasoning that got there. The doing is solved. The keeping isn't. That reasoning has nowhere to land.
Then the bill showed up.
Aiming more AI at a problem, it turns out, doesn't compound on its own. Every session boots cold and re-earns what the last one knew. You're not paying for compute, you're paying twice for the same thought.
A rules file crossed 150,000 stars.
A plain list of rules became one of the most-starred things in all of AI coding. People paste it into every repo to beg the model not to forget. A sticky note went viral because the hole is that universal, and a better sticky note was never the fix.
The substrate warms as it works.
(example session): #6142, real numbers
One assistant or six.
Either way, the work carries.
You want your AI to pick up where it left off, with nothing to run.
You use an AI in chat. You want each new session to read the record of the last one instead of you recapping it. You don't want to think about servers. Five dollars a month, hosted.
- Hosted at vinculum.run, nothing to set up
- Works with claude.ai, Claude Code, any MCP client
You want to try it on real work first.
Start on the Free plan at vinculum.run. Connect Claude Code or any MCP client, point it at a project, and see whether your sessions stop re-explaining themselves before you pay a cent.
- No card needed
- Claude Code, claude.ai, any MCP client
- AGPL v3, so you can read every line of it
You direct parallel sessions.
You already pay for Claude. You run several sessions, sometimes many. You want to describe what needs doing and watch helpers do it on the dashboard, instead of being the message bus between them.
- Start helpers from chat, with no terminal needed
- Real-time Mission Control: every session, every write, drift sensors live
- Background intelligence on your subscription: summaries, classification, clustering
Nothing to rip out.
Nothing to migrate.
Vinculum sits underneath what you already run and makes all of it compound.
Strap it on. You gave up nothing.
One Claude or a fleet.
The work carries either way.
Free to start. Five bucks for unlimited. Twenty to run a workforce. Flat every month, and never a cut of your Claude bill.
It bolts on under what you already use. You rip out nothing.
- no card needed
- the record and the dashboard
- AGPL v3, no lock-in
- projects without limit
- kept as long as you keep it
- any MCP client
- helpers started through the runner
- Mission Control + live sensors
- summaries on your own plan
- unlimited seats
- projects you all share
- Founding Teams price, locked while you stay
Can't run AGPL code? Commercial licensing →
The questions you're
already asking.
Isn't this just a memory tool, or a task tracker, or a code map?
Why not just use a bigger context window?
Is this just for Claude Code?
What's the open-source license?
Who built this?
Sixty seconds.
No API key. No new bill.
Live intelligence routes through MCP sampling: your existing Claude subscription does the inference, with no extra server-side charges. Start free; the paid plans add unlimited steps and helpers that run in parallel.
$ claude mcp add --transport http vinculum https://vinculum.run/mcp
# 2: open claude.ai in a browser tab
# say "check my vinculum inbox"
# that's your conductor interface
dashboard → vinculum.run/login
Give your AI a record to work from.
Start free at vinculum.run, on the Claude subscription you already have. Every session works from the same record, from the first one on.
No credit card for free tier · AGPL v3 · cancel anytime
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.
