Memory your agent can prove.
Kage checks every memory against your code — when it's written, when it's recalled, and when your diff changes what it cites. Wrong knowledge never reaches the agent. You get the receipt.
this week≈ $6.18
Install once. It runs itself.
1 · Install
One command creates repo memory, builds the code graph, and auto-wires every agent on your machine.
2 · It takes notes
Learnings become packets — explicit or auto-distilled — and every citation is verified against your repo before it's written.
3 · Sessions start warm
A "previously…" digest opens each session; verified memory is injected the moment the agent reads a cited file.
4 · Diffs get checked
kage pr check warns when your change invalidates team memory — before the PR lands.
It takes notes. Then it checks them.
Learnings become packets as the agent works — explicitly, or auto-distilled from the session with a signal gate. Every citation is validated against your repo before it's written. A memory citing a file that doesn't exist is refused on the spot.
How a packet earns trust →Every session starts knowing.
A "previously…" digest and a timeline of recent memory open each session automatically — and when the agent reads a file, verified packets citing that file are injected right then. Each recall prints the receipt.
Watch memory stream in, live →Your diff gets fact-checked.
No other memory tool does this: when your change invalidates what the team knows, kage pr check says so — in the same review as the code, with the fix one command away.
Memory that follows you.
Personal memory lives in ~/.kage/memory and syncs over a private git remote you own. Conflicts resolve newest-wins with both versions kept — and synced packets are re-verified against the local checkout before any recall trusts them.
$ kage sync pushed 2, pulled 1, resolved 0 $ kage learn --personal --learning "Always run the full suite before releasing" ✓ captured · personal · re-verified on every machine
Remembering is solved. Trusting isn't.
Capture-everything memory solves remembering. Kage solves trusting what's remembered — and a memory system that never re-verifies its own claims gets less trustworthy the longer you use it.
| Kage | claude-mem | mem0 / Zep | |
|---|---|---|---|
| Automatic capture + session-start recall | ✓ | ✓ | via SDK |
| Hallucinated citations rejected at write time | ✓ | — | — |
| Stale memory withheld at recall | ✓ | — | — |
| Diff-time stale-catch before the PR lands | ✓ | — | — |
| Memory reviewed in git, same PR as the code | ✓ plain files | SQLite + cloud | hosted API |
| Savings receipts (tokens + $ per recall) | ✓ per-packet | token index | — |
| Cross-machine sync | ✓ your own git remote | their cloud | their cloud |
| Account / API key required | none | cloud optional | yes |
Already running claude-mem? Audit your existing store — read-only, no account: npx -y @kage-core/kage-graph-mcp audit-claude-mem classifies every observation as verified, drifted, gone, or unciteable.
Trust you can measure — on your own repo.
Most memory tools benchmark recall. Kage benchmarks the thing that matters when an agent acts: whether the memory can be trusted. Run it yourself; every number traces to a logged event.
Trust score: 100/100 (PASS) Hallucinated-citation rejection: 100% Stale-memory exclusion: 100% Live grounding rate: 99%
See what your own repo is hiding first: npx -y @kage-core/kage-graph-mcp scan --project .
The receipts speak first.
Kage is days old in its current form — we'd rather show you a blank wall than fake quotes. These three spots belong to the first teams who run it.
"Your quote here — after we run the Truth Report on your repo, live."
— First design partner · book the demo
"Your quote here — after the first stale-catch saves your PR."
— Second design partner · book the demo
"Your quote here — after a week of receipts."
— Third design partner · book the demo
Every MCP agent. Built in the open.
kage install auto-detects and wires everything on your machine. Claude Code users can also /plugin marketplace add kage-core/Kage.
Free where it matters. Verified everywhere.
The open-source core is complete on its own — verification, receipts, sync over your own git remote. Local-first, private by default: secrets are scanned out and <private>…</private> is never stored.
Open source
$0 forever
Everything on this page: verified memory, Truth Report, receipts, auto-capture, repair, live viewer, 13 agents, kage sync over your own private git remote. No account, no API key.
Kage Cloud
$0 early access
Memory that follows you: your packets on every machine behind one private MCP link — verification stays client-side, so the cloud never sees your code.
Team
Coming soon
Shared team memory with review gates — the same PR-reviewed trust model, hosted. Early design partners shape it.
Stop letting your agent forget.
The open-source core installs in 60 seconds. Kage Cloud — memory on every machine behind one private MCP link — is rolling out to the waitlist first.
Waitlist is one click on GitHub — 👍 or comment to join. Demos are 30 minutes, your repo, live. Or skip the line: install the open-source core now.