Your coding agent's memory should have to prove itself

An agent acting on wrong memory is worse than one with none.

Every memory tool for coding agents has the same quiet failure mode: knowledge written weeks ago keeps getting recalled after the code it describes was refactored away. The store only grows, nothing re-checks it, and the agent confidently acts on stale facts.

We built Kage around one rule: memory has to prove itself. Every memory cites the files it's about, and it's checked against your repo three times:

• On write - a memory citing a file that doesn't exist is refused. Hallucinated knowledge never enters storage.
• On recall - if the cited code changed or was deleted, the memory is withheld and flagged instead of served.
• On your diff - kage pr check warns when a change you're about to merge invalidates something the team knows.

The loop runs itself: sessions that captured nothing get auto-distilled into drafts you review (a signal gate keeps junk out), every session opens with a "previously..." digest, and each recall prints a receipt - tokens and dollars saved, measured per memory.

Memory lives as plain JSON in your repo, reviewed in the same PR as the code. Personal memory syncs over a private git remote you own. No account, no API key, no database.

One command wires Claude Code, Codex, Cursor, Windsurf - anything MCP:

npx -y @kage-core/kage-graph-mcp install

See what your own repo is hiding (read-only, ~1 min): npx -y @kage-core/kage-graph-mcp scan --project .

Site: https://kage-core.com
Repo (GPL-3.0): https://github.com/kage-core/Kage

Teams: we're running live 30-minute demos on your repo - the Truth Report, a stale-catch on a real diff, and the savings receipt at the end. Book one: https://kage-core.com/demo.html

Would love hard questions - especially from anyone who's watched an agent confidently act on stale knowledge.

Comments

[Kage]

Love this, we're treating the same disease in different organs. Yours verifies the agent is in the right mode before it acts; ours verifies the memory it acts on is still true. Both are "don't let the agent run on unchecked assumptions," and funnily enough both ride PreToolUse hooks.

Going to try Brainstorm-Mode, the divergent/actionable split is exactly the failure I keep hitting: ask for options, get a PR. Thanks for the genuinely thoughtful read.

[Mehmet Can Farsak]

The 'prove it' approach to memory is spot on — agents should have receipts for what they know. There's a related blind spot: agents don't prove they're in the right mode before acting. Ask for brainstorming and get a diff. I built Brainstorm-Mode (mehmetcanfarsak on GitHub) which adds that verification layer via PreToolUse hooks — if the agent isn't supposed to be executing, it can't. Three modes (divergent, actionable, academic) keep the context aligned with the actual task.