Open, git-native memory your team's coding agents read and write together. Every lesson an agent learns becomes a file in your repo: versioned in git, reviewed in pull requests, shared across the whole team. Kage checks each one against your code, so deleted and stale citations get caught before they mislead anyone.
One command sets up everything, then restart your agent. Or just tell your agent:
100/100 trust benchmark ·
0 dependencies ·
no account, no API key ·
free & open source —
or try it before installing anything: npx -y @kage-core/kage-graph-mcp scan --project .
412K tokens saved
this week≈ $6.18
38
4
2
11
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.
Don't merge the retry paths — one uses idempotency keys✓ citations verified · src/payments/retry.ts · fingerprinted
Auth uses jose, not jsonwebtoken — CVE in the transitive dep✓ citations verified · src/auth/session.ts · fingerprinted
**"Use the helper in src/ghost.ts"**✗ rejected on write — no such path in this repo
Legacy retry helper is the fallback⊘ withheld from recall — cited file deleted since capture
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.
Auth uses jose, not jsonwebtoken cites src/auth/session.ts — file changed in this diff fix: kage reverify --packet auth-jose · or kage supersede
Webhook retries are capped at 3 cites src/webhooks/retry.ts — constant removed fix: kage learn (update) — then this warning disappears
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
.
100/100 trust benchmark — hallucination & staleness
0 deps no API key, no database, no daemon
348 tests passing on every release
Git-native memory reviewed in the same PR as code
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, 15 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.