The short answer up front: there is no best agent memory tool. These six projects solve genuinely different problems that happen to share the word "memory," and picking between them by star count or a leaderboard screenshot is how teams end up running a temporal knowledge graph to store "user prefers dark mode."
I am Edward, co-founder of Mnemoverse. One of the six tools below is mine, so read this whole piece knowing that. I have tried to handle the bias the way I would want a competitor to: my product gets one section among equals, and I tell you when not to pick it.
This is a map, not a ranking. For each tool: what it actually is, the job it wins, and when you should walk past it.
Mem0: extracted facts, open-source SDK, managed option
What it is: an Apache-2.0 open-source memory SDK with a managed cloud on top. Its core move is fact extraction: it distills conversations into discrete facts it can recall in later sessions.
The job it wins: adding a memory layer to a conversational product quickly, with an exit hatch. Because the SDK is open source, you can start on the managed cloud and move toward self-hosting if compliance or cost pushes you there. If "remember what the user told us and recall it next session" describes your need, this is a short path to it.
When not to pick it: when facts change over time and you need to know what was true when. Plain fact extraction flattens time; that job belongs to Zep. And if what you actually want is a structured graph over your documents rather than conversation-derived facts, look at Cognee.
Zep: facts with expiry dates
What it is: a managed memory service built on the open-source Graphiti temporal knowledge graph. The defining feature is that facts carry validity windows. The graph does not just know the customer's plan is Enterprise; it knows when that became true and when it stopped being true. The free tier is 10,000 credits a month.
The job it wins: any domain where state changes and history matters. Support agents, sales agents, anything touching accounts, subscriptions, or relationships. When an agent has to answer "what changed since last quarter," temporal validity is the actual feature, and Zep is honestly the tool I point people to for it.
When not to pick it: strict local-first or data-residency requirements. Graphiti is open source, but the managed service is what Zep sells. Also skip it if your memory needs are simple preferences and session context; a temporal graph is real machinery, and machinery you don't need is just operational surface.
Letta: the agent owns its memory
What it is: an Apache-2.0 agent framework in the MemGPT lineage. Memory here is not a sidecar service. Agents edit their own memory as a first-class behavior, rewriting what they know instead of delegating that to an external lookup.
The job it wins: building agents from scratch where memory management is part of the agent's cognition. If the MemGPT idea feels philosophically right to you, that the agent itself should curate what it remembers, Letta is the direct descendant of that idea and you should build inside it.
When not to pick it: when you already have an agent stack and just want memory bolted on. Letta is a framework, and adopting a framework to get a memory feature is a large trade that most existing codebases will not want to make.
Cognee: your graph, your infra
What it is: an Apache-2.0 framework that builds a knowledge graph on your own infrastructure through an extract-cognify-load pipeline. You feed it data, it constructs the graph, and everything stays inside your walls.
The job it wins: self-hosted knowledge graphs. If your security team's first question is "where does the data live" and the only acceptable answer is "our VPC," Cognee is designed for exactly you. It wins on data control the same way hosted services win on convenience.
When not to pick it: when nobody on the team wants to own a pipeline. Extract-cognify-load is yours to run, monitor, and evolve. If you want an API that just answers, a hosted service will cost you less in engineer-hours.
LangMem: memory that speaks LangGraph natively
What it is: LangChain's memory SDK, native to LangGraph's Long-term Memory Store, with storage in memory or in Postgres.
The job it wins: memory for teams already building on LangGraph. Native means no adapter layer and no impedance mismatch with your graph state, and Postgres persistence keeps operations boring. If your agents are LangGraph agents, LangMem is the honest default, and I say that as someone selling an alternative.
When not to pick it: outside the LangChain ecosystem. Its advantage is integration depth, and away from LangGraph that advantage evaporates. If your agents live in Claude Code, Cursor, or a custom stack, you take on the concepts without the payoff.
Mnemoverse: one memory across your tools (mine, so calibrate)
I build Mnemoverse. Read this section knowing that.
What it is: a hosted persistent-memory API that agents reach over MCP. One API key or OAuth works across Claude Code, Cursor, VS Code, and ChatGPT (ChatGPT connects through a Custom GPT action). The design bet is cognitive rather than graph-first: memories get an importance score on write; concepts form Hebbian associations tuned by a Rescorla-Wagner update; consolidation merges similar memories into prototypes while Von Restorff protection keeps distinctive ones from being averaged away; and outcome feedback (memory_feedback, a signal from -1 to 1) re-ranks future recall based on whether a memory actually helped. The interface is twelve MCP tools over npx: seven core ones (write, read, feedback, stats, list_recent, delete, delete_domain), four Beta tools for shared rooms, and a vault listing tool; a browser OAuth connector exposes ten of the twelve, holding back the two destructive ones. The MCP server and Python SDK are MIT; the engine is hosted. On the research side, our SLoD paper (arXiv 2603.08965) was accepted at the GRAAI workshop at IEEE WCCI.
The job it wins: continuity across tools. If you code in Cursor at work, run Claude Code at home, ask ChatGPT questions in between, and are tired of every tool relearning your stack and preferences, one shared memory over MCP is the point. The free tier is 1,000 queries a day and 10,000 atoms with no credit card; Pro is $29/month. Sign-up is at console.mnemoverse.com, docs at mnemoverse.com/docs.
When not to pick it: if memory cannot leave your machine, use Basic Memory instead, a local-first AGPL-3.0 MCP server that stores plain Markdown. If you need the engine itself self-hosted, Cognee or self-hosted Mem0 fit; our engine is hosted, and that is a real constraint, not a footnote. If you are deep in LangGraph, LangMem's native integration likely serves you better. And if your core need is temporal validity windows on facts, that is Zep's home turf, not ours.
What's not on this map
Supermemory, if your problem is connectors (Notion, Google Drive, Gmail, S3) and multimodal extraction; note that while there is an open-source repo, the hosted engine is not fully public. Basic Memory, mentioned above, for local-first purists. And Cursor now ships native Rules plus a Memories feature, with availability varying by version, which may be all you need if Cursor is your only tool.
About those benchmark numbers
Every vendor in this space, mine included, has numbers that look impressive. They conflict because everyone benchmarks the task their architecture is shaped for: a temporal-graph system gets evaluated on temporal questions, an extraction system on fact recall, and the datasets, retrieval budgets, and judge models differ from paper to paper. Small harness choices swing results substantially. So treat all of it, including anything I publish, the same way: vendor-reported numbers are contested; run your own evals. Take two candidates from this map, wire each into a week of your actual workload, and measure whether the agent stops asking questions it already asked. Wiring that up costs you a day, and it tells you more than every leaderboard combined.
The map in one paragraph
Facts extracted from conversations with an open-source SDK: Mem0. Facts with expiry dates: Zep. An agent that curates its own context: Letta. A knowledge graph you host yourself: Cognee. Already on LangGraph: LangMem. One memory following you across coding tools: Mnemoverse, and remember who wrote this. None of these is a wrong answer in its own lane. Most of the pain I see comes from picking a tool from someone else's lane because its number was bigger on a benchmark that was never about your problem.
Top comments (0)