Shared memory for developers and their coding agents — so the team stops rediscovering its own codebase

#ai #llm #opensource #devtools

Every team keeps rediscovering its own codebase. Someone already chased down this exact bug last month. The reason that module is shaped the way it is got decided in a thread nobody can find. A new teammate — or a fresh agent session — hits the same wall and re-derives it from scratch.

The knowledge exists. It's just trapped: in people's heads, in closed PRs, in one-off chat sessions that evaporate when the window closes.

Kage is a shared memory layer for developers and their coding agents. Capture a learning once — a bug's root cause, a decision, a gotcha — and the whole team, and every agent (Claude Code, Codex, Cursor, Windsurf, anything that speaks MCP), recalls it the next time it's relevant. The team stops rediscovering the same things.

And it's grounded in your actual code and lives in your repo — so shared memory is reviewed in PRs like everything else, and stays accurate as the code changes.

See it on a throwaway repo in 30 seconds:

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

Shared, like the rest of your codebase

Memory in Kage is a team artifact, not a personal scratchpad:

✍️ Anyone (or their agent) captures a learning as they work — tied to the files it's about.
🔎 The next person to touch that code has their agent recall it automatically — no re-deriving it.
🔁 It's git-native — plain JSON in the repo, reviewed in the same PR, shared with everyone on merge. New hires and fresh agent sessions inherit the team's accumulated context on day one.

No vector DB, no API key, no separate service.

Stays accurate as the code moves

Because each note is tied to the files it describes, shared memory doesn't rot:

a note that cites a file which doesn't exist won't be stored;
when code a note depends on is deleted or refactored, that note is held back and flagged to update;
nothing drifts silently — it's grounded in, and reviewed with, the code.

(You can even measure how grounded your repo's memory is with kage benchmark --trust — a health check, not the headline.)

See what the team remembers

Kage ships a viewer — a shared dashboard of your repo's memory: what the team and its agents have learned, every note wired to the code it's tied to, and what's actually been recalled.