Verified memory for coding agents

# 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.

$ npx -y @kage-core/kage-graph-mcp install
Get early access Read the docs
Kage · savings receiptexample week
412Ktokens saved
this week≈ $6.18
Recalls served from memory38
Stale memories caught & withheld4
Hallucinated citations rejected2
Caller questions answered from the graph11
your numbers, from your repo · kage gains or the viewer's live feed
How it works

## 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.

Capture — with proof

## 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 →
gotcha09:24
Don't merge the retry paths — one uses idempotency keys ✓ citations verified · src/payments/retry.ts · fingerprinted
decision09:41
Auth uses jose, not jsonwebtoken — CVE in the transitive dep ✓ citations verified · src/auth/session.ts · fingerprinted
refused09:52
"Use the helper in src/ghost.ts" ✗ rejected on write — no such path in this repo
stale10:05
Legacy retry helper is the fallback ⊘ withheld from recall — cited file deleted since capture
Recall — already warm

## 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 →
SessionStart · injected~800 tokens
# Previously (Kage) Working on: payment retry consolidation Learned: retry paths must stay separate (gotcha, 2d) Drafts awaiting review: 1 · kage inbox # Recent memory [a3f9c2e1] gotcha retry paths — idempotency keys (2d) [7b21d4f8] decision auth uses jose, not jsonwebtoken (5d) [e8c50a93] runbook npm test --prefix mcp before release (1w) ↳ saved ~12K tokens vs re-reading source
Catch — before it merges

## 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.

The stale-catch commands →
⚠ Your changes invalidated 2 team memories
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
Sync — no account

## 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.

The sync & cloud design →
git@github.com:you/kage-memory.git● synced · 2 machines
kage syncyour remote, your keys

    $ 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

Compare

## 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.

Proof

## 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.

kage benchmark --trust 0 deps · no API key

    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 .`

Early users

## 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

Used everywhere

## 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`.

Claude Code Codex Cursor Windsurf Gemini CLI Cline Goose Roo Code Kilo Code OpenCode Aider Claude Desktop any MCP client
100/100trust benchmark — hallucination & staleness
0 depsno API key, no database, no daemon
238tests passing on every release
Git-nativememory reviewed in the same PR as code
Pricing

## 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.

Join the waitlist

### Team

Coming soon

Shared team memory with review gates — the same PR-reviewed trust model, hosted. Early design partners shape it.

Book a demo

Early access

## 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.

Join the Cloud waitlist Book a demo

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.