{
"markdown": "![\"Marrow](\"assets/brand/marrow-landscape.png\")
\n\nmarrow
\n\n*Memory that keeps working after Claude's runs out — shared across your projects, machines and tools.*\n\n[](https://github.com/aryawidjaja/marrow/releases/latest)\n[](LICENSE)\n[](https://www.marrow.works/)\n[](https://www.rust-lang.org)\n[](https://github.com/aryawidjaja/marrow/stargazers)\n\n[](https://modelcontextprotocol.io)\n[](https://www.anthropic.com/claude-code)\n[](https://cursor.com)\n[](https://openai.com/codex)\n\n## Claude's memory stops at 25KB. This one doesn't.\n\nClaude Code's built-in memory loads the first 200 lines of one file into every session. That is fine\nfor a young project. A codebase two years old knows more than fits in 200 lines, and everything past\nthe cut is simply dropped.\n\nMarrow retrieves instead of loading. Ask a question and it returns the twenty memories that answer it,\nplus the ones linked to those, out of however many thousand you have.\n\n**At 1,000 project facts that is 2.1× less context per turn (p = 0.002) and $0.50 a task instead of\n$0.90.** [Numbers and method below.](#does-it-actually-help-we-measured-it)\n\nIt also does three things the built-in memory does not:\n\n- **One brain across projects.** Built-in memory is per repository. Marrow's hive lets an agent in\n `api` recall what `webapp` knows.\n- **One brain across machines and teammates.** Built-in memory is explicitly machine-local. Marrow\n syncs through a relay you run, or [Spinal Cloud](https://spinal.cloud) if you would rather not.\n- **One brain across tools.** Claude Code, Cursor and Codex read and write the same memory over MCP.\n\nAnd because several agents share it, it also keeps them from colliding: a file another live session\nis editing is claimed, and every agent's actions land in one append-only, hash-chained record you can\nread.\n\nFree forever, AGPL-3.0, runs on your machine. Every memory is a markdown file you can open and delete.\n\n## Does it actually help? We measured it\n\n![\"Context](\"assets/benchmark-context-per-turn.png\")
\n\nThe usual way to tell an agent how your project works is to write it all into a `CLAUDE.md`, which it\nthen reads on every single turn. That is fine for ten things. A codebase a couple of years old knows\na thousand.\n\nWe gave a coding agent the same task and the same repo three ways: nothing, everything in a\n`CLAUDE.md`, and the same facts in Marrow. 75 runs.\n\n- **A `CLAUDE.md` costs more the more your project knows.** 21k tokens per turn at 10 facts, 51k at\n a thousand. Marrow stays flat: 24.1k, 23.7k, 24.3k. At a thousand facts that is **2.1× less\n context** (p = 0.002) and **$0.50 a task instead of $0.90**.\n- **Below roughly a hundred facts, just write the file.** Marrow loses that one, 0.87×, and takes\n more turns. We would rather say so than pretend it wins everywhere.\n- **An agent with no project memory broke things.** It invented a database table, reached for\n `uuid4` where ids are meant to be sortable, and wrote a naive timestamp. Both of the arms that had\n the knowledge got those right.\n\nMethod: same fixture repo and prompt each time, graded by running the code rather than reading it,\nwith bootstrap intervals and a permutation test over 6 runs per cell. There is more on the numbers at\n[marrow.works](https://www.marrow.works/).\n\n## What about Claude Code's built-in memory?\n\nFair question, and the honest answer is that for a small project you may not need this.\n\nClaude Code ships auto memory: Claude writes notes to `~/.claude/projects//memory/`, and a\n`MEMORY.md` index is loaded into every session. It is on by default and it costs nothing. Use it and\nbe happy until one of these starts to bite:\n\n| | Built-in auto memory | Marrow |\n|---|---|---|\n| How memories reach the model | First 200 lines / 25KB of one index file, every session | Ranked retrieval: the matches, plus what they link to |\n| What happens when it outgrows that | Claude is told to delete entries | Nothing; retrieval just searches more |\n| Scope | One repository | Every project on the machine |\n| Across your machines | No — \"files are not shared across machines\" | Yes, via a relay you run or Spinal Cloud |\n| Across tools | Claude Code only | Claude Code, Cursor, Codex, any MCP client |\n| Shared with teammates | No | Yes |\n| Record of what agents did | No | Append-only, hash-chained, auditable |\n| Flags memory that code has outgrown | No | Yes, for anchored Rust symbols |\n\nThe rule of thumb: **under a hundred facts, one repo, one machine, one tool — use the built-in.**\nMarrow starts paying for itself past that, and our own benchmark says so out loud\n([we lose at 10 facts](#does-it-actually-help-we-measured-it)).\n\nThe two are not exclusive. Auto memory is Claude's private scratchpad; Marrow is the shared record.\n\n## Get started\n\n**Claude Code**, one command:\n```\n/plugin marketplace add aryawidjaja/marrow\n/plugin install marrow@marrow\n```\nThen install the binaries it drives (`brew install aryawidjaja/marrow/marrow`, or\n`irm marrow.works/install.ps1 | iex` on Windows) and restart.\n\n**Everything else** — Cursor, Codex, Claude Desktop, or if you would rather not use a plugin:\n```bash\nbrew install aryawidjaja/marrow/marrow # macOS/Linux; Windows: irm marrow.works/install.ps1 | iex\nmarrow setup # add --global to wire every repo at once\n```\n`marrow setup` seeds your brain with what it can work out about the repo on its own, so the first\nsession is not empty, and reports anything still missing. Restart your agent afterwards. The hooks\nneed `jq` and never block your work when Marrow is unavailable. Already mid-session? Run\n**`/marrow-save`** to keep what is worth carrying forward.\n\nChanged your mind? `marrow uninstall` puts everything back and keeps your memories. More ways to\ninstall, including the no-terminal Claude Desktop bundle, are [further down](#more-install-options).\n\nThe memory lives in `.marrow/` in your project.\n\n## See your brain\n\nMarrow isn't a black box, it's a graph you can explore, like a second brain.\n\n```bash\nmarrow-serve # opens the dashboard at http://localhost:8088\n```\n\nEvery memory is a neuron, grouped into the area it belongs to, so the graph has real structure\ninstead of being a hairball. Links connect memories that share a topic, a tag, or **related meaning**\n(from embeddings). Browse the tree, drag, zoom, click to read, filter, and **add, edit, or delete**\nmemories right there. The **Hive** tab shows every project at once.\n\n## Your memories are organised, not a pile\n\nEvery memory lives in an **area** of the project: `auth`, `billing`, `infra`. The agent files it as it\nwrites, so the brain has a shape you can navigate instead of one flat heap.\n\n```\nproject → area → topic → versions\n```\n\n```bash\nmarrow areas # the map: auth 11 · billing 10 · infra 23 · monitoring 10\n```\n\nYour agent sees that same map the moment a session starts, so it knows what the project knows before\nit answers. It can also weight a recall toward one area without hiding the rest:\n\n```bash\nmarrow add --kind decision --topic jwt-expiry --area auth \"We use 15-minute JWTs.\"\n```\n\nNothing is forced. If a memory fits no area, it stays unfiled and is still fully searchable. A wrong\narea is worse than none.\n\n## One brain across your projects\n\nBy default each project has its own brain. Opt any project into a machine-wide **hive** with one\ncommand, and your agents can recall across all of them:\n\n```bash\ncd ~/code/webapp && marrow hub register --name webapp\ncd ~/code/api && marrow hub register --name api\n\nmarrow hub recall \"how do we do auth\" # searches every project, tagged by project\n```\n\nNow an agent working in `api` can ask what `webapp` knows. In the dashboard, the **Hive** tab shows a\ncentral *core* neuron (you) with every project orbiting it, bridged where they share ideas.\n\n## Give your agents a room to talk\n\nOnce a project joins the hive, its agents can open named rooms, ask each other questions, reply, and\nhand work over without relying on one giant chat. Claude Code, Codex, Cursor, and other MCP agents on\nthe same machine can use the same channel.\n\nAgents check the inbox when they start and before touching work another session may own. You can read\nevery room in the dashboard's **Channel** tab, so the coordination stays visible instead of happening\nbehind your back.\n\n## One brain across your devices (beta)\n\nEach project is local and private by default. Share the *one* project you want synced, and the rest\nstay on your machine. It's like sharing a repo, not your whole disk.\n\n```bash\n# once, on a server (Docker, Fly.io, any host; see deploy/)\nMARROW_TOKEN=$(openssl rand -hex 16) marrow-server\n\n# then in the project you want shared, on each machine\nMARROW_TOKEN= marrow share --gateway https://your-gateway --space team-app\n```\n\nSame gateway + space + token on two machines routes their MCP memory tools to one remote project\nstore. A decision saved through an agent on your laptop is available to an agent on your desktop.\nEvery other project is untouched. The backbone currently uses one bearer token; run it on\ninfrastructure you control over HTTPS and back up its data volume.\n\n```bash\nmarrow status # shows whether this project is shared or local\nmarrow unshare # back to local, nothing is deleted\n```\n\nYour agent is told which mode it is working in. You can configure sharing from the dashboard's\n**Manage Projects** panel. The local dashboard still visualizes the local project store;\nshared-memory reads and writes happen through the agent's MCP tools. Full scope and deployment\nguidance are in [deploy/README.md](deploy/README.md). Code anchors and freshness checks need the\nsource tree, so they remain local-only.\n\n## More install options\n\nPrebuilt binaries, no Rust:\n```bash\ncurl -fsSL marrow.works/install.sh | sh\n```\nFrom source:\n```bash\ncargo install --git https://github.com/aryawidjaja/marrow marrow-cli marrow-mcp marrow-web marrow-server\n```\nThis puts `marrow`, `marrow-mcp`, `marrow-serve`, and the cross-device `marrow-server` on your PATH.\n\n### Windows\n\n```powershell\nirm marrow.works/install.ps1 | iex\n```\n\nOr with [Scoop](https://scoop.sh):\n```powershell\nscoop install https://github.com/aryawidjaja/marrow/releases/latest/download/marrow.json\n```\n\nEither way you get `marrow`, `marrow-mcp`, `marrow-serve` and `marrow-server`, no admin rights, no\nRust, semantic search already built in.\n\n**Just want it in Claude Desktop?** Download `marrow-mcp.mcpb` from\n[Releases](https://github.com/aryawidjaja/marrow/releases/latest) and double-click. No terminal at\nall: it asks which project to remember and that is the whole setup.\n\nThe hooks that warm-start sessions and stop two agents editing the same file are shell scripts, so\nthey need [Git for Windows](https://git-scm.com/download/win) and [jq](https://jqlang.github.io/jq/).\nThe installer says so if either is missing:\n```powershell\nwinget install Git.Git jqlang.jq\n```\nWithout them memory still works; the automatic coordination stays off. Prefer WSL2? Install the Linux\nway inside it and everything behaves exactly as it does on Linux.\n\n## Bringing in an existing project\n\nA fresh brain starts empty. To seed it from docs you already have, the first warm start nudges your\nagent to run `marrow ingest`, it lists your README and `docs/` and distills them into memory. After\nthat, later sessions can start with those memories available. Any time, run **`/marrow-save`** to\npreserve the decisions and discoveries worth carrying forward.\n\n## Using Cursor, Codex, or other MCP agents\n\nThe automatic hooks are Claude Code specific, but any MCP agent gets the full memory toolset. Register\nthe server for every Claude Code project:\n```bash\nclaude mcp add marrow -s user -- marrow-mcp --root .\n```\nFor one project, add the same server to `.mcp.json` (Claude Code), `.cursor/mcp.json` (Cursor), or your\nCodex TOML.\n\n## Semantic search\n\nBuilds that ship with the local embedding model (the `marrow-semantic` formula, and the Windows and\n`install.sh` builds) use **meaning-based** recall by default, so a note about \"JWT\" is found by\nsearching \"login security\". The plain `marrow` formula is keyword-only and smaller:\n```bash\nbrew install aryawidjaja/marrow/marrow-semantic # multilingual, downloads a small model on first use\n```\n`marrow status` shows the mode; `marrow embed none` switches back, `marrow embed fastembed` switches on. Semantic search also powers the\n\"related meaning\" links in the dashboard graph.\n\n## CLI\n\nYour agent drives Marrow for you, but you can too:\n```bash\nmarrow add --kind decision --topic auth \"We use short-lived JWTs.\" # save\nmarrow search \"token expiry\" --weight 1 # find (0=keyword, 1=semantic)\nmarrow hub recall \"rate limiting\" # search the whole hive\nmarrow list-stale --repo . # notes whose code drifted\nmarrow consolidate --repo . --apply # merge duplicates\nmarrow audit # prove the ledger untampered\n```\n\n`marrow add` writes a plain markdown file under `.marrow/memory/`, the YAML frontmatter is metadata,\nthe text below is the memory. The SQLite index is a rebuildable cache over these files.\n\n## It doesn't forget the old stuff\n\nThe obvious worry with a memory that only ever grows: does the good idea from four months ago just\nsink? Two things stop it.\n\n**Recall follows the links.** Ask a question and Marrow doesn't only return what matched your words.\nIt takes the matches and spreads outward through the graph, a few links at a time, weakening with\neach step. So a note that shares none of your vocabulary still surfaces if it sits behind one that\ndoes. That old decision stays reachable through its neighbours, which is exactly what the links are\nfor.\n\n**And the brain strengthens what it uses.** Every recall is recorded. A memory the agents keep\nreaching for gets easier to reach again; one nobody has ever touched stays where it is. Recall a\nthing enough and it comes to you.\n\nWhen a decision changes, the agent supersedes the old memory instead of appending another active\nversion. Marrow preserves the lineage so the current answer stays clear without losing history.\n\n## What's under the hood\n\n- **Staleness detection for Rust**: a memory can cite a Rust symbol; Marrow fingerprints it and flags\n the note when that symbol changes, while tolerating formatting changes and supported relocations.\n- **Consolidation**: finds genuine duplicates (a near-identical restatement, or a pair that are\n mutually each other's closest match) and merges them, preserving lineage. It will not merge notes\n that are merely similar.\n- **Associative recall**: a question returns the matches *and* the memories connected to them, found\n by following links, shared topics and related meaning outward from the hits.\n- **Hive mind**: sessions join warm, publish best-effort file claims, and read a live activity trail.\n Claude Code hooks can block a detected local collision, but deliberately fail open rather than\n risk blocking work when their prerequisites are unavailable.\n- **Audit & provenance**: every write, edit, and recall lands in an append-only, hash-chained ledger;\n any answer traces back to its sources. Turn signing on and `marrow audit` also catches a memory\n file edited on disk behind Marrow's back.\n- **Typed & validated**: every memory is a `fact` or a `decision` (or an `entity`), filed in an area\n under a short topic; bad writes are rejected with the reason, so the brain can't fill up with junk.\n- **Expiry & confidence**: a memory can say how sure it is, and can carry an expiry date for things\n that are only true for now. Marrow retires them when they lapse.\n- **Runs anywhere**: offline single binaries; markdown is the source of truth, SQLite a disposable cache.\n\n## The name\n\nMarrow is where the immune system's memory begins: the quiet layer that remembers while the rest of\nthe body keeps changing. Your agents share one too, but it stays yours, on your machine and on your\nterms.\n\n## License\n\nThe engine (`crates/`) is **AGPL-3.0-only**; the embeddable Python backend (`python/marrow-anthropic`)\nis **Apache-2.0**. Using Marrow from your agent over MCP or the CLI is a separate process, not a\nderivative work. A commercial license is available, see [COMMERCIAL.md](COMMERCIAL.md).\n",
"bytes": 17441,
"sha": "9687dac4dca25f765753d9a0e197991bcc72a6e73f503dab8acd4a153bd87c14",
"repo_slug": "aryawidjaja/marrow",
"fonte": "repo",
"truncated": false,
"api": "https://agentalog.com/api/listings/mcp_io_github_aryawidjaja_marrow_35a851b6/readme"
}