{ "markdown": "
\n\n\"Kage\"\n\n\n### Kage manages your memory and agents\n\nState an intent. Kage's orchestrator briefs a coding agent from your repo's own memory, runs it\nin an isolated git worktree — a single run or a multi-wave goal — and **re-runs the checks\nitself** rather than trusting the agent's report:\n\n```\n┌ VERIFIED 3/3 — checks run by Kage, not the agent · build-a-stale-memory-triage-surface-do-n-260818-ec2c\n│ \"the stale-memory triage surface is built and wired into the review flow\"\n│ ✓ tests ran npm test --prefix mcp → exit 0 evidence/tests.log\n│ ✓ diff-size inspected at most 800 changed lines evidence/diff-size.log\n│ ✓ citations inspected every formally cited path exists (directly, or as a unique suffix) in the worktree evidence/citations.log\n│ · touched 4 file(s), 212 line(s)\n└────────────────────────────────────────────────────────────────\n```\n\nA real receipt from this repo's own run history. Every row is a command Kage ran or a fact\nit inspected — never a claim the agent made about itself. `kage merge` only lands the code once\nthe claim holds, and ratifies what the agent learned, so the next brief, yours or a teammate's,\nstarts smarter.\n\nThat memory is the decisions behind your codebase, the runbook for a tricky deploy, the root\ncause of a gnarly bug — captured as your agents work and checked against the actual code, so\nwhat gets reused stays true. It's kept as plain Markdown files in your repo, conformant to the\n[Google Open Knowledge Format (OKF)](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf)\nso there's no lock-in, and shared with your whole team through git. No account, no database,\nno API key.\n\n```bash\nnpx -y @kage-core/kage-graph-mcp install\n```\n\n

\n \"npm\n \"downloads\"\n \"license\"\n \"zero-dependency\n \"no\n \"Built\n

\n\n\"Kage\n\n

\n Website ·\n Docs ·\n Live viewer ·\n npm ·\n Book a demo\n

\n\n**Works with** Claude Code · Codex · Cursor · Windsurf · Gemini CLI · Cline · Goose ·\nRoo Code · Kilo Code · OpenCode · Aider · Claude Desktop · Copilot · OpenClaw · Hermes · any MCP client\n\n🌐 English · [简体中文](translations/README.zh-CN.md) · [日本語](translations/README.ja.md) · [한국어](translations/README.ko.md) · [Español](translations/README.es.md) · [Português (Brasil)](translations/README.pt-BR.md) · [Français](translations/README.fr.md) · [Deutsch](translations/README.de.md) · [हिन्दी](translations/README.hi.md)\n\n
\n\n---\n\n## Install\n\n**One command, inside your repo, then restart your agent.** That's the whole setup.\n\n```bash\nnpx -y @kage-core/kage-graph-mcp install\n```\n\nIt creates `.agent_memory/`, builds the code graph, writes the `AGENTS.md` / `CLAUDE.md`\npolicy that tells agents to use Kage, auto-detects and wires your agents, and configures\n`.gitignore` + the packet merge driver. Requires Node.js 18+. No account, no API key.\n\n**Or just ask your agent to set it up.** Paste this into Claude Code, Cursor, or any coding agent:\n\n> Set up Kage (verified memory for coding agents, https://github.com/kage-core/Kage)\n> in this repo: run `npx -y @kage-core/kage-graph-mcp install`, then tell me to restart you.\n\n
Other ways (plugin · per-agent · memory-only)\n\n```bash\n# Claude Code / Codex plugin\n/plugin marketplace add kage-core/Kage # then: /plugin install kage@kage\n\n# wire a single agent (run `kage setup list` for all supported)\nkage setup claude-code --project . --write\n\n# memory store only, no agent wiring\nkage init --project .\n\n# confirm the harness is live\nkage setup verify-agent --agent claude-code --project .\n```\n
\n\n## Delegate work (the orchestrator)\n\n```bash\nkage room --project . # talk to Kage; it briefs and hires agents for you\nkage dispatch \"\" --agent claude # one delegated run, briefed from repo memory\nkage runs --project . # what every run is doing right now\nkage review --project . # read a finished run's claim and diff\nkage merge --project . # land the code and ratify what it learned\n```\n\nEvery run works in its own git worktree. The checks that decide the verdict on the receipt\nabove — tests, diff size, citations — are commands **Kage** runs itself, never the agent's\nself-report.\n\n- **The app.** `kage app --project ` starts (or reuses) the local daemon and opens the\n same room, runs board, and memory view in a UI. From a checkout, `npm start --prefix shell`\n runs it as a native window — a thin Electron shell with no HTML of its own, it just loads the\n daemon's own page — and `npm run dmg --prefix shell` builds a macOS `.dmg` (arm64 only;\n Windows/Linux packaging isn't built yet).\n- **From your phone.** The daemon can also bind to your machine's LAN address, gated by a\n pairing secret required on every request, reads included. Today that means setting\n `\"lan\": true` in `.agent_memory/config.json` by hand — there's no `--lan` flag or app toggle\n yet.\n- **Add a project without a terminal.** `kage projects add --agent claude` registers\n another repo the same way the app's \"+\" button does, then `kage app --project ` opens it.\n\n```bash\nkage app --project \nkage projects add --agent claude\n```\n\n## Desktop app\n\nA thin native shell (macOS, arm64 only) over the same daemon the CLI runs — dock presence,\na global hotkey, native notifications. Download the latest `.dmg` from\n[GitHub releases](https://github.com/kage-core/Kage/releases) (look for a\n`Kage-.dmg` asset).\n\nUnsigned builds show macOS's \"unidentified developer\" prompt on first launch —\nright-click the app in Finder and choose **Open** once. Once installed, it checks for\nupdates on launch and every 4 hours and installs on restart; ad-hoc (unsigned) builds\ncan't self-install and notify you instead, linking back to the releases page.\n\nPrefer the CLI? The one-line install works everywhere the app doesn't need to:\n\n```bash\nnpx -y @kage-core/kage-graph-mcp install\n```\n\n## What is Kage\n\nKage is an orchestrator for coding agents, built on a memory layer. As your agent works, it captures what it learns\n(decisions, bug fixes, conventions, how the code fits together) as\n[**Open Knowledge Format (OKF)**](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf)\nconcept files committed in your repo under `.agent_memory/`. The next session (yours or a\nteammate's) starts already knowing it, instead of re-reading or re-asking.\n\nThree things make it different from other memory tools:\n\n- **It's collaborative.** The knowledge one person (or their agent) figures out becomes the\n whole team's. Memory is shared through git, so a teammate's next session starts with what\n you just learned, not a blank slate.\n- **It's standard & git-native.** Memory is a conformant OKF bundle — plain Markdown in your\n repo, reviewed in the same PR as the code, readable by any OKF tool — not locked in one\n machine or a vendor's cloud. Your knowledge stays yours.\n- **It's verified.** Every memory cites the code it's about, and Kage checks those citations\n against your actual files at write time, at recall time, and when a diff changes the code.\n Memory that no longer matches the code is withheld, so the agent never acts on a stale claim.\n\n## Kage called it. Google standardized it.\n\nFrom day one, Kage kept agent memory as plain files in your repo — no cloud, no database, no\nlock-in, while everyone else was building memory clouds. In June 2026, Google Cloud shipped\nthe **Open Knowledge Format**: knowledge as Markdown in git, vendor-neutral, no account — the\nexact thesis Kage already ran on. So Kage **adopted OKF as its standard, and supercharges it**\nwith the layer OKF deliberately leaves out:\n\n- **Verification** — OKF stores what you wrote down; Kage checks every concept against your\n real code and refuses hallucinated citations at write time.\n- **Freshness** — OKF has no notion of staleness; Kage catches drift the moment your code\n changes and withholds memory that's no longer true.\n- **Code-grounding** — a deterministic code graph anchors each concept to the exact symbols it\n describes — the layer OKF leaves to tooling.\n\nThe trust metadata rides in OKF-legal `x-kage-*` fields, so a Kage bundle stays 100%\nconformant and opens in any OKF consumer, including Google's own visualizer.\n**OKF standardizes the store; Kage is the verification and freshness layer Google left out.**\n\n## How it works\n\nOnce installed, it's ambient. You don't run anything by hand:\n\n1. **Recall before acting.** At the start of a task (and the moment the agent opens a file),\n Kage surfaces the relevant verified memory for it. Stale or deleted memory is left out.\n2. **Capture as it works.** Durable learnings become packets. A memory that cites a file\n which doesn't exist is rejected on the spot, so hallucinations never enter storage.\n3. **Stay honest as the code moves.** When a diff changes code that a memory cites, that\n memory is flagged at commit/PR time (`kage pr check`) and withheld from recall until it's\n re-verified or replaced, so knowledge can't quietly rot.\n\nWatch it happen in the **local dashboard** (`kage viewer`): packets, the memory↔code graph,\ntrust gates, and live events stream in as the agent works. Wrap anything in\n`…` and it's never stored.\n\n

\n\"kage\n

\n\n

`kage viewer`: the memory engine underneath the orchestrator above — your\nteam's decisions, runbooks, and bug fixes (purple), kept in the repo and linked to the code they\nare about (blue).

\n\n## Why Kage\n\nMost memory tools ([claude-mem](https://github.com/thedotmack/claude-mem),\n[agentmemory](https://github.com/rohitg00/agentmemory), mem0, Zep) store memory per-machine\nor in a cloud you don't own, and never re-check it against the code. Kage keeps it in your\nrepo and verifies it, so it stays your team's and stays true as the code changes.\n\n| | Kage | claude-mem | mem0 / Zep |\n|---|---|---|---|\n| Automatic capture + session-start recall | ✓ | ✓ | via SDK |\n| Hallucinated citations **rejected at write time** | ✓ | — | — |\n| Stale memory **withheld at recall** (cited files deleted/changed, TTL, reported) | ✓ | — | — |\n| **Diff-time stale-catch**, warned before the PR when your change breaks a memory | ✓ | — | — |\n| Memory reviewed in git, same PR as the code (plain files, no DB) | ✓ | SQLite + cloud | hosted API |\n| Codify memory into team `SKILL.md` files agents auto-load | ✓ (`kage skills`) | — | — |\n| Cross-machine sync | ✓ your own git remote | their cloud | their cloud |\n| Account / API key required | none | cloud optional | yes |\n\n## Features\n\n- **Truth Report.** `kage scan` reads any repo in ~60s and surfaces its highest-risk\n knowledge gaps: undocumented hot files, untested hot paths, complexity hotspots,\n unresolved code debt, and bus-factor-1 files, plus duplicate implementations, dead\n exports, and doc lies when they exist. Every finding cited to `file:line`. Zero setup,\n nothing generated, runs before you install anything.\n- **Savings receipts.** `kage gains` keeps a per-repo value ledger (tokens + $ the agent\n didn't have to re-spend), every number traceable to a logged event; the agent relays it\n after each recall.\n- **Team skills.** `kage skills` turns durable, verified procedures into\n `.claude/skills//SKILL.md` files agents auto-load, committed and shared, no cloud.\n- **Personal memory & sync.** `kage learn --personal` keeps cross-machine notes in\n `~/.kage/memory`, recalled as a clearly separated lower-trust section and synced over your\n own git remote.\n- **Self-healing session loop.** Uncaptured sessions are auto-distilled into pending drafts\n you review; `kage resume` opens each session with a \"previously…\" digest; `kage repair`\n fixes broken packets and indexes in one command.\n\n## Benchmarks\n\n- **18% faster than grep at equal correctness** on real code-navigation tasks (N=3 suite,\n same agent/model; reproduce with `kage benchmark --project . --compare`).\n- **LongMemEval-S retrieval:** 98.72% R@10 / 99.79% R@20 / 0.909 MRR — ahead of plain BM25\n at every depth except R@5, where BM25 edges it (96.60% vs 96.17%; full table in\n [benchmarks/LONGMEMEVAL.md](benchmarks/LONGMEMEVAL.md)). The retrieval path itself is\n dependency-free: BM25 + sparse lexical scoring, no embeddings, no network.\n- **Memory Correctness Under Change:** 0% stale-served (memory whose code was deleted or\n changed is withheld), vs 100% for capture-everything stores.\n- **Trust benchmark:** 100/100, covering hallucination rejection, stale exclusion, and live\n grounding (`kage benchmark --trust --project .`).\n\nMethodology, commands, and caveats: [docs/BENCHMARKS.md](docs/BENCHMARKS.md).\n\n## Daily commands\n\n```bash\nkage recall \"how do I run tests\" --project .\nkage verify --project . # check citations against current code\nkage pr check --project . # stale-catch + graph freshness gate\nkage gains --project . # what Kage saved you\nkage viewer --project . # local dashboard\nkage okf migrate --project . # render memory as a Google OKF bundle\n```\n\nFull CLI and MCP reference: [docs](https://kage-core.com/guide.html).\nDelegating work to coding agents (dispatch → verified claim → merge): [docs/DELEGATION.md](docs/DELEGATION.md).\n\n## Storage\n\nEverything lives in `.agent_memory/`: `packets/` is durable repo memory (git-tracked OKF Markdown);\n`graph/`, `code_graph/`, `structural/`, and `indexes/` are rebuildable with `kage refresh`;\n`reports/` holds the value ledger and health reports. Capture scans for secrets and PII\nbefore writing.\n\n**Standard format — Open Knowledge Format (OKF).** Kage's memory is an\n[OKF](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf) bundle:\nplain Markdown concept files with YAML frontmatter, readable by any OKF consumer\n(including Google's visualizer). Run `kage okf migrate` to render the store as an OKF\nbundle under `.agent_memory/okf/`. Kage adds the lifecycle OKF leaves out — grounding,\nverification, and freshness — carried in OKF-legal `x-kage-*` fields, and can `import`\nany third-party OKF bundle. The round-trip is lossless. See [OKF_STANDARD.md](OKF_STANDARD.md).\n\n## Development\n\n```bash\ncd mcp\nnpm install\nnpm test\nnpm run build\n```\n\n## Contributing & community\n\nKage is built in the open and we'd love your help. Four runtime dependencies (the\nretrieval core uses none), no account, no cloud — it's a friendly codebase to jump into.\n\n- **[CONTRIBUTING.md](CONTRIBUTING.md)** — dev setup, project layout, conventions.\n- **[ROADMAP.md](ROADMAP.md)** — where Kage is headed, and where to plug in.\n- **[Good first issues](https://github.com/kage-core/Kage/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)** ·\n **[Help wanted](https://github.com/kage-core/Kage/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22)** — scoped places to start.\n- **[Discussions](https://github.com/kage-core/Kage/discussions)** — questions, ideas, show-and-tell.\n\nBy participating you agree to our [Code of Conduct](CODE_OF_CONDUCT.md).\n\n## License\n\nGPL-3.0-only. See [LICENSE](LICENSE). Releases before the GPL switch were MIT.\n", "bytes": 16657, "sha": "e0fb5b362d484d11360e91d3e40280e1d835f52a31802aeed5b69457782c3c69", "repo_slug": "kage-core/kage", "fonte": "repo", "truncated": false, "api": "https://agentalog.com/api/listings/mcp_com_kage_core_kage_81fbd093/readme" }