Google shipped OKF. Kage keeps it true.
Google OKF made agent memory an open standard, Markdown in your repo with no lock-in, but left out the part that keeps it honest. Kage is that part: every memory is checked against your code, so your agent never acts on a stale fact.
One command, then restart your agent. No account, no API key.
100/100 trust benchmark ·
zero-config install ·
no account, no API key ·
free & open source —
or try it before installing anything: npx -y @kage-core/kage-graph-mcp scan --project .
this week≈ $1.24
Google Cloud
Open Knowledge Format is now the standard.
Kage always kept agent memory as plain files in your repo — no cloud, no lock-in, while everyone else built memory clouds. In June 2026, Google Cloud shipped OKF: the same idea, now an open standard. We adopted it on day one, and added the verification layer it's missing.
Every concept is checked against your real code; hallucinated citations are refused on write.
OKF has no notion of staleness. Kage catches drift the moment code changes and withholds it.
A code graph anchors each concept to the exact symbols it describes.
OKF standardizes the store. Kage is the verification layer Google left out — in OKF-legal x-kage-* fields, so a Kage bundle stays 100% conformant.
# OKF fields — readable by any OKF consumer type: Decision title: Auth uses jose, not jsonwebtoken resource: src/auth/session.ts tags: [auth, security] # Kage's verification layer (OKF-legal extension) x-kage-verified: fresh x-kage-anchors: [src/auth/session.ts@9f3c1a…] x-kage-freshness: { ttl_days: 365, policy: source_hash } --- # … prose + # Citations, kept true to the code.
Install once. It runs itself.
1 · Install
One command creates repo memory, builds the code graph, and auto-wires Claude Code and Codex — with a paste-in snippet for every other agent.
2 · It takes notes
Learnings become packets — explicit or auto-distilled — and every citation is verified against your repo before it's written.
3 · Recall, right when it's needed
On Claude Code, verified memory for your task is injected as you work — recalled on each prompt and the moment the agent reads a cited file. Other agents pull the same memory through the MCP tools.
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.
Every memory is checked against your code before it's saved — cite a file that doesn't exist and it's refused on the spot.
How a packet earns trust →Your diff gets fact-checked.
When your change invalidates what the team knew, kage pr check flags it in the same review — the fix one command away.
Remembering is solved. Trusting isn't.
Capture-everything memory solves remembering. Kage solves trusting what's remembered — it re-checks every claim against your code.
| 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-recall | 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 uncited.
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 gate executes in front of you.
Trust score: 99/100 (PASS) · example, depends on your repo Hallucinated-citation rejection: 100% Stale-memory exclusion: 100% Live grounding rate: 98%
See what your own repo is hiding first: npx -y @kage-core/kage-graph-mcp scan --project .
Every MCP agent. Built in the open.
kage install auto-detects your agents — wiring Claude Code and Codex directly, and printing a paste-in MCP snippet for the rest. 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, 15 agents, kage sync over your own private git remote, and kage cloud — a real, self-hostable team server with review-gated packet sharing. No account, no API key.
Kage Cloud
Not built yet
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. Gated on real demand; the waitlist is how we measure it.
Team (managed)
Coming soon
The same review-gated team server, run by us — TLS, uptime, real auth. Self-host it today for free with kage cloud; this is that, 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 — isn't built yet; the waitlist is how we decide whether it should be.
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.