← Blog

Letta Alternatives: 7 Options for Stateful AI Agents

November 16, 2026

AI Agents & ToolsAI CodingTool Comparisons

The best Letta alternative depends on one question: do you want a new agent runtime, or just memory for the agent you already have? If you want a hosted runtime with memory built in, look at Claude Managed Agents or the OpenAI Agents SDK. If you build in Python graphs, LangGraph with LangMem is the closest open-source match. If you only need memory, keep your current agent and add Mem0, Zep (or its open-source engine Graphiti), Cognee, or LlamaIndex's memory blocks.

Letta, formerly MemGPT, is not a memory library. It's a full harness: the agent, its tools, its schedules and its memory all live inside Letta. That's its strength, and it's also why people look elsewhere. Swapping Letta out usually means choosing a different place for the agent to live, not just a different database.

This guide explains what Letta is in late 2026, compares seven alternatives, and ends with when Letta is still the right call.

Quick Comparison

OptionTypeWhere memory livesLicenceHosted option
Letta (baseline)Full agent harnessMemory blocks and a git-tracked memory filesystemApache-2.0Letta Cloud
Claude Managed AgentsHosted agent harnessMemory stores (beta)Proprietary APIAnthropic, or self-hosted
OpenAI Agents SDKAgent frameworkSessions for history, memory files for lessonsMITYou run it
LangGraph + LangMemGraph framework plus memory toolsLangGraph's long-term storeMITLangGraph Platform
Mem0Memory layerExtracted facts, retrieved on demandApache-2.0Mem0 platform
Zep / GraphitiContext layer / temporal graphTemporal context graphsGraphiti: Apache-2.0Zep Cloud
CogneeMemory platformKnowledge graph built from your dataApache-2.0Cognee cloud
LlamaIndex MemoryMemory componentShort-term buffer plus long-term blocksMITYou run it

What Letta Is in Late 2026

If you last looked at Letta in 2024 or 2025, a lot has moved.

Letta's homepage now describes the company as an AI research lab building "machines that learn," and its main product is Letta Code, a stateful agent harness. The original letta-ai/letta repository says the current source lives in Letta Code, and that the retired Letta V1 API server sits on an archive branch. Old tags and releases stay up "for reproducibility," but active projects are pointed at the new code.

Here is what the current product gives you, per its README and Letta's docs:

  • Self-editing memory. Agents rewrite their own context over time, including their system prompt through memory blocks, and can learn new skills.
  • MemFS. All context, memory blocks included, is tracked in git. You can sync it to your own GitHub repository.
  • Many front doors. A CLI, a web app at chat.letta.com, and messaging channels such as Slack, Telegram and Discord.
  • Always-on behaviour. Schedules, crons and background "dreaming" for reflection.
  • Ways to embed or host it. The Letta Agent SDK wraps the harness for your own TypeScript apps, and the App Server runs agents on infrastructure you control.

Letta Code is Apache-2.0. Letta's pricing page has a free plan where you bring your own API keys or a coding plan, with a cap on how many stateful agents you keep. Paid plans add hosted model credits and higher limits.

Why teams look for a Letta alternative

  • You built on the old V1 server. The API you integrated with is retired. Moving to Letta Code is a migration either way, so it's a natural point to compare.
  • You want memory, not a runtime. If you already have an agent framework, adopting Letta's harness is a bigger change than adding a memory API.
  • Your stack is Python. The Agent SDK targets TypeScript apps. Python-first teams often prefer LangGraph or the OpenAI Agents SDK.
  • The product is shifting toward Letta's own apps. Coding agents and personal assistants lead the docs now. If you need a plain backend service for your product, check that the SDK covers your case.

For background on how agent memory works in general, see our guide to AI agent memory.

Full Agent Runtimes With Memory Built In

These replace Letta as the place your agent runs. Pick one of these if you like Letta's "agent owns its memory" model.

Claude Managed Agents: Anthropic's hosted harness

Best for: teams already on Claude that want long-running agents without running the loop themselves.

Anthropic's docs describe Claude Managed Agents as a "pre-built, configurable agent harness that runs in managed infrastructure," aimed at long-running and asynchronous work. Each session starts fresh by default. Memory stores carry information across sessions: user preferences, project conventions, prior mistakes and domain context. A self-hosted version of Managed Agents exists too.

If you'd rather keep your own loop, the Claude memory tool is the lighter path. Claude asks to create, read, update or delete files in a memory directory, and your application carries out those operations. You choose where the files live.

Where it beats Letta: no harness to run, and memory sits next to the model you're already paying for.

Where it's weaker: both features are in beta, and you're tied to Claude models. Letta lets you switch between many providers mid-conversation.

OpenAI Agents SDK: sessions plus memory files

Best for: Python teams that want a lightweight framework and their choice of storage.

The OpenAI Agents SDK splits memory into two parts. Sessions keep conversation history across runs, with built-in backends for SQLite, Redis, SQLAlchemy, MongoDB, Dapr, encrypted storage and OpenAI's Conversations API. Separately, sandbox agent memory distills lessons from earlier runs into files under a memories/ folder, so the next run needs less exploration.

Where it beats Letta: it's a library, not a platform. You own the process, the storage and the deployment.

Where it's weaker: memory files persist only if you keep or restore the sandbox workspace, and there's no built-in self-editing of the system prompt the way Letta does it.

LangGraph with LangMem: open-source and Python-native

Best for: teams that model agents as graphs and want memory in the same stack.

LangMem is an MIT-licensed library from the LangChain team. It gives agents tools to record and search memories during a conversation, a background manager that extracts and consolidates knowledge, and prompt refinement so behaviour improves over time. It integrates natively with LangGraph's long-term memory store, and its core API works with other storage too.

Where it beats Letta: the whole stack is open source and Python, and you control the graph step by step. If you're weighing the frameworks themselves, see LangGraph vs LangChain.

Where it's weaker: you assemble the pieces. Letta's channels, schedules and git-backed memory don't come in the box.

Memory Layers That Plug Into Any Agent

These don't replace your runtime. They give the agent you already have a memory. If you're comparing memory layers in depth, our Mem0 alternatives guide goes further on this group.

Mem0: the drop-in memory API

Best for: teams that want to add user memory to an existing app with a few calls.

Mem0 calls itself drop-in memory infrastructure for agents and apps. You send it conversations, it extracts facts, and it returns the relevant ones later. There's a managed platform and an Apache-2.0 open-source library, plus integrations for SDKs and agent harnesses.

Where it beats Letta: much smaller change to your code. Your agent keeps its framework and calls Mem0 for memory.

Where it's weaker: the agent doesn't manage its own identity or prompt. Mem0 stores and retrieves facts; deciding what to do with them is up to you.

Zep and Graphiti: memory that tracks change over time

Best for: enterprise agents whose facts change, and who need to know what was true when.

Zep now pitches itself as an enterprise context layer. It combines business data, documents and conversations into governed context graphs, with access policies and logged requests. Agent memory is one of its use cases. Self-serve plans are credit-based.

Its open-source engine, Graphiti, is Apache-2.0. It builds temporal context graphs that record how facts change and keep provenance back to source data, with retrieval that mixes semantic search, keyword search and graph traversal.

Where it beats Letta: time-aware facts and enterprise governance, neither of which is Letta's focus.

Where it's weaker: it's a context service, not an agent. Graphiti also needs a graph database you operate.

Cognee: open-source memory built from your data

Best for: teams that want company knowledge, not only chat history, in agent memory.

Cognee is an Apache-2.0 memory platform for agents. It connects sources like Slack, GitHub and Linear into one knowledge graph, and it can generate ontologies so agents follow your domain's rules. Its site lists support for Claude Code, Codex and MCP.

Where it beats Letta: memory comes from your organisation's data, not only from what the agent saw in conversation.

Where it's weaker: more setup to ingest and model your sources, and no agent runtime of its own.

LlamaIndex Memory: memory blocks for RAG-heavy agents

Best for: teams already using LlamaIndex for retrieval.

LlamaIndex's Memory class combines a short-term chat buffer with long-term memory blocks. The built-in blocks are static information, facts extracted from chat history, and a vector store of past messages. Each block gets a priority, and the memory respects a token limit you set. The framework is MIT-licensed.

Where it beats Letta: the idea of memory blocks will feel familiar, and it sits next to your indexing and retrieval code.

Where it's weaker: it's a component. Persistence, multi-agent sharing and scheduling are yours to build.

How to Choose a Letta Alternative

If you need...Look atWhy
A hosted agent that remembers, on ClaudeClaude Managed AgentsMemory stores, no loop to run
A Python library with pluggable storageOpenAI Agents SDKSessions and memory files
Open-source, graph-shaped agentsLangGraph + LangMemMemory tools in the same stack
Memory for an agent you already haveMem0Smallest code change
Facts that change over timeZep or GraphitiTemporal context graphs
Memory built from company dataCogneeIngests Slack, GitHub, Linear
Memory next to your RAG pipelineLlamaIndex MemoryShort-term plus long-term blocks

Two tests settle most decisions:

  1. Does the agent need to change itself? If you want it rewriting its own prompt and skills, stay with a runtime: Letta, Managed Agents or LangGraph with LangMem's prompt refinement. If it just needs to recall facts, a memory layer is enough.
  2. Where must the data live? Letta, LangMem, Mem0's library, Graphiti, Cognee and LlamaIndex can all run on your machines. Managed Agents and the hosted tiers can't, unless you use their self-hosted options.

If you're migrating off the V1 server, run one real agent on two options for a week. Compare what it remembers, what it forgets, and how much glue code you wrote.

When Letta Is Still the Right Call

Stay with Letta if:

  • You want agents that are more like people than tools. Long-lived identity, self-editing memory and skill learning are what Letta is built around.
  • You want git-versioned memory. MemFS lets you diff, review and roll back what an agent learned.
  • You want one agent across many places. The same agent can work from the CLI, the browser and chat apps, and across several machines.
  • You switch models often. Letta supports a long list of API providers, coding plans and local endpoints.

Where Taku Fits

All of these tools help you build an agent that remembers. Many people don't want to build one at all; they want to use an AI app someone has already finished. Taku isn't an agent framework and doesn't replace Letta or anything on this list. That's where Taku comes in.

Taku Apps and Sites, built by the best AI minds. Find one, run it, and keep it in your Mac Dock. Taku is in Beta, and the Mac app is available now.

FAQ

Is Letta the same as MemGPT?

Yes. Letta was founded by the creators of MemGPT, the 2023 research project on virtual context management, and the open-source project was renamed. Today's main product, Letta Code, is a newer harness built on that research.

What happened to the Letta V1 API server?

Letta's README says the V1 API server is retired and kept on the repository's archive branch. Existing tags and releases stay available, but active projects should use Letta Code, the Agent SDK or the App Server.

Letta vs Mem0: which should I use?

Use Letta if you want the agent to live inside a harness that manages its own memory. Use Mem0 if you already have an agent and just want it to remember users and tasks. Mem0 is a smaller change; Letta gives the agent more control over itself.

Letta vs Zep: what's the difference?

Letta is an agent harness. Zep is a context layer that agents call to get governed, time-aware facts about users, customers and company data. Some teams could use both: an agent runtime for behaviour and Zep for enterprise context.

Is there an open-source alternative to Letta?

Yes. LangGraph with LangMem is the closest open-source runtime option. For memory alone, Mem0's library, Graphiti, Cognee and LlamaIndex are all open source. Letta Code itself is also Apache-2.0.