---
title: "Mem0 vs Letta: Memory Layer or Stateful Agents"
description: "Mem0 vs Letta compared: an extraction memory layer against hosted stateful agents with memory blocks. Pricing, deployment, and the MemGPT rename."
canonical: https://past.dev/blog/mem0-vs-letta
date: 2026-09-03
category: Research
authors: The past.dev team
---
# Mem0 vs Letta: Memory Layer or Stateful Agents

Mem0 vs Letta is a comparison across two layers of the agent stack. Mem0 is a memory layer you attach to an agent you already run: it extracts facts from conversations with an LLM, stores them per user, and returns ranked matches at recall time. Letta runs stateful agents as a service: the agent lives on a Letta server, carries memory blocks inside its own context window, and edits that memory itself. Choose mem0 to add recall to an agent loop you own. Choose Letta when you want the agent, its state, and its memory operated as one hosted object.

## Mem0 vs Letta at a glance

| Dimension | Mem0 | Letta | past.dev |
| --- | --- | --- | --- |
| What is stored | Fact strings an LLM extracts from messages ([docs](https://docs.mem0.ai/core-concepts/memory-operations)) | Agent state: editable in-context memory blocks plus a searchable archival store ([docs](https://docs.letta.com/guides/agents/memory-blocks)) | Raw text with its original timestamp; derived facts with validity windows and supersession links |
| Temporal handling | created_at and updated_at per memory; custom timestamps on add ([docs](https://docs.mem0.ai/platform/features/timestamp)) | No dated fact model in the memory guides; sleep-time agents consolidate in the background ([docs](https://docs.letta.com/guides/agents/architectures/sleeptime)) | Event time from the source timestamp, validity windows, supersession links |
| Entity and identity | Scoped by the user_id, agent_id, or run_id you pass ([docs](https://docs.mem0.ai/core-concepts/memory-operations)); graph memory on Pro and up ([pricing](https://mem0.ai/pricing)) | Memory belongs to an agent; blocks can be shared across agents ([docs](https://docs.letta.com/guides/agents/memory-blocks)) | Entity resolution at ingestion links references across email, transcripts, tickets, chat |
| Retrieval | search() returns ranked memory strings with scores, timestamps, metadata ([docs](https://docs.mem0.ai/platform/quickstart)) | Blocks sit in context with no retrieval step; the agent searches archival memory through tool calls ([docs](https://docs.letta.com/guides/agents/archival-memory)) | Recall returns ranked, dated evidence with sources and one of four status values; audience-scoped |
| Deployment | Apache-2.0 library, self-hosted server, or managed platform ([repo](https://github.com/mem0ai/mem0)) | Managed cloud; Apache-2.0 core ([repo](https://github.com/letta-ai/letta)); Docker self-hosting carries a caveat ([docs](https://docs.letta.com/guides/selfhosting)) | Managed, or self-hosted in your own Postgres with the same API |
| Pricing | Free tier, then $19, $249, custom ([pricing](https://mem0.ai/pricing)) | Free tier, $20 Pro, metered API plan, custom ([pricing](https://docs.letta.com/letta-code/pricing)) | See the [quickstart](/docs/memory-api/quickstart) |

## What each one stores

Mem0's add call runs your messages through an LLM that extracts the facts worth keeping ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). A second step retrieves existing memories in the same scope and has one LLM call decide per fact whether to add, update, or delete a stored record ([memory types](https://docs.mem0.ai/core-concepts/memory-types)). Records are keyed to the identifiers you pass: user_id, agent_id, or run_id. The storage unit is a short fact string.

Letta's storage unit is the agent. Memory blocks are structured sections of the agent's context window that persist across interactions, each with a label, a description, a value, and a character limit ([memory blocks](https://docs.letta.com/guides/agents/memory-blocks)). The agent edits its own blocks through built-in memory tools, and blocks can be shared between agents or marked read only. Overflow knowledge goes to archival memory, a semantically searchable store the agent writes and queries through the archival_memory_insert and archival_memory_search tools ([archival memory](https://docs.letta.com/guides/agents/archival-memory)). Messages, memory edits, reasoning steps, and tool calls all persist server-side in a database and stay retrievable after they leave the context window ([agent overview](https://docs.letta.com/guides/agents/overview)).

Letta also schedules background work. Sleep-time agents review recent conversation, consolidate what mattered, and update memory outside the active loop, triggered after a set number of agent steps or when the context window is compacted ([sleep-time agents](https://docs.letta.com/guides/agents/architectures/sleeptime)). The company frames this as reasoning about context during idle time instead of at inference time ([letta.com](https://www.letta.com/)). Mem0's Pro and Enterprise plans list dream memory consolidation as a platform feature ([pricing](https://mem0.ai/pricing)).

## Temporal handling

Mem0 stamps every memory with created_at and updated_at, and search results carry both ([quickstart](https://docs.mem0.ai/platform/quickstart)). Adds accept a custom timestamp so imported history keeps its original time ([timestamps](https://docs.mem0.ai/platform/features/timestamp)), and an optional expiration date hides a memory from search once passed ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). When a fact changes, the update step rewrites or deletes the record. The documented model has no validity windows and no link from a new value to the value it replaced.

Letta's guides describe agent-curated text in blocks plus archival passages with tags; per-fact dates and validity windows are absent from both ([archival memory](https://docs.letta.com/guides/agents/archival-memory)). If your workload asks what was true in March, test each system against [facts that change over time](/guides/facts-that-change-over-time) before committing.

## Deployment and pricing

Mem0 ships as an Apache-2.0 repository with three documented paths: library in your process, self-hosted server, and managed platform ([repo](https://github.com/mem0ai/mem0)). Platform pricing as of September 2026: a free Hobby tier with 10,000 add and 1,000 retrieval requests per month, Starter at $19 per month, Pro at $249 per month with 500,000 adds, 50,000 retrievals, and graph memory, and custom Enterprise with on-prem deployment ([pricing](https://mem0.ai/pricing)).

Letta's core framework is Apache-2.0 ([repo](https://github.com/letta-ai/letta)). Hosted pricing as of September 2026: a free tier, Pro at $20 per month with up to 20 stateful agents, an API plan at $20 per month plus $0.10 per active agent per month plus metered tool execution, and custom Enterprise ([pricing](https://docs.letta.com/letta-code/pricing)). Self-hosting runs the letta/letta Docker image against Postgres, and the same guide now states the image is "no longer an actively maintained or supported Letta product surface" ([self-hosting](https://docs.letta.com/guides/selfhosting)).

## Letta vs MemGPT

MemGPT began as a research project on giving LLMs self-editing memory tools. On September 23, 2024 the team announced that the open-source project and the company would carry the name Letta, while MemGPT would keep naming the agent design pattern from the original paper ([announcement](https://www.letta.com/blog/memgpt-and-letta/)). The Python package moved to letta as part of the same change, and the repository still records the lineage ([repo](https://github.com/letta-ai/letta)). A search for letta vs memgpt therefore compares a platform to the pattern it grew from: one lineage, one current product.

## Benchmarks the vendors publish

Mem0 self-publishes BEAM results of 64.1% at the 1M scale and 48.6% at 10M, and the same post notes these sit below its LoCoMo and LongMemEval headlines ([mem0 blog](https://mem0.ai/blog/ai-memory-benchmarks-in-2026)). We found no self-published memory benchmark from Letta as of September 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), [methodology](/benchmarks/methodology)). BEAM is the one benchmark both vendors ran; read any other pairing of numbers as separate experiments.

## How to decide

Run the five tests from [choosing a memory system](/guides/choose-memory-system) on a pilot of each.

1. Change a fact, then request the old and the new value with dates. Mem0's update step rewrites records ([memory types](https://docs.mem0.ai/core-concepts/memory-types)); a Letta block holds whatever the agent last wrote into it.
2. Backfill a year of history with original timestamps. Mem0 accepts a custom timestamp on add ([timestamps](https://docs.mem0.ai/platform/features/timestamp)); Letta's memory guides document no equivalent.
3. Send one person under three identifiers. Mem0 separates scopes by identifier; Letta scopes memory to the agent; see [entity resolution](/guides/entity-resolution) for what merging requires.
4. Ask for something the stored data cannot answer, and record whether you receive an invented answer or an explicit gap.
5. Price your own volume: adds and retrievals per month on mem0 ([pricing](https://mem0.ai/pricing)), agents and tool execution on Letta ([pricing](https://docs.letta.com/letta-code/pricing)).

## Where past.dev sits in this comparison

past.dev is a memory API with neither an agent runtime nor a chat loop attached. POST /api/v1/ingest accepts raw text with its original timestamp, and POST /api/v1/recall returns ranked, dated evidence with sources and one of four status values: Supported, Conflicted, NoKnownSupport, or UnknownBecauseDegraded. Facts carry event time from the source timestamp, validity windows, and supersession links, so a changed fact keeps its history. Entity resolution at ingestion links references to one person across email, transcripts, tickets, and chat, and recall is audience-scoped. Deployment is managed or self-hosted in your own Postgres with the same API, data export is supported, and the service holds SOC 2 Type II, ISO 27001, and ISO 27701 certifications. On BEAM's complete splits past.dev reports 91.50% at 100K events, 86.18% at 1M, and 82.61% at 10M, plus 88.7% on LoCoMo with corrected keys ([benchmarks](/benchmarks)). The [quickstart](/docs/memory-api/quickstart) covers ingest and recall.

Both remain the right call in their lanes. Letta fits when the deliverable is a hosted stateful agent that curates its own context, with an Apache-2.0 core for teams that self-host. Mem0 fits per-user conversational personalization behind a small API with a free tier. past.dev fits when memory must answer with dated, sourced evidence and label the cases it cannot support.

For the deeper design comparisons, see [past.dev vs mem0](/vs/mem0), [past.dev vs Letta](/vs/letta), and [past.dev vs Zep](/vs/zep).