Best AI Agent Memory Tools in 2026

AI agent memory is no longer one product category. Mem0 can remember users inside an app or carry context between coding-agent sessions. Zep keeps the history of facts as they change. Letta gives agents persistent memory they can edit and consolidate in the background. Cognee builds an open knowledge graph from source material, and LightMem uses compression and topic-based summaries to reduce memory-construction costs. Dosu captures and maintains engineering context across the tools where a team works.

Those use cases overlap. Compare the tools by how context enters each system, who corrects it, and which controls apply when an agent retrieves it.

Compare AI agent memory tools by use case

A memory tool can store personal facts, preserve the history of changing information, let an agent curate its own working memory, build a graph from a corpus, cut the cost of remembering a long conversation, or maintain shared engineering context. The storage technology matters less than the work the tool takes off your plate.

The table is a routing guide, not a ranking. A team can use more than one tool when it has more than one memory use case.

Mem0 for portable memory

Mem0 provides an SDK for persistent memory inside an agent app. Its extraction flow turns prior conversations into a smaller set of memories, so later requests don't have to replay the full transcript.

Mem0 also supports coding agents. Its plugins can capture context across Claude Code, Cursor, and Codex sessions, while its MCP server gives other clients a path to the same memory layer. Use Mem0 when the goal is portable memory tied to a user, project, or agent.

Your team still defines the memory behavior. App code or plugin configuration determines what gets captured, when recall runs, and how incorrect memories are corrected.

Zep for facts that change

Zep keeps current facts alongside earlier versions in a temporal knowledge graph. An agent can retrieve what is true now or what was recorded on a specific date, with provenance for each fact.

That model fits systems that must preserve changing state for later review. A support agent might need the customer's current plan, while an incident review might need the plan recorded when an earlier decision was made.

Zep's hosted service runs the managed product. Graphiti is the open source graph framework beneath it, while enterprise customers can ask Zep about bring-your-own-cloud deployment. Zep deprecated the old Community Edition, so it isn't the current self-hosting path.

Letta for agents that manage their own memory

Letta grew out of the MemGPT research at UC Berkeley, and it flips the usual arrangement. Instead of your application holding the transcript and replaying it on every call, Letta holds the agent and its state. Your code sends the agent a message and the agent decides what to remember.

MemFS stores memory as Markdown files in an agent-owned git repository. Files under system/ stay in the active prompt, while other files are read when needed. Conversation-history search is separate from the memory filesystem.

Background subagents can consolidate memory without blocking the main agent. Letta's sleep-time compute paper describes the broader approach of moving memory work between interactions. That work still consumes model resources, so include it when measuring cost.

Letta Code gives agents persistent, git-backed memory through MemFS, with background subagents that review conversations and consolidate lessons. It can initialize memory from a repository and prior Claude Code or Codex sessions. The useful distinction is what each product maintains. Letta develops an agent's memory across its work, while Dosu maintains shared engineering knowledge for retrieval across a team's tools.

Cognee for teams that want to own the graph

Cognee loads source material, extracts entities and relationships, and stores them in a knowledge graph. Teams can optionally supply an ontology to constrain or enrich that extraction.

The project is open source and can run locally, through Cognee's hosted service, or in infrastructure your team controls. Cognee also connects to coding agents through plugins and MCP.

Graph construction grows with the amount of material loaded. Test a representative corpus before settling on the architecture, then compare retrieval quality and operating cost against the simpler memory paths your use case allows.

LightMem for memory on a token budget

Most memory systems spend heavily to remember. LightMem, an open source framework from Zhejiang University's ZJUNLP group, starts from the opposite question: how little can you store and still answer correctly later? The paper was accepted at ICLR 2026, and the design borrows the Atkinson-Shiffrin model of human memory.

Input passes through three stages. Sensory memory compresses raw text and drops low-value tokens before anything is stored. Short-term memory groups related utterances by topic rather than by fixed window and summarizes each group. Long-term memory takes those entries with timestamps right away, then reorganizes, deduplicates, and abstracts them during an offline update the authors call sleep time, so consolidation never sits in the path of a live response.

The authors report that this beats Mem0, LangMem, A-MEM, and MemoryOS on the LongMemEval and LoCoMo benchmarks while using up to 38 times fewer total tokens on LongMemEval. Those are research-benchmark numbers on conversational recall, so run them against your own traces before you plan around them.

LightMem is MIT licensed, runs against cloud APIs or local models through Ollama and vLLM, and ships an MCP server. Its examples include a code assistant with memory. Using it to maintain repository knowledge would require integrating source ingestion and change detection into your application, along with the deployment and access controls your team needs.

Dosu for maintained engineering context

Dosu takes responsibility for engineering knowledge after it is captured. It collects decisions from coding sessions and pull requests, along with generally available Sources such as GitHub, Slack, Notion, and Web.

As the codebase changes, Dosu maintains Documents and agent-facing files such as AGENTS.md. The wider knowledge base remains available over MCP and Dosu's command-line tool, so coding agents can retrieve team context without a separate memory integration in every workflow.

Coding agents follow stale instruction files as readily as current ones. A stale AGENTS.md is worse than no AGENTS.md when it sends the agent through an obsolete workflow.

Branch Notes are readable immediately

write_knowledge saves an append-only Branch Note for one repository and branch. Members of the connected Library can read it immediately through read_knowledge, and the note carries a stable author identifier. Branch Notes don't wait in review_knowledge.

Published knowledge follows a different path. review_knowledge covers pending Document changes and draft messages, which a person can inspect, edit, approve, or decline before publication.

A Branch Note can support later work on the same branch without being presented as reviewed organization knowledge.

Agents can search several Libraries

A Dosu Agent can search more than one Library. It scouts the Libraries connected to that Agent, researches the relevant ones, and returns only context the person asking may access.

Administrators select the connected Libraries. Permissions held by the person asking filter the returned context, which keeps private team knowledge out of answers for people who can't access it. Dosu is SOC 2 Type II compliant. The team can provide its report and security documentation for vendor review.

FAQ

What is the best AI agent memory tool?

There isn't one winner across use cases. Mem0 fits portable memory, Zep fits temporal facts, Letta fits long-lived agents that curate their own memory, Cognee fits teams that want to own the graph, LightMem fits conversational memory on a token budget, and Dosu fits maintained engineering context. A team can use more than one when each tool owns a separate memory use case.

Does Mem0 work with coding agents?

Yes. Mem0 has integrations for Claude Code, Cursor, and Codex. The difference from Dosu is the responsibility each tool takes on. Mem0 provides a portable memory layer, while Dosu captures engineering Sources, maintains shared Documents and agent files, and applies Library access controls.

Which tools consolidate memory in the background?

Letta uses background subagents to consolidate memory, while LightMem batches long-term memory maintenance into an offline update. Dosu maintains team knowledge in the background. With Monitor enabled, it checks ready pull requests and subsequent commits against relevant published Documents and proposes updates when it detects drift. Applying those changes follows the configured review workflow.

Which memory tool has the best benchmarks?

No public benchmark settles the question for every use case. Most memory benchmarks, LongMemEval and LoCoMo included, test whether a system recalls personal details from a long conversation. That doesn't measure whether a coding agent finds the right architecture decision quickly enough to finish a task.

For conversational memory, benchmark against your app's own traces. For coding-agent context, measure task quality, latency, and the cost of repository orientation. We explain the mismatch in more detail in the building blocks of agent memory.

What's the difference between personalization memory and institutional memory?

Personalization memory stores facts about one user, including preferences and product history. Institutional memory stores what an organization knows, including architecture decisions and current operating conventions. A tool can support both, but the capture, correction, and access model may differ for each use case.

Give coding agents shared engineering context

When coding agents repeatedly reconstruct architecture decisions and operating conventions, the missing context belongs in the engineering workflow. Dosu captures that knowledge from the places your team already works, maintains it as the codebase changes, and makes it available to coding agents through MCP and the command-line tool.

Connect your repo to Dosu so the next coding session can start with the context your team has already established.