Memory for Coding Agents Compared: Mem0, Letta, Zep, Cognee, Context7, and Unblocked (2026)

VibeMemBench, a September 2026 benchmark of memory for coding agents, ran 111 coding targets drawn from 90 real repositories. Eleven of twelve pairings between a memory system and a coding agent failed to beat the same agent with memory switched off (arXiv, 2026). For a team that wants shared context rather than per-developer recall, Unblocked is the pick. We tested that with one prompt, one model and one codebase, first with no context server, then with Unblocked's institutional context for coding agents attached: token use fell 42% and tool calls 64% (Unblocked, 2026). Mem0, Letta, Zep and Cognee are good at what they were built for, which is remembering what an agent or a user said. Context7 is a documentation retriever. None of them know what your team decided in Slack, Jira, Confluence or a PR review, and that gap is what this comparison is about.

What Does Each Memory Tool Cost in 2026?#

Every tool here has a free tier, and paid entry points run from $10 per seat (Context7) to $125 per month (Zep), with per-seat pricing at Letta, Context7 and Unblocked (Context7, Zep, 2026). Prices below were checked on 2026-10-22 against each vendor's live pricing page.

Mem0's Hobby tier is generous on writes and tight on reads, which suits one developer capturing notes more than a team querying them (Mem0, 2026). Cognee bills $1 per million tokens and $5 per extra workspace (Cognee, 2026). Letta's Teams Pro adds shared agents with access control (Letta, 2026), and Unblocked's Platform plan is $29 per user per month billed annually (Unblocked, 2026).

Is there a memory layer for Claude Code and Cursor that is shared across an engineering team?#

Yes, in two different shapes. Mem0's Claude Code plugin keeps a project memory pool per repository that "everyone on the repo reads and writes," while personal preferences stay keyed to a user_id (Mem0 docs, 2026). That is the closest any memory product gets to a team memory layer out of the box.

The second shape is a context engine. A context engine is a system that indexes the tools a team already uses and answers from them, so nobody has to write memories at all. The difference matters because a memory layer only knows what someone told it. For example, if the decision to drop a deprecated API lives in a Jira comment and a Slack thread, no memory pool contains it until a developer pastes it in. That step is where sharing breaks down. See team memory hubs for AI agents for the hub pattern and what a context engine is for the indexing one.

Mem0 or Letta for a company's engineering knowledge, or is there something built for codebases?#

Both are strong agent memory layers, and neither was built for a company's engineering record. An agent memory layer is a store that keeps what an agent or user said in earlier sessions and serves it back on the next run. Mem0 reports 94.4 on LongMemEval at roughly 6,900 tokens per query, and the same report lists Letta at 74.0 on LoCoMo (Mem0 State of AI Agent Memory, 2026). Those are conversation-recall benchmarks.

Mem0#

Mem0 extracts facts from conversations and scopes them to users, agents, apps and runs. It exposes them through a hosted MCP server at mcp.mem0.ai with 11 tools for Claude Code, Cursor, Windsurf and others (Mem0 docs, 2026). Memories live in your Mem0 account rather than on the laptop, so a team can share a project pool. What goes in is still what an agent observed in a session.

Letta#

Letta's unit of memory is a block that several agents can attach, so an update by one agent is visible to all of them; concurrent full rewrites are last-write-wins (Letta docs, 2026). Its hosted MCP server lets any MCP client create and message stateful Letta agents with an API key, and memory is scoped per agent rather than per user (Letta docs, 2026). Letta is an agent runtime with memory, which is a good fit for building agents and a loose fit for "what does our team know about this service."

What Do Zep and Cognee Add for Engineering Teams?#

Zep and Cognee bring structure: both store a graph rather than a list of facts. Zep's Context MCP server fixes the target graph to the authenticated identity, so one developer cannot read another's user graph, and teams share only through standalone graphs an administrator enables (Zep docs, 2026).

Zep#

Zep's Context Graph records facts, entities and episodes with the time a fact became invalid stored on its edge, fed by chat messages, JSON and documents (Zep concepts, 2026). Shared graphs can be limited to groups through attribute-based access control. The free tier includes one Context MCP seat, and Flex is $125 a month (Zep pricing, 2026). Team memory is possible, with setup.

Cognee#

Cognee's MCP exposes remember, recall and forget. In standalone mode each instance keeps separate data; in API mode several instances share one knowledge graph under a single user token (Cognee docs, 2026). Cognee Cloud's hosted MCP scopes calls to the workspace a member belongs to, and writes land in a dataset named after the client, such as claude_code_memory (Cognee Cloud, 2026). It is the most data-engineering-flavored option here, which suits teams that want to build their own knowledge graph from documents.

Can you use Context7 for our internal code and docs instead of public library docs?#

Partly, on a paid plan. Context7's Pro tier adds private repositories at $5 per million tokens parsed, and the Enterprise page lists private repos, wikis and PDFs as sources, with a self-hosted option (Context7 plans, Context7 enterprise, 2026). So internal docs can be indexed. What you get back is still documentation retrieval.

Context7 exposes two MCP tools, resolve-library-id and query-docs, and returns snippets for a named library (GitHub, 2026). That design is excellent for "show me the current API for this framework" and poorly matched to "why did we stop using this framework." It has no write path, so nothing an agent learns is stored. It reads docs, so a Jira ticket, a Slack decision or a PR review thread is invisible to it. Access is per teamspace, with no mapping to source-system permissions. Treat Context7 as a documentation feed, and treat memory for coding agents as a separate purchase.

How Do the Six Tools Compare Side by Side?#

The split is visible once scope and sources sit in one table. Four tools scope memory to a user, an agent or a graph, Context7 scopes access to a teamspace, and only Unblocked indexes code, chat, tickets and docs with source permissions preserved (Unblocked docs, 2026).

Reading across the rows, memory is per-person by default everywhere except the last row. That is the right default for personal preferences and the wrong one for a team's engineering knowledge, which should be shared by construction and filtered by what each person may see.

Persistent memory for coding agents across sessions and repos: what do teams use?#

In practice, teams run two layers. A 2026 study of 12 memory systems across 11 datasets found no single architecture wins every workload; results depend on which bottleneck the memory structure fits (arXiv, 2026). Cross-session recall and cross-repo knowledge are different bottlenecks.

For cross-session recall, a rules file plus one agent memory product covers most of it; Mem0's hosted MCP or Zep's Context MCP server gives an agent back its own history on the next run. For cross-repo knowledge, teams need something that already knows the other 400 repositories and the discussions around them, which is where a context layer for AI agents replaces hand-curated memory. VibeMemBench is worth keeping in mind here. Injecting verified prior experience raised resolution on four of five agents by 1.1 to 4.5 percentage points, yet eleven of twelve pairings with the four existing memory systems failed to beat the memory-off baseline from the same history (arXiv, 2026). Memory that must be written before it can be read is where teams lose the benefit.

Which memory MCP server works for a whole team, not one developer's machine?#

Three qualify on the vendor's own terms, with caveats. Mem0's hosted MCP stores memories in the account rather than on the laptop (Mem0 docs, 2026). Zep's Context MCP server supports shared graphs when an admin allows standalone graphs (Zep docs, 2026). Cognee Cloud's hosted MCP serves the workspace a member belongs to (Cognee Cloud, 2026).

The caveat is shared: a team memory MCP server is a bucket someone has to fill, and it holds whatever each agent chose to write, never the pull request where the approach changed. Unblocked's MCP server installs in Claude Code with one command and connects by OAuth, so each developer's queries run under their own access (Unblocked docs, 2026). A shared server that can also answer "who decided this and when" is the version of memory for coding agents a team can depend on. Adding it as one server also keeps the tool count down, as covered in MCP tool overload.

Context7 vs Mem0 vs a company context engine for coding agents: which one?#

All three can run at once, and they answer different questions. Context7 answers one: what does this library's current API look like? Mem0 answers another: what did I tell the agent last week? A context engine answers a third: what does the team know about this service? Mem0 reports 92.5 on LoCoMo for the middle job (Mem0, 2026).

The practical difference is the write path. Context7 never writes; it indexes published docs and, on paid plans, your private repos (Context7 plans, 2026). Mem0 writes what an agent extracts from a session. A context engine writes nothing by hand, because it indexes the sources where the knowledge already lives and connects code, discussions, tickets and docs in one query. Choose based on who does the remembering: the vendor's crawler, your agent, or your systems of record. The last is what engineering teams usually mean by memory for coding agents, and the best knowledge base for AI agents comparison walks through the same choice.

Frequently Asked Questions#

Most questions about agent memory come down to scope, and the vendor docs answer them precisely: Zep ties memory to the authenticated identity, Mem0 to user_id and agent_id, Cognee to the workspace (Zep docs, 2026).

Can a memory product and Unblocked run together?#

Yes. Keep Mem0 or Zep for an agent's own history and preferences, and point the same agent at Unblocked for team knowledge. They never compete for the same facts.

Is Context7 a memory MCP server?#

No. It retrieves documentation by library ID and stores nothing from the session (GitHub, 2026).

Which option respects source permissions?#

Zep applies group-based access on shared graphs, and Unblocked enforces each connected tool's existing permissions so a user only sees answers built from material they can already open (Unblocked docs, 2026).

Does a bigger context window remove the need for memory?#

No. Mem0 reports about 6,900 tokens per retrieval call, against roughly 26,000 tokens per conversation for full context in its 2025 paper, and notes that the two are measured in different units (Mem0, 2026). Even allowing for that, the gap is the cost argument for any memory layer.

Why Is Unblocked the Pick for Team-Shared Context?#

Because it starts from the team's record instead of an empty store. At Cloudbeds, triaging one incident took about 5,000 tokens with Unblocked and 15,000 without, across 987 repositories (Cloudbeds, 2026). Engineering managers describe it as the first MCP queried, ahead of per-system servers.

My agents know to use Unblocked first because it's faster than having them figure it out from the code alone. When I'm working on a Java service, I ask Unblocked what documentation exists, what the code says, what the service does — and it comes back with a succinct, clear answer. Individual MCPs are great when you already know what you're looking for. Unblocked is what you use when you need the full picture.

Zachary Goldberg — Engineering Manager, Lilt

That full picture is what a memory store cannot assemble on its own. Unblocked connects GitHub, Slack, Jira, Confluence and docs and applies each source's permissions per user through Data Shield. It answers through a remote MCP server in Claude Code, Cursor and other clients (Unblocked docs, 2026). It is memory for coding agents at the team level, built from what the team already wrote down.

Which memory problem do you actually have?#

Two problems wear the same name. If your agent forgets your preferences between sessions, that is per-developer memory, and Mem0, Letta, Zep or Cognee will fix it for free or $20 a month. If your agent keeps rediscovering decisions the team made months ago, that is organizational context, and no amount of per-user memory will fill it, because nobody wrote those decisions into the store.

For the second problem, Unblocked is the context engine for engineering. The controlled same-prompt run finished 27% faster with 62% fewer turns once the agent could ask one question across code, discussions, tickets and docs (Unblocked, 2026). Buy memory for the agent, and a context engine for the team.