Cadenya
Paid
Developers building agentic workflows
Kage
FreeSelf-HostedAgentic
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.
Similar tools
JevProxyFreemiumThe proxy sits in front of your Cursor or Claude Code agent fleet and classifies incoming tool…
CadenyaPaidCadenya is an agent runtime built around a layered model: tools connect once through MCP…
Brain MemoryFreeBrain Memory stores agent decisions as Markdown files with YAML frontmatter, organized in a…
EmemFreemiumemem stores facts as short, signed tokens — each one a content-addressed handle that any agent…
Summary
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 4 months 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
Free
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
Free
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
Custom
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.
Find your fit
Before you choose Kage
More options in Agent Frameworks. Compare pricing, platforms, and features side by side.
Brain Memory
Free · Open source
Long-term continuity in multi-session coding projects
Pros
- 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
- 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.
About
- Platforms
- npm, Git
- API Available
- No
- Self-Hosted
- Yes
- Last Updated
- June 22, 2026
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
Frequently Asked Questions
- Is Kage free?
- Kage offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
- 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.
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.
Contribute
- Work on Kage? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.