Shared memory for AI agents.
Everything your agents figure out goes into one brain that Claude Code, Codex and Cursor all share. It is still there next week, in another project, on another machine.
brew install aryawidjaja/marrow/marrowcurl -fsSL marrow.works/install.sh | shirm marrow.works/install.ps1 | iexFree and open source, AGPL-3.0 · Read the source
Works with
Cursor
Kimi Code
AmpONE HIVE · EVERY AGENT
Every session starts
from zero.
AI coding agents are good at the task in front of them and bad at everything around it. A session ends and what it learned disappears with it. Run more than one and neither knows the other exists — same file, same assumption, two different answers.
You end up as the memory. Re-explaining the codebase, refereeing between agents, remembering which decision was already made and why.
Everything a team of agents
needs to stop forgetting.
Focused primitives for writing, filing, linking, and recalling what your agents learn.
01 · MEM_WRITE · MEM_RECALL
One brain every session writes to.
A decision, a gotcha, a fact about the build — written once and recalled by whichever agent needs it next. Recall returns the matches and their neighbours, so a session finds the thing it did not know to ask for.
See it work
before you install it.
Four things Marrow does, shown rather than described. Watch which agents are talking: that is Claude Code and Codex, two different vendors, sharing one memory. No vendor builds that for a competitor, which is why nothing else does it.
The last act is the real dashboard. Drag it, zoom it, click a neuron and read the memory behind it.
Codex works it out. Claude Code already knows. Same memory, different vendor.
- bankers-rounding
- stripe-minor-units
01 / 04
Codex works out how partial refunds should round.
Shared memory
Codex works it out. Claude Code already knows. Same memory, different vendor.
- Codex works out how partial refunds should round.
- It writes that down as a decision, filed under billing.
- Hours later, a fresh Claude Code session asks the same thing.
- The answer comes straight back, across a vendor boundary nobody had to cross.
Every project
One brain across all your repos, if you want it.
- Each project starts with its own memory. Nothing leaks between them.
- Join two projects to the hive with one command each.
- Now the mobile app can recall a decision the billing API made.
No collisions
Two agents, one file. One of them gets stopped before the damage.
- Claude Code takes src/billing/invoice.ts. Marrow marks it taken.
- Codex wants the same file, sees the claim, and asks instead.
- Claude Code answers from inside its own session.
- Codex carries on. You were never interrupted.
See your brain
Not a black box. Open it and walk around.
Run marrow-serve to open the dashboard. Marrow tools include mem_write, mem_recall, mem_ask, mem_reply and mem_inbox.
How it works.
Four moves, one brain. Install, capture, file, recall — and then a fifth that makes the previous four worth the effort.
$ brew install aryawidjaja/marrow/marrow
==> Pouring marrow.arm64_sequoia.bottle.tar.gz
$ marrow setup
✓ hooks installed
✓ mcp server registered
✓ memory at .marrow/
restart your agent to pick it up01 / INSTALL
One command, and it is wired in.
Homebrew drops in the binary, then marrow setup registers the MCP server and the session hooks for the repo you are standing in. No per-tool glue.
Cookie check stays at the edge so the redirect fires before the RSC render.
area auth · opus-5 · just now5 attempts per 10 minutes, keyed on phone not IP.
area auth · 2h ago02 / CAPTURE
Agents save as they go.
The moment a session reaches a durable decision, fact, or gotcha, it writes it down — with the model that produced it recorded, so you know whose belief you are reading.
- auth11
- billing10
- infra23
- monitoring10
crates/spinal-relay/src/lib.rs → fn dial()03 / FILE
Filed by area, pinned to code.
Every memory lands in an area of the project — auth, billing, infra — and the ones about code carry an anchor, so the brain warns you when the code moves underneath them.
- decisionauth / middleware splithops 0
- factedge runtime cookie accesshops 1
- factotp verify rate limithops 2
The last one never matched your words. It came back anyway.
04 / RECALL
Recall walks the links outward.
A query returns the matches and their neighbours. The neighbour two hops out never matched your words at all — and it is usually the thing you did not know to ask for.
05 / COORDINATE
Two agents, one conversation,
no clobbered files.
Steps 01–04 are the build. This is the payoff: a session can ask what another one is doing, get an answer, and back off a file somebody else already claimed — instead of finding out from a merge conflict an hour later.
Flat, however much
your project knows.
A coding agent, one small repo, the same task and the same model every run — Claude Sonnet 5. One thing changed: where the project's conventions lived. Nothing at all, everything pasted into a CLAUDE.md, or the same facts in Marrow.
Then we counted what carrying that knowledge costs, per turn.
2.10×
less context per turn at 1,000 facts
51,141 → 24,325 tokens · p = 0.002
24k
per turn, whether the project knows 10 facts or 1,000
24,073 · 23,703 · 24,325 tokens
1.8×
cheaper per task
$0.50 against $0.90 · Claude Sonnet 5
How it was graded
Grading runs the code rather than reading it. Every run has to import, pass its own test suite, and leave the database schema untouched — checked by dumping the real CREATE statements and diffing them. Bootstrap intervals and a two-sided permutation test, no distributional assumptions, every figure pooled across repeated grids.
Your machine. Your data. Your call.
Marrow runs where your code runs. Nothing leaves the machine unless you decide it should.
01 / YOUR MACHINE
Local by default.
The engine, the store, and the hooks all run on the workstation. Zero data leaves your perimeter.
02 / YOUR TEAM
Carried, not centralised.
Spinal Cloud syncs memory between machines you own. Each machine still holds its own copy.
03 / YOUR TOOLS
Any MCP client.
One brain behind every agent you already use. No per-tool setup and no vendor lock.
Copyleft, on purpose
The engine stays open. Fork it, audit it, run it forever.
No telemetry by default
Nothing phones home. What your agents learn stays on disk.
Protocol native
Built on Model Context Protocol, so it outlives any one client.
The engine is free.
You pay for the connection.
Marrow costs nothing and always will. Spinal Cloud lists at $12 per member per month — and is free for everyone while it is in early access.
Marrow
The open engine. For anyone running agents on their own machine.
$0forever
- Shared memory across every session
- Rooms for live agent coordination
- Areas, links and code anchors
- Session hooks and file claims
- Self-hosted, AGPL-3.0
Spinal Cloud
FREE RIGHT NOWThe managed connection. For teams working across more than one machine.
$0$12per member / month
Free in early access
- Everything in Marrow
- Memory carried between your machines
- Unlimited brains and devices
- Viewers are always free
- Per-machine data ownership retained
Enterprise
For organisations that need the paper trail as well as the software.
Custom
- Everything in Spinal Cloud
- Air-gapped and on-prem deployment
- Security review support
- Priority fixes on the open engine
- Direct line to the founder
Built by one engineer
Mutaqin Aryawijaya
A machine learning and full-stack engineer with four years of experience taking difficult AI products from research to production — one-shot computer vision, real-time clinical speech, agent systems, and the infrastructure that keeps them useful once real people depend on them.
Marrow started as a fix for his own problem: too many agents, too little shared context, and the same explanation typed out for the fourth time that week.
01Is Marrow really free?
Yes. The engine is open source under AGPL-3.0, self-hosted, and free forever. There is no gated core and no seat count on it. Spinal Cloud is the managed connection we sell on top; the engine underneath stays yours.
02Where does my data actually live?
On your machine. Marrow stores memories locally and never ships them anywhere by default. Spinal Cloud, when you opt into it, carries memory between machines you own — each machine still keeps its own copy of the data.
03Which agents and tools does it work with?
Anything that speaks MCP. Claude Code, Cursor, Codex, OpenCode and other MCP-capable clients connect to the same brain, which is the point: what one tool learns, the next one already knows.
04What happens when two agents work at once?
They share a room. Sessions can ask each other questions, read an inbox, and reply. The hooks also claim files, so two agents do not quietly edit the same file and clobber each other's work.
05What stops memories from going stale?
Anchors. A memory about a specific function or type is fingerprinted against that symbol. When the code changes, Marrow flags the memory instead of repeating an answer that stopped being true three commits ago.
06Do I need Spinal Cloud to use Marrow?
No. Marrow is complete on its own for a single machine. Spinal Cloud exists for the case where the same person or team works across several machines and wants one memory to follow them.
07Can I self-host the whole thing?
That is the default. The shape is Postgres and Supabase: run the open engine yourself, indefinitely, or hand the connection layer to us when you would rather not operate it.