There is no evidence-backed universal winner. Mem0, Zep, LangChain’s memory and persistence tools, and Letta retain different kinds of information and fit different architectures. Choose based on what must persist, how facts change, and how much of your stack you want to adopt—not on a single benchmark score.
What does “memory” mean in an agent?
It can mean keeping a conversation available so an agent can resume a thread, extracting durable facts about a user, representing facts and relationships that change over time, or giving an agent editable files that persist across conversations. Those are different jobs. A system that performs well at one is not automatically the right choice for another.
As an Amazon Associate I earn from qualifying purchases.
The key design questions are what the memory unit is, who decides what to retain, how corrections and historical changes are represented, and how the application retrieves information later.
How do the four options differ?
| Option | Memory model | Who manages what is retained? | Typical architectural fit |
|---|---|---|---|
| Mem0 | Extracted and consolidated information from conversations, with a graph-based variant for relationships. Mem0 documentation | A dedicated memory layer handles extraction, consolidation, and retrieval; the application still needs to assess and integrate that behavior. | Add a memory service to an existing application when durable conversational information is the goal. |
| Zep | The default v3 documentation describes temporal Context Graphs and a Context Lake that manages and serves them. Zep v3 overview | The graph model organizes entities, relationships, and facts over time; teams should verify that its update and governance behavior matches their use case. | Evolving relationships, temporal facts, provenance, or governed enterprise context are central. |
| LangChain / LangGraph | Current LangChain docs distinguish short-term, thread-level agent state from long-term, user- or application-level data across threads and sessions. A checkpointer persists thread state. LangChain short-term memory documentation | The developer chooses what to persist, how to scope it, and how cross-thread retrieval works. | Use framework-native state and persistence when building within LangChain or LangGraph and needing thread continuity or custom memory fields. |
| Letta | MemFS is a git-backed memory filesystem that agents can inspect and edit; memory is shared across an agent’s conversations. Optional “dreaming” uses background subagents to review conversations and update memory. Letta memory documentation | Memory belongs to the stateful agent and is managed through its memory workflow. | Adopt Letta’s agent runtime when editable, inspectable, versioned agent memory is a first-class requirement. |
Which one should you choose?
Choose LangGraph state for continuity within a thread
If the immediate requirement is for an agent to resume a conversation, current LangChain short-term memory is thread-scoped state, not automatic cross-session user recall. Its documentation recommends a database-backed checkpointer for production. Cross-thread memory is a separate long-term-memory concern, so decide how user-specific or application-level data will be stored and retrieved.
#1 Best Overall
Evaluate Mem0 for extracted durable information
Mem0 is a candidate when you want a dedicated layer to extract, consolidate, and retrieve salient information from conversations while keeping your existing application. Test which details it retains, how it handles corrections and updates, whether retrieval is relevant, and what hosting and data controls are available for your deployment. The architecture description alone does not establish how it will behave on your workload.
Evaluate Zep for context that changes over time
Zep is a candidate when relationships, changing facts, temporal validity, or governance are important. Its current default documentation is v3. The separate Zep v2 Memory API describes messages submitted by session, a user-level knowledge graph, and retrieval using recent messages and information that may come from any session for that user. Treat those details as v2 behavior; they should not be assumed to describe the current v3 interface.
Rank #2
- Capture Every Milestone from Birth to Age 5: From birth to age 5, this complete baby memory book includes 128 guided pages to help you document every milestone. The simple, organized layout makes it easy for busy parents to fill out this first year memory book without feeling overwhelmed
- 6 Keepsake Envelopes for Precious Mementos: Unlike other books, ours includes 6 built-in envelopes to safely store physical memories. Store hospital bracelets, ultrasound photos, first haircut locks, and special cards all in one organized place
- From Pregnancy to First Year Memories: Capture your journey from the pregnancy story and gender reveal to the baby's arrival and family tree. This baby milestone book includes space for footprints and many other meaningful moments that become cherished memories for a lifetime
- 24 Free Milestone Stickers Included: Celebrate your baby's growth with a set of 24 milestone stickers for monthly photos and special celebrations. This added value makes our baby book a standout choice for tracking your little one's progress through their early years
- Gift-Ready Keepsake Box for Baby Registry: Presented in a premium sliding gift box with gold foil details, this book makes a beautiful baby shower gift or baby registry essential. A thoughtful Mother's Day gift for new moms who value quality and style
Choose Letta when memory belongs to the agent
Letta’s model suits teams that want the agent’s memory to be an inspectable and editable part of a stateful agent, rather than simply adding persistence to an arbitrary existing stack. Its optional dreaming workflow can consolidate lessons from recent conversations, but adopting this model entails adopting Letta’s runtime and memory workflow.
What do the published benchmarks establish?
The published figures are findings from the projects’ own papers, under specific evaluation setups. They do not constitute a neutral, matched comparison of all four current options.
Rank #3
Zep paper results
The Zep paper, dated 2025-01-20, reports 94.8% DMR accuracy with gpt-4-turbo, compared with 93.4% for MemGPT as reported by the MemGPT team. In the same setup, it reports 94.4% for its full-conversation baseline and 78.6% for its conversation-summary baseline. With gpt-4o-mini, it reports 98.2% for Zep and 98.0% for full conversation. The authors describe DMR as limited, including single-turn fact-retrieval questions and ambiguous question wording. Read the Zep paper.
Mem0 paper results
The Mem0 paper, dated 2025-04-28, reports a 26% relative improvement over OpenAI in its LLM-as-a-Judge metric and around a 2% higher overall score for its graph-memory variant than its base configuration on the paper’s LOCOMO evaluation. It also reports 91% lower p95 latency and more than 90% token-cost savings versus its full-context method. These are results from the paper’s own setup, not directly comparable with the Zep paper’s results. Read the Mem0 paper.
A score is meaningful only with its dataset, model, baselines, and task definition. These reported results do not settle which option will remember more accurately for your application.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11How can you compare them on your own workload?
Run the same tasks and constraints through each architecture you are seriously considering. Keep the base model, retrieval budget, prompts, and evaluation criteria consistent; document any integration differences that cannot be held constant.
- Define what success means. Separate thread resumption, recall of durable user facts, multi-hop questions, temporal reasoning, and correction handling instead of using one vague “memory” score.
- Create representative conversation histories. Include facts that change, explicit corrections, stale information, relationships across people or events, and questions whose answers require combining multiple details.
- Test the memory lifecycle. Measure what is ingested, what is retained, what is retrieved, and whether an update or deletion changes later answers as required.
- Apply real operating constraints. Include privacy and deletion requirements, data boundaries, permissions, audit or provenance needs, and the deployment model you can support.
- Measure total operating cost. Track ingestion and retrieval latency, model calls, storage, and ongoing model and service costs under the same traffic assumptions.
- Inspect failures, not just averages. Review missed, stale, contradictory, or irrelevant recalls and decide which failure modes are unacceptable for the application.
This comparison reveals trade-offs a single benchmark cannot: a graph may help with changing relationships but add operational commitments; framework state may offer control but leave cross-session retrieval to the developer; an agent-owned memory workflow may be inspectable but require a runtime change.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
