Git-native memory for coding agents

Your coding agent forgets everything. Kage gives it memory that's verified against your code.

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.

$ npx -y @kage-core/kage-graph-mcp install

One command sets up everything, then restart your agent. Or just tell your agent:

Set up Kage in this repo (https://github.com/kage-core/Kage): run npx -y @kage-core/kage-graph-mcp install, then tell me to restart you.

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 .

Kage · savings receiptexample week

your numbers, from your repo · kage gains or the viewer's live feed

How it works

Install once. It runs itself.

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 →

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

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%

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.

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.

100/100trust benchmark — hallucination & staleness

0 depsno API key, no database, no daemon

348tests 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.