Kage
Summary
Your coding agent rewrites the same auth decision three times because it forgot the last two — and you only find out when a junior dev asks why the pattern changed.
Kage stores agent learnings as files in your repo, verifies every citation against actual source paths before writing, and injects relevant memory the moment an agent opens a cited file. The `kage pr check` command catches stale memory in the diff review — before it merges. The install path is a single `npx` command, no account or API key required. The tool is early-stage with a GitHub star count in the single digits, so production edge cases, documentation gaps, and missing integrations are realistic risks. Teams with complex agent pipelines or non-git workflows will find the current scope narrow.
Bottom line: Pick this for a small team whose coding agents keep re-learning the same repo-specific decisions and where git-based review of agent knowledge fits your workflow — but hold off if your agents span multiple non-git projects or your memory needs exceed what a file-per-packet model can organize.
Pricing Plans
Last verified 2 weeks ago- Free Tier
- Open-source core: verified memory, Truth Report, receipts, auto-capture, repair, live viewer, 15 agents, kage sync over your own private git remote. No account, no API key.
Open source
Everything on this page: verified memory, Truth Report, receipts, auto-capture, repair, live viewer, 15 agents, kage sync over your own private git remote. No account, no API key.
- Verified memory
- Truth Report
- Receipts
- Auto-capture
- Repair
- Live viewer
- 15 agents support
- Git-native sync
- No account required
- No API key required
Kage Cloud
Memory that follows you: your packets on every machine behind one private MCP link u2014 verification stays client-side, so the cloud never sees your code. Early access.
- Private MCP link
- Cross-machine sync
- Client-side verification
- Early access
Team
Shared team memory with review gates u2014 the same PR-reviewed trust model, hosted. Coming soon.
- Shared team memory
- Review gates
- PR-reviewed trust model
View full pricing on kage-core.com →
Pricing may have changed since last verified. Check the official site for current plans.
Community Performance Report Card
No community ratings yet. Be the first to rate this tool!
Community Benchmarks Community
Sign in to submit a benchmarkNo community benchmarks yet. Be the first to share a real-world data point.
Pros
Sign in to edit- Citation verification at write time rejects packets that reference non-existent paths, so hallucinated file references never enter the memory store and agents are not misled by made-up context.
- Git-native packet storage means memory review, approval, and rollback use the PR workflow your team already runs, so there is no separate tool or access model to maintain for shared agent knowledge.
- The `kage pr check` diff command catches stale memory before a PR merges, so a refactor that invalidates a team decision surfaces in code review rather than silently corrupting future agent sessions.
- No account, no API key, and a local install path means agents on your machine gain persistent memory without routing data through a third-party cloud service — relevant if your repo contains code you cannot send externally.
- Sessions open with an automatic digest and file-triggered memory injection, so agents start each session with relevant context rather than requiring manual re-prompting of prior decisions.
Cons
Sign in to edit- There is no API surface: external applications, dashboards, or agent frameworks that need to query the memory graph programmatically cannot do so — teams that need memory accessible outside a local MCP install have no supported path and would need to switch to a memory tool that exposes an API.
- The packet-per-file storage model is scoped to git repositories — agents working across multiple non-git projects, or workflows where memory needs to span codebases without a shared repo root, have no supported storage target.
- With a GitHub star count in single digits and a demo-booking link as the primary enterprise contact path, community-sourced troubleshooting, third-party integrations, and documented production case studies are sparse; teams hitting edge cases in self-hosted setups are largely on their own.
Community Reviews
Sign in to write a reviewNo reviews yet. Be the first to share your experience.
About
- Platforms
- npm, Git
- API Available
- No
- Self-Hosted
- Yes
- Last Updated
- 2026-06-22T08:18:14.250Z
Best For
Who it's for
- Repositories requiring git-based review of agent knowledge
- Developers wanting local, account-free memory without cloud APIs
What it does well
- Providing persistent memory across agent sessions for coding tasks
- Verifying agent citations against source code to prevent hallucinations
- Sharing verified learnings across team members via git
- Detecting and handling stale memory during code changes
Integrations
Discussion Community
Sign in to commentNo discussion yet. Sign in to start the conversation.
Compare Kage
Spotted incorrect or missing data? Join our community of contributors.
Sign Up to ContributeCommunity Notes & Tips Community
Sign in to contributeBe the first to contribute. General notes, observations, gotchas, and tips from people who use this tool day-to-day.
Frequently Asked Questions
- Is Kage free?
- Yes — Kage is fully free to use. There is no paid tier.
- Is Kage open source?
- No — Kage is a closed-source tool. Source code is not publicly available.
- Can I self-host Kage?
- Yes. Kage supports self-hosting on your own infrastructure.
- What platforms does Kage support?
- Kage is available on: npm, Git.
Hours Saved & ROI Stories Community
Sign in to contributeBe the first to contribute. Concrete time/cost savings, with context. e.g. "Cut my code review backlog from 4h to 45m per week."
Curated lists that include this category
Coding agents start each session blank. Hard-won decisions — which retry path uses idempotency keys, which auth library replaced a vulnerable dep — evaporate between sessions and have to be rediscovered, re-explained, or re-prompted every time. Kage addresses this by turning agent learnings into structured packets stored as files in your repository. Each packet is verified against live source paths at write time: a memory citing a file that does not exist is refused immediately. Sessions start with a digest of recent memory injected automatically, and when the agent opens a file, any verified packets that cite it arrive at that moment rather than requiring a separate retrieval step.
The differentiating feature is `kage pr check`, a diff-level fact-check that runs during code review. When a changed file invalidates an existing memory packet, the command surfaces the conflict in the same review as the code and offers a single-command fix — `kage reverify` or `kage supersede`. The vendor states no other memory tool does this. For teams where a refactor silently breaks the assumptions that guided earlier agent decisions, catching that signal before merge is the gap this feature fills.
Kage fits best in repositories where a small-to-medium engineering team uses coding agents regularly and already treats git history as the source of truth for team knowledge. The git-native storage model means memory review, rollback, and sharing follow the same PR workflow the team already uses. The constraints are real: the tool is scoped to code repositories, there is no API surface for external applications to query the memory graph, and self-hosted operation means you manage the installation. Community adoption is early and the GitHub star count is in single digits, so expect rough edges in documentation and sparse community support for non-standard setups.
Installation is a single `npx` command that creates the repo memory structure, builds a code graph, and wires agents on the local machine. The vendor states zero external dependencies and no account or API key requirement. A scan mode — `npx -y @kage-core/kage-graph-mcp scan –project .` — lets teams inspect what Kage would capture before committing to a full install.