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. And one proxy brings that verified memory to every agent you run.
One proxy fronts the Anthropic, OpenAI-compatible, and Gemini wire formats —
Claude Code, Codex CLI, Cursor, aider, Gemini CLI — with zero per-agent plugins.
No account, no API key. Or try it before installing anything:
npx -y @kage-core/kage-graph-mcp scan --project .
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 — carried in
OKF-legal x-kage-* fields, so a Kage bundle stays 100% conformant and
readable by any OKF consumer.
# 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.
Capture → verify → inject → receipts. A loop, not a database.
Agents write down what they learn. Kage decides — deterministically, against the code — what is still true enough to say back.
Learnings become markdown in git
Decisions, gotchas, runbooks — written as OKF concept files under .agent_memory/. No lock-in: teammates get the memory by cloning the repo.
Every claim is checked against the repo
Citations are resolved against the real code, deterministically. A memory that cites a file that changed under it is flagged — not silently trusted.
Only verified memory reaches the prompt
Verified, approved claims inject where relevant. Stale memory is withheld with a stated reason. Injecting nothing is a first-class outcome.
Everything measurable gets measured
Bytes, injections, recalls served, stale withheld — receipts on your real traffic. Anything estimated is labelled an estimate.
One command. Zero per-agent plugins.
kage up starts a local proxy that fronts three wire formats. Any agent
that speaks one of them gets injection, reversible history compression, and the same
honesty gates — with no per-agent wiring at all.
Claude Code, Codex CLI, aider — anything that honors ANTHROPIC_BASE_URL, or just kage run -- claude.
Cursor and the wide world of OpenAI-format clients, pointed at the same local port.
Gemini CLI and Gemini-format tools, through the same proxy with the same gates.
The gate that says nothing when it should.
Most memory tools optimize recall. Kage also measures the other side: never injecting on absent topics, never injecting what the code disproves. Both rates are benchmarked at zero — and drift-checked so they stay there.
A store audit of 367 real packets shows what earns its keep: ops and verification runbooks are the most-recalled class (~1.0–1.4 uses per packet); reference dumps that restate the code measure 0.00. Kage stores what code cannot say.
Full benchmark table →benchmarks/injection-relevance-kage.mjs · drift-checked in CIRemembering 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 |
| Works with every agent through one proxy | ✓ 3 wire formats | Claude only | per-SDK |
| Savings receipts (measured, never estimated) | ✓ | 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.
Long sessions, digested. Nothing lost.
Turned on, the proxy digests conversation history into compact form — reversibly. The exact originals are always retrievable. Measured on real repo bodies over a 12-turn session, not on synthetic filler.
The honest caveat: compressing a single body on real traffic measures roughly 0%. History is where the savings are — which is why this works on history.
How it is measured →npm run bench:compressionShared memory, with a report your lead can trust.
A workspace syncs approved memory across the team — review-gated, tenant-isolated,
and proven against a real PostgreSQL, not a mock. If the workspace goes down, local
memory keeps working. kage report team answers the only question that
matters: is this actually helping?
$ kage report team
One command, measured on your traffic:
- Recalls served and stale withheld — counted, not sampled
- Live injection rate with confidence
- Store composition by derivability — what memory holds that code cannot say
- Dark areas: subsystems with zero memory coverage
- Review health across the team
Free where it matters. Verified everywhere.
The open-source core is complete on its own — verification, receipts, the all-agent proxy, sync over your own git remote. Local-first, private by default.
Everything on this page: verified OKF memory, the injection gate, history digestion, receipts, the team report, viewer + portal, and sync over your own private git remote. No account, no API key.
The review-gated team server — tenant-isolated Postgres, approved-only sync, audit log — is code-complete and self-hostable now (Docker + backup/restore in the repo). Raw prompts never leave your machines.
The same workspace, run for you. Honest status: the technical gates pass, but no design-partner pilot has completed yet — that is the bar we hold before charging anyone. Book a demo to be an early partner.
Two commands. Then any terminal.
Requires Node.js 18+. No account, no API key. Memory lives in your repo as markdown — review it in the same PR as the code.
$ npx -y @kage-core/kage-graph-mcp install # memory store + code graph, once per repo $ kage up # background proxy: anthropic · openai-compatible · gemini $ kage run -- claude # or: export ANTHROPIC_BASE_URL=http://localhost:8788 $ kage status --project . # receipts for what it measured $ kage down # stop it when you are done
kage up starts in audit mode — measurement only; your bytes
are forwarded unchanged and nothing is injected until you opt in with
kage up --mode assist. Off by default is a feature, not a limitation.
What we will not claim
Where we are: every number on this page comes from this repository's own benchmarks and test suites, reproducible from the source. There are no customer pilots yet; nothing here is a testimonial. "Works with all agents" means the three wire formats named above — Anthropic, OpenAI-compatible, and Gemini — not literally everything.
Stop letting your agent forget.
The open-source core installs in 60 seconds. Demos are 30 minutes, your repo, live.