Letta Alternatives: 7 Agent Memory Options Compared

Letta alternatives are memory systems you can use instead of Letta (formerly MemGPT) to give agents long-term memory. The main ones are Mem0, Zep, Graphiti, Cognee, LangMem, Hindsight and Supermemory. Most teams switch because they want a memory layer for their own agent, while Letta is now a full agent runtime that owns the loop.

This page covers what Letta does today, the common reasons to look elsewhere, a comparison table, a short section per option, and how to choose. For a deeper look at Letta itself, see the Letta guide.

What is Letta, and what do Letta alternatives replace?

Letta is an open-source platform for stateful agents that edit their own memory, built by the team behind the MemGPT paper. Its current product, the Letta Harness (formerly Letta Code), runs the agent, stores its memory as files in a git repository, and adds background “dreaming” that reviews conversations and updates memory. It’s available as a CLI, desktop app, web app and SDK.

Some history helps here. The MemGPT paper (Packer et al., 2023) proposed “virtual context management”: treat the LLM’s context window like an operating system treats RAM, and page information in and out of slower storage. Letta grew out of that work.

The product has changed a lot since. According to the letta-ai/letta README, the old Letta V1 API server is retired and lives on an archive branch; active development is in letta-ai/letta-code. Per the Letta docs:

• Memory blocks and MemFS. An agent’s memory is a set of Markdown files in a git repo the agent owns. Files under system/ go into the system prompt every turn; the rest stay out of context until the agent reads them.
• Dreaming. Background subagents review recent conversations and consolidate lessons into memory. You configure when it triggers (every N steps, on context compaction, or off).
• Agent SDK. The Letta Agent SDK targets JavaScript and TypeScript projects. A Python client, letta-client, still exists for the Letta API.
• Self-hosting. The CLI and App Server can run fully locally with no Letta account. Self-hosted agents aren’t reachable through chat.letta.com and aren’t backed up automatically.
• Pricing. Free personal plan (limited agents), Pro at $20/month for up to 20 stateful agents, and an API plan at $20/month plus $0.10 per active agent per month and $0.00015 per second of tool execution, with LLM usage billed on top.

Why teams look for Letta alternatives

These are the common reasons, based on how Letta works now:

1. You want memory, not a runtime. Letta runs the agent loop, tools and context. If your agent already lives in LangGraph, CrewAI, the OpenAI Agents SDK or plain Python, a memory layer you call is a smaller change.
2. Your stack is Python. The Python V1 server is retired. The harness ships on npm (Node.js 22.19+) and the Agent SDK is JS/TS. Python teams that self-hosted the old server face a migration either way.
3. You want memory written by a pipeline, not by the agent. In Letta, the agent decides what to write to its memory files. Some teams prefer automatic extraction on every message, with fixed rules for conflicts and updates.
4. You need structured recall. Letta memory is text files plus message search. Systems built on knowledge graphs or time-aware facts handle questions like “what changed since March?” more directly.
5. Per-agent pricing. The API plan charges per active agent per month. If you run one agent per end user, a usage-based memory service may cost less. Check the numbers for your own workload.

None of these make Letta a bad choice. If you want agents that persist, learn across machines and manage their own context, it’s built for exactly that.

Letta alternatives compared

Licenses are from each project’s GitHub repo as of October 2026.

Only two of these publish scores on the long-history benchmarks, both from Mem0’s comparison page (vendor-run):

Each alternative in short

Hindsight

Hindsight is an open-source memory server (MIT) and the closest match to what Letta does with memory, without taking over your agent loop. It has three operations: retain stores content and extracts facts, entities and time data; recall runs semantic, BM25 keyword, graph and temporal search in parallel and merges the results; reflect answers a question by reasoning over a memory bank. Like Letta’s dreaming, it consolidates in the background: related facts merge into observations that keep their evidence, and mental models hold standing answers that stay current.

Why it ranks first here:

• Long histories. On BEAM it scores 73.9 at 1M tokens and 64.1 at 10M, against 64.1 and 48.6 for Mem0, per Mem0’s own comparison page. On LongMemEval it’s 94.6 to Mem0’s 94.4. All vendor-run.
• Everything is open source. Graph and temporal recall, consolidation, reflect and mental models are in the MIT server. Mem0 keeps graph memory and temporal reasoning on its hosted Platform (graph memory only on custom paid plans).
• Python-first teams. Python, TypeScript and Go clients, a REST API and an MCP endpoint per bank, a direct answer to reason 2 above.
• Coding agents and frameworks. Plugins for Claude Code, Codex, Cursor and Copilot, plus LangGraph, CrewAI, Pydantic AI, the OpenAI Agents SDK and n8n among 60+ integrations.

It runs on Postgres with pgvector (or an embedded Postgres) via Docker, pip or Helm, with 25+ LLM providers including local ones. The limits: writes cost more than Mem0’s, since retain and consolidation both call an LLM, and by Mem0’s measurement it returns about 4x more context per retrieval, so set max_tokens. The design is described in a December 2025 paper; code and docs are on GitHub.

Mem0

Mem0 is a memory layer you add to an existing agent. It comes as a library (pip install mem0ai), a self-hosted server via Docker Compose, or the managed Mem0 Platform. Its April 2026 algorithm extracts facts in one LLM call, only adds memories (no overwrites), links entities across memories, and scores semantic, BM25 keyword and entity matches together. Mem0’s README notes its published benchmark scores come from the managed platform, which has optimizations the open-source SDK doesn’t. Compare it directly in Mem0 vs Letta.

Zep and Graphiti

Zep is a managed service that builds a temporal knowledge graph per user and returns a prompt-ready Context Block. Facts have validity windows, so Zep can tell current facts from outdated ones. Its open-source engine, Graphiti, does the graph part on your own Neo4j, FalkorDB or Neptune. Zep’s old Community Edition is deprecated. See what Zep memory is for pricing and setup.

Cognee

Cognee turns documents, conversations and other data into a knowledge graph with embeddings, through cognee.remember() and cognee.recall(). It can run locally without an LLM key, using a small local extraction model. It ships an MCP server and a managed Cognee Cloud. It suits teams whose “memory” is mostly a domain knowledge base. The team’s research is in a 2025 arXiv paper on optimizing the interface between knowledge graphs and LLMs.

LangMem

LangMem from LangChain gives agents tools to save and search memories during a conversation, plus a background manager that extracts and consolidates memories after it. It stores data in LangGraph’s long-term memory store, so it’s the natural pick if you already run LangGraph. It can also refine an agent’s prompt over time, based on its interactions.

Supermemory

Supermemory is a memory and context API that extracts facts from conversations, keeps user profiles, handles updates and contradictions, and combines memory with document RAG and connectors (Google Drive, Notion, Gmail and others). It’s available as a hosted API, with a local server for self-hosting and plugins for coding agents. Its self-hosting docs explain what the local version includes compared with Enterprise.

How to choose a Letta alternative

Start from what you’re replacing:

• You want Letta’s model, without Letta running your agent: Hindsight (background consolidation, mental models and reflect in a memory server), or LangMem (agent-managed memory tools inside LangGraph).
• Your agents run for months and histories get long: Hindsight, which leads on BEAM 1M and 10M.
• You want memory for Claude Code, Codex or Cursor without switching harness: Hindsight’s plugins.
• You want simple user memory with minimal setup, or the smallest prompt per retrieval: Mem0 or Supermemory.
• Facts change and history matters: Zep (managed) or Graphiti (self-hosted).
• Your memory is mostly documents and domain knowledge: Cognee.
• You need everything self-hosted and open source: Mem0, Graphiti, Cognee, LangMem and Hindsight all run on your infrastructure; Hindsight is the one with no paid-only memory features. See this comparison of open-source memory systems for more detail.

Then test with your own data. Vendor benchmark scores are mostly self-reported and use different setups, so a small evaluation on real conversations tells you more. For a broader map of memory types and tools, see AI agent memory explained. Vectorize also maintains a separate Letta alternatives comparison.