---
title: "Mem0 vs Zep vs Letta: Building the Memory Shortlist"
description: "Mem0 vs Zep vs Letta for the agent memory shortlist: extraction memory, a temporal knowledge graph, or hosted stateful agents, plus the wider field."
canonical: https://past.dev/blog/mem0-vs-zep-vs-letta
date: 2026-09-03
category: Research
authors: The past.dev team
---
# Mem0 vs Zep vs Letta: Building the Memory Shortlist

Mem0 vs Zep vs Letta is the standard agent memory comparison, and the three products are less interchangeable than the shortlist implies. Mem0 extracts facts from conversations into per-user memory served over an API. Zep builds a temporal knowledge graph where facts carry validity intervals. Letta hosts stateful agents whose memory is part of the agent itself. If you are adding memory to an agent you already have, the working choice is Mem0 or Zep; Letta asks you to adopt its agent as the unit.

### Mem0: extracted user memory

Mem0's `add` call runs conversation messages through an LLM that pulls out facts, decisions, and preferences, stores them additively, and ranks them at search time ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). Scope comes from `user_id`, `agent_id`, and `run_id`. Graph Memory links the entities mentioned across memories through co-occurrence and folds that signal into one relevance score ([graph memory](https://docs.mem0.ai/platform/features/graph-memory)), and a `timestamp` field backdates historical imports ([timestamp](https://docs.mem0.ai/platform/features/timestamp)). It runs as a managed platform or as an open-source library and self-hosted server ([open source](https://docs.mem0.ai/open-source/overview)). The design center is per-user conversational memory behind a small API.

### Zep: a temporal knowledge graph

Zep ingests messages and business data into a Context Graph, which its docs define as a temporal knowledge graph of entities, relationships, and facts for a user or subject ([concepts](https://help.getzep.com/concepts)). Each fact edge carries four timestamps: `created_at`, `valid_at`, `invalid_at`, `expired_at`. New information invalidates superseded facts instead of deleting them, which supports point-in-time queries ([facts](https://help.getzep.com/facts)). Retrieval assembles a context block string from the user's graph ([retrieving context](https://help.getzep.com/retrieving-context)). The underlying engine, Graphiti, is open source ([Graphiti docs](https://help.getzep.com/graphiti/getting-started/welcome)); Zep is the managed product built on it. The design center is tracking how facts change over time. Background on the category sits in our [temporal knowledge graph glossary entry](/glossary/temporal-knowledge-graph).

### Letta: hosted stateful agents

Letta's unit is the agent rather than a memory layer for your agent. Its docs define a stateful agent as a persistent identity with its own memory, model configuration, tools, and message history ([stateful agents](https://docs.letta.com/concepts/stateful-agents)). Memory lives in MemFS, a git-backed filesystem the agent reads and edits with ordinary file tools ([MemFS](https://docs.letta.com/concepts/memfs)), and background dreaming lets subagents consolidate lessons between sessions ([memory](https://docs.letta.com/configuration/memory)). Agents run on Letta Cloud or a self-hosted Letta App Server ([self-hosting](https://docs.letta.com/self-hosting)). Choosing Letta means adopting its agent harness; the memory system comes with it.

## Mem0 vs Zep vs Letta at a glance

past.dev appears as the fourth column because this is the comparison buyers run us against. Its cells come from our published docs only. Vendor cells are linked to the page that proves them, current as of September 2026.

| Dimension | Mem0 | Zep | Letta | past.dev |
|---|---|---|---|---|
| What is stored | LLM-extracted memories, added without overwriting ([operations](https://docs.mem0.ai/core-concepts/memory-operations)) | Entities and fact edges in a temporal graph ([concepts](https://help.getzep.com/concepts)) | Agent state: MemFS files plus message history ([stateful agents](https://docs.letta.com/concepts/stateful-agents)) | Facts derived from raw ingested text, tied to sources |
| Temporal handling | Optional backdated `timestamp` on add ([timestamp](https://docs.mem0.ai/platform/features/timestamp)) | `valid_at` / `invalid_at` on each fact; invalidation on change ([facts](https://help.getzep.com/facts)) | Memory is a git-backed filesystem, so edits carry git history ([MemFS](https://docs.letta.com/concepts/memfs)) | Event time from source timestamps, validity windows, supersession links |
| Entity handling | Co-occurrence linking across memories ([graph memory](https://docs.mem0.ai/platform/features/graph-memory)) | Entities are graph nodes ([concepts](https://help.getzep.com/concepts)) | Left to how the agent organizes its files ([MemFS](https://docs.letta.com/concepts/memfs)) | Resolution at ingestion across email, transcripts, tickets, chat |
| Retrieval returns | Ranked memories with one combined score ([graph memory](https://docs.mem0.ai/platform/features/graph-memory)) | An assembled context block string ([retrieving context](https://help.getzep.com/retrieving-context)) | The agent consults memory itself; `system/` files stay in its prompt ([MemFS](https://docs.letta.com/concepts/memfs)) | Ranked, dated evidence with sources and a status: Supported, Conflicted, NoKnownSupport, UnknownBecauseDegraded |
| Deployment | Managed, library, or self-hosted server ([open source](https://docs.mem0.ai/open-source/overview)) | Managed cloud, BYOK, or BYOC ([pricing](https://www.getzep.com/pricing)); Graphiti engine open source ([docs](https://help.getzep.com/graphiti/getting-started/welcome)) | Letta Cloud or self-hosted App Server ([self-hosting](https://docs.letta.com/self-hosting)) | Managed, or self-hosted in your own Postgres: docker compose, pinned images, same API |
| Pricing model | Metered requests: free tier, then $19 to $249/mo tiers ([pricing](https://mem0.ai/pricing)) | Credits per 350 ingested bytes; free 10,000 credits/mo, Flex $125/mo ([pricing](https://www.getzep.com/pricing)) | Free and $20/mo plans; API plan $20/mo plus $0.10 per active agent plus usage ([pricing](https://docs.letta.com/letta-code/pricing)) | Managed or self-hosted; start at the [quickstart](/docs/memory-api/quickstart) |

## Mem0 vs Zep vs Letta vs Cognee: the rest of the field

Shortlists usually carry more names. One sentence on each, with its official source.

[Cognee](https://docs.cognee.ai/) is an open-source framework that processes raw documents into searchable memory backed by a knowledge graph, vector embeddings, and a relational provenance store. [Supermemory](https://supermemory.ai/docs/) describes itself as context infrastructure for AI agents: a hosted API with SDKs, MCP integrations, and a self-hosting path. [LangMem](https://langchain-ai.github.io/langmem/) is LangChain's memory library, with agent memory tools and a background memory manager that persist through LangGraph's store. [Honcho](https://honcho.dev/docs/), from Plastic Labs, is an open-source memory library and managed service that models workspaces, peers, sessions, and messages and builds representations you query for context. [Hyperspell](https://hyperspell.com/) connects sources such as Slack, Gmail, and Google Drive through prebuilt connectors and serves the synthesized context to agents over an API. Longer treatments: [Cognee comparison](/compare/cognee), [past.dev vs Supermemory](/vs/supermemory), [LangMem comparison](/compare/langmem).

## Self-published numbers

Mem0 and past.dev both publish results on BEAM, the same long-horizon benchmark, so those figures can appear together. Mem0 reports 64.1% at 1M events and 48.6% at 10M ([their 2026 benchmark post](https://mem0.ai/blog/ai-memory-benchmarks-in-2026)). On BEAM's complete splits, past.dev reports 91.50% at 100K events, 86.18% at 1M, and 82.61% at 10M ([benchmarks](/benchmarks), setup in the [methodology](/benchmarks/methodology)). Vendor results on other benchmarks are separate experiments and do not combine into one ranking, so none are listed here. Every number above is vendor-reported.

## How to decide: five tests

Run these before committing; the full walkthrough is in [choosing a memory system](/guides/choose-memory-system).

1. Change a fact, then ask for the old and new values with dates. Zep documents fact invalidation for this case ([facts](https://help.getzep.com/facts)); verify the context block surfaces both values.
2. Backfill a year of history with original timestamps, then ask what was known at a past date. Mem0 documents the write side ([timestamp](https://docs.mem0.ai/platform/features/timestamp)); test retrieval against it.
3. Give one person three identifiers (email address, chat handle, ticket ID) and check whether facts land on one entity or three.
4. Ask something the stored data cannot answer, and watch whether the system says so or improvises.
5. Price your actual volume: Mem0 meters add and retrieval requests ([pricing](https://mem0.ai/pricing)), Zep meters ingested bytes as credits ([pricing](https://www.getzep.com/pricing)), Letta meters active agents plus model usage ([pricing](https://docs.letta.com/letta-code/pricing)).

## Where past.dev sits in this comparison

past.dev is a memory API built for facts that change. `POST /api/v1/ingest` takes raw text with its original timestamp; `GET /api/v1/ingest/{id}` reports `settled: true` when processing completes; `DELETE /api/v1/ingest/{id}` forgets a source and erases what only it supported. `POST /api/v1/recall` returns ranked, dated evidence with sources, and every answer carries one of four statuses: Supported, Conflicted, NoKnownSupport, or UnknownBecauseDegraded. Facts keep event time, validity windows, and supersession links; entity resolution at ingestion connects references across email, transcripts, tickets, and chat; recall is audience-scoped. Deployment is managed or self-hosted in your own Postgres with the same API, data export is supported, and SOC 2 Type II, ISO 27001, and ISO 27701 certifications are held. Published results, including LoCoMo at 88.7% on corrected keys, are at [/benchmarks](/benchmarks).

Each rival earns its place on the right problem. Zep's Graphiti fits a team that wants a self-hosted open-source graph engine. Mem0 fits per-user conversational personalization as a service or a library. Letta fits when you want the whole agent hosted and managed. When answers must carry dates, sources, and an explicit status under missing evidence, start at the [quickstart](/docs/memory-api/quickstart).

For the pairwise design comparisons, see [past.dev vs Mem0](/vs/mem0), [past.dev vs Zep](/vs/zep), [past.dev vs Letta](/vs/letta), and the [Mem0](/mem0-alternative) and [Zep](/zep-alternative) alternative pages.