Comparisons
Memory for coding agents, compared.
Nine ways a team gives its coding agents a memory, from a file in the repository to a hosted product: what each is good for, where it stops, and when to use which. Checked October 11, 2026.
- Six criteria, none of them a benchmark
- Nine tools, each with what it is good for
- When to use what, in one table
- Ordered by how much of the team each one reaches
- Every engineer, every agent, every toolTeam memory
- Every teammate, through git, one tool eachA rules file, a memory bank in the repository
- One developer, every editorA per-developer memory service
- One developer, one toolA session recorder, auto memory
- One sessionThe chat history
The same bug costs the team ninety minutes every time it is found on a machine the memory does not reach.
A memory that stays on one machine costs the team the same bug twice. The list is ordered by how much of the team each one reaches.
What to compare on.
Six questions, each about who the memory reaches and what it is a record of. None of them is a benchmark, and none of them is a price.
- 1Across tools
Do Claude Code, Cursor and Codex read the same record, or does each keep its own?
- 2Across teammates
Does a decision made on one machine reach the next engineer’s agent?
- 3Who and when
Does a memory say who recorded it, and which commit it belongs to?
- 4Replaced decisions
When a decision changes, is the old one overwritten, left to mislead, or kept with the reason?
- 5What it remembers
A product’s users, or the team’s software?
- 6Where it runs
Your repository, your machine, your servers, or a managed service?
The nine tools, fairly.
Each is real and each is the right tool for something. From what every team already has to hosted products, here is what each one is built for, what it is good for, and where it stops.
- Built for
- Standing instructions for one agent, in a file it reads at the start of every session.
- Good for
- Conventions and instructions a team wants in front of the agent every time. Free, and already there.
- Where it stops
- They hold what someone wrote, or what one agent noticed on one machine, and they load whole. Not shared across tools, and nothing says who settled what, or when.
- Across toolsPartly: Cursor reads CLAUDE.md
- Across teammatesThrough git
- Who and whenNo
- Replaced decisionsOverwritten
- What it remembersInstructions
- Where it runsYour repository
- Built for
- A directory of markdown the agent reads first and keeps up to date: tasks, active context, progress, system patterns.
- Good for
- One developer who wants structured notes that carry from one session to the next.
- Where it stops
- It works until the second teammate: nobody updates it in the middle of a fix, it conflicts on merge, and every agent loads all of it. The best-known one is built on Cursor’s commands and needs Cursor 2.0.
- Across toolsOne tool
- Across teammatesThrough git
- Who and whenGit blame only
- Replaced decisionsEdited away
- What it remembersNotes and plans
- Where it runsYour repository
- Built for
- Records what the agent did in a session, compresses it, and feeds the relevant part back into the next session through Claude Code’s lifecycle hooks.
- Good for
- One developer who wants their own sessions to remember themselves. The installer also covers Codex, Copilot, OpenCode and others. Apache-2.0.
- Where it stops
- The memory is yours, on your machine, with a cloud backup. Nothing on the project page describes sharing it with a teammate’s agent, or who recorded what. claude-mem alternatives.
- Across toolsYes, per developer
- Across teammatesNot described
- Who and whenNo
- Replaced decisionsSummarised
- What it remembersYour sessions
- Where it runsYour machine, cloud backup
- 4
Mem0
- Built for
- A memory layer for the AI product you ship, remembering each end user, with plugins for Claude Code, Cursor and Codex on top.
- Good for
- A product that must remember its users, and a developer who wants that same layer under a coding agent, shared per repository in the Claude Code plugin.
- Where it stops
- What it stores is facts extracted into a general model of a user. That is a different job from a team’s record of its software. Full comparison: Mem0 alternatives.
- Across toolsYes, plugins
- Across teammatesPer repository, in the plugin
- Who and whenNo
- Replaced decisionsLatest fact wins
- What it remembersA product’s users
- Where it runsManaged, or open source
- Built for
- The same job: memory for the AI product you ship, with Claude Code and Cursor plugins.
- Good for
- A product remembering its users, and a developer who wants a shared memory per repository in Claude Code.
- Where it stops
- The same split: a store of facts about users, not the decisions, root causes and constraints behind a codebase, and nothing says who settled what. Full comparison: Supermemory alternatives.
- Across toolsClaude Code, Cursor
- Across teammatesPer repository, in the plugin
- Who and whenNo
- Replaced decisionsLatest fact wins
- What it remembersA product’s users
- Where it runsManaged, or open source
- 6
Zep
- Built for
- “The unified context layer for enterprise data”: a temporal graph of what an agent learns about users and business data, with the open-source Graphiti underneath.
- Good for
- An agent you ship that has to reason over user and business history as it changes.
- Where it stops
- Serving side. Organised around users and episodes, not repositories and commits; it offers MCP server seats, but no coding-agent plugin is described.
- Across toolsVia MCP
- Across teammatesNo: the agent’s memory
- Who and whenTimestamps, not people
- Replaced decisionsDated, kept in the graph
- What it remembersUsers and business data
- Where it runsManaged, or open source
- Built for
- An agent whose “memory, identity, and capabilities evolve with experience”: the memory belongs to the agent you build, and the agent edits it.
- Good for
- Building your own agent that manages its own memory. Letta Code is its own coding agent.
- Where it stops
- The memory is the agent’s, not the team’s: not a record that other tools or other teammates read.
- Across toolsIts own agent
- Across teammatesNo
- Who and whenNo
- Replaced decisionsThe agent edits it
- What it remembersThe agent’s own state
- Where it runsManaged, or your own server
- Built for
- “Long-term memory for your agents”: typed facts, observations and mental models, with a one-line install that gives each repository a memory bank in 20+ coding harnesses.
- Good for
- One developer using several editors, Claude Code, Codex CLI, Cursor CLI and Copilot CLI among them, who wants the same memory in all of them. Open source; runs embedded, in its cloud, or on your Postgres.
- Where it stops
- Memory banks are “one per user or agent, fully isolated”. Nothing on the page describes a bank shared by a team, or who recorded what.
- Across toolsYes, 20+ harnesses
- Across teammatesNot described
- Who and whenNo
- Replaced decisionsFacts updated
- What it remembersYour agent’s sessions
- Where it runsEmbedded, cloud, or your Postgres
- Built for
- Engineering memory for the team: why its software is the way it is, read and written by every engineer and every coding agent on the repository.
- Good for
- A team whose engineers and agents keep relearning why the code is the way it is, and that wants one record under Claude Code, Codex, Cursor and 60+ MCP clients.
- Where it stops
- Not for a product remembering its users; use one of the serving products above for that.
- Across tools60+ MCP clients
- Across teammatesYes, by repository and role
- Who and whenPerson, session, files, commit
- Replaced decisionsKept, with the reason; the current one marked
- What it remembersThe team’s software
- Where it runsManaged cloud
The nine tools against the six criteria.
The same facts as above, in one table.
| Tool | Across tools | Across teammates | Who and when | Replaced decisions | What it remembers | Where it runs |
|---|---|---|---|---|---|---|
| Built-in files | Partly: Cursor reads CLAUDE.md | Through git | No | Overwritten | Instructions | Your repository |
| Memory banks and a decisions file in the repository | One tool | Through git | Git blame only | Edited away | Notes and plans | Your repository |
| claude-mem | Yes, per developer | Not described | No | Summarised | Your sessions | Your machine, cloud backup |
| Mem0 | Yes, plugins | Per repository, in the plugin | No | Latest fact wins | A product’s users | Managed, or open source |
| Supermemory | Claude Code, Cursor | Per repository, in the plugin | No | Latest fact wins | A product’s users | Managed, or open source |
| Zep | Via MCP | No: the agent’s memory | Timestamps, not people | Dated, kept in the graph | Users and business data | Managed, or open source |
| Letta | Its own agent | No | No | The agent edits it | The agent’s own state | Managed, or your own server |
| Hindsight | Yes, 20+ harnesses | Not described | No | Facts updated | Your agent’s sessions | Embedded, cloud, or your Postgres |
| Recallium | 60+ MCP clients | Yes, by repository and role | Person, session, files, commit | Kept, with the reason; the current one marked | The team’s software | Managed cloud |
When to use what.
Most of these are not alternatives to each other. Start from your situation.
| If | Use |
|---|---|
| You want instructions in front of the agent every session | Built-in files. Keep them whatever else you add. |
| You are one developer and want structured notes the agent keeps | A memory bank in the repository. |
| You are one developer on Claude Code and want sessions to remember themselves | claude-mem. |
| You are one developer working across several editors | Hindsight or Recallium: both put one memory under every editor you use. |
| You ship a product that must remember its users | Mem0, Supermemory or Zep. The right tool for a different job. |
| You are building your own agent that manages its own memory | Letta. |
| You are a team whose engineers and agents keep relearning why the code is the way it is | Recallium, with the rules files kept for instructions. |
Use them together. Keep the rules files for instructions, and keep what the team works out in a memory every engineer and every agent reads.
Team memory for coding agents, defined.
Team memory for coding agentsis the record of what a team's engineers and agents have worked out about its software, read by every agent on the team in any tool: the decisions and what they replaced, the root causes and the fixes, the constraints and the conventions, each with who recorded it and which commit it belongs to.
It is also called shared memory for coding agents, agent memory for engineering teams, and engineering memory for AI agents. Most tools on this list are built for a different job, remembering a product's users. The split is on Serving Memory vs. Engineering Memory; the stage-by-stage view is Memory for coding agents.
In detail: Recallium vs built-in agent memory
CLAUDE.md and Cursor Rules are where most teams start. They are the right home for standing instructions; Recallium keeps what the agents work out, and shares it.
| Recallium | Claude Code: CLAUDE.md and auto memory | Cursor Rules | |
|---|---|---|---|
| Who writes it | Agents, as the work lands | You write CLAUDE.md; Claude writes auto memory notes | You; admins for Team Rules |
| What it holds | Why the code is the way it is: decisions, root causes and fixes, linked to files | Instructions; learnings and preferences Claude picks up | Instructions and conventions |
| How it is read | Searched on demand; only the relevant results are expanded | Loaded every session; auto memory loads its first 200 lines or 25KB | Always, by file pattern, by the agent’s choice or by @-mention |
| Shared with | Every teammate’s agent on the repository (Cloud Pro) | CLAUDE.md through git; auto memory stays with you | Project Rules through git; Team Rules on Team and Enterprise plans |
| Works in | Claude Code, Codex, Cursor, GitHub Copilot and any MCP client | Claude Code; Cursor also reads CLAUDE.md | Cursor (Agent only) |
Use them together: keep rules files for instructions, and Recallium for the record of decisions and fixes. More on each agent: Claude Code memory, Codex memory and Cursor memory (Cursor removed its separate Memories feature in version 2.1).
In detail: Recallium vs Mem0 and Supermemory
Mem0 remembers users. Recallium remembers engineering. Mem0 and Supermemory are serving memory for the AI product you ship to your users, with coding-agent plugins on top. Recallium is institutional engineering memory for the team building it: why that matters. Each has a full comparison: Supermemory alternatives and Mem0 alternatives for coding agents.
| Feature | Recallium | mem0.ai | Supermemory |
|---|---|---|---|
| Built for | Engineering work: the decisions, fixes, constraints and rules behind a team's software, with the current decision made explicit | AI apps remembering their end users; plugins for Claude Code, Cursor, Codex and more | AI apps remembering their end users; Claude Code and Cursor plugins |
| Deployment | Managed cloud | Managed platform, or Apache-2.0 open source | Managed service, or MIT-licensed open source |
| Memory for software work | Follows the work from design to ship: handoffs, team rules, commit trailers | Shared memory per repository in the Claude Code plugin | Team memory per repository in the Claude Code plugin |
| MCP integration | 60+ MCP clients; one installer wires 16+ coding agents | MCP integration | MCP integration |
| LongMemEval-S | 99.8% hit@10 · 98.4% QA, full protocol published | 94.4% QA (README) · 93.4% in result files, GPT-5 reader and judge, depth 200 | 95% recall@15, source page withdrawn |
Product details checked October 3, 2026. Features and availability vary by edition. The benchmark figures measure different things: Recallium’s headline is retrieval at depth ten, Mem0’s is answer accuracy at depth 200, so they are not directly comparable and this is not a controlled head-to-head ranking. On the accuracy lane, Mem0’s committed result file records 93.4% from 200 results; Recallium reaches 98.4% from 3.8 results on average. The readers differ (GPT-5 against Claude Opus 5.5), so this is a difference in context needed, not a ranking. Supermemory’s recall@15 was published at supermemory.ai/research/longmembench, which now redirects to their home page. Sources: Mem0 documentation · Supermemory product overview.
One record, every engineer, every agent
A memory that stays on one machine costs the team the same bug twice. Join the waitlist for Recallium Cloud.