Shared memory for AI coding agents — reviewed, not auto-captured
A wave of agent-memory tools — Engram, Recallium, agentmemory, threadctx — gives coding agents automatic recall: they capture context as sessions run and replay it later. The-Snip takes the other trade. Agents file structured items explicitly — a snippet, a saved API call, a short doc — into a workspace that Claude Code, Cursor and any MCP client share, and nothing becomes canon until a human approves it. Auto-capture is convenient, but the store it builds is opaque; you can't audit memory you can't read. Here, every item sits in a review queue in plain language before it's trusted. Explicit filing is a one-line convention in CLAUDE.md, and the payoff is a memory you'd let a new hire read: small, structured, approved — signal over sludge.
Setting this up for Claude Code specifically? A reviewed team memory for Claude Code
Full MCP server contract and setup: MCP docs
How it works
- Create a workspace as the shared memory and generate an API key in Settings → API keys — keys are free on every plan; the agents' writes need Pro & Team, $8/user/month.
- Add the MCP server to each agent's config with the block below — .mcp.json for Claude Code, .cursor/mcp.json for Cursor; any MCP client uses the same shape.
- Write the filing convention into CLAUDE.md or your Cursor rules: call search_base before debugging or writing shared code; after a novel fix, file a short doc titled with the exact error message, plus create_snippet when there's runnable code.
- Let every agent — across editors, repos and machines — read and propose against the same base. Reads return approved canon; writes wait in review.
- Triage the queue on a rhythm: approve genuine lessons, reject noise in bulk, tighten titles so search lands. Approved items become memory for every agent and teammate at once.
{
"mcpServers": {
"the-snip": {
"url": "https://the-snip.com/mcp",
"headers": { "Authorization": "Bearer snip_········_····" }
}
}
}Questions, answered.
How is this different from Engram or Recallium-style auto-capture?
Those tools record memory automatically as agents work — low effort, but the store is opaque and unreviewed, and it grows whether or not what it holds is true. The-Snip inverts the trade: agents file explicit, structured items and a human approves each one, so the memory stays small, readable and auditable. Pick the trade that fits — they're genuinely different products.
Won't agents forget to file things if it's not automatic?
Sometimes, yes — that's the honest cost of explicit filing. A one-line convention in CLAUDE.md (after a novel fix, file a short doc titled with the error message) recovers most of it, and what does get filed was worth writing down, which is why the base stays worth searching.
Which agents can share the memory?
Anything that speaks MCP over Streamable HTTP — Claude Code, Cursor, Windsurf, Claude Desktop — plus scripts over the REST API and the zero-dependency CLI. Same workspace-key model everywhere, and every write from every client goes through the same review gate.
What does a shared agent memory cost?
Reads are free — any agent can search the base on the Free plan. Agent writes (create and update) need Pro & Team, $8/user/mo — or $80/user/year. Agents authenticate with workspace keys rather than seats, so you pay per human. The free plan (25 items) lets you seed the base, connect agents read-only, and trial the review workflow by hand before paying.
Can it hold non-code memory, like decisions and gotchas?
Yes — Markdown docs are first-class items, wikilinked to the snippets and saved API calls they explain. Decision records, gotchas and runbooks all fit, and review keeps them current instead of quietly rotting.
Start your base — free.
Free: 25 items, no card. Pro & Team: $8/user/mo — unlimited items, REST API, review workflow, and the hosted MCP server.