Letta

Letta is an open-source platform for building stateful AI agents, meaning agents that remember, learn, and adapt across sessions rather than resetting to zero with every conversation. It was created by Charles Packer and Sarah Wooders, Berkeley PhD researchers from the Sky Computing Lab, and grew out of the MemGPT research project first published in October 2023. The company, Letta AI, Inc., emerged from stealth on September 23, 2024 with a $10 million seed round led by Felicis, at a reported $70 million valuation. Notable angels include Jeff Dean (Chief Scientist at Google DeepMind), Clem Delangue (CEO of HuggingFace), and Robert Nishihara (co-founder of Anyscale). The Apache 2.0 repository has accumulated over 22,400 GitHub stars and reached its v0.6.7 release in March 2026.

The framework's core innovation is an OS-inspired three-tier memory model: core memory (always active in the LLM context window, like RAM), archival memory (a searchable vector store for long-term cold storage, like disk), and recall memory (indexed conversation history). Agents do not passively receive injected context; they call memory management functions during their reasoning loops to move information between tiers. This self-directed memory editing is the defining architectural feature that separates Letta from bolt-on memory layers like LangChain memory modules. The flagship product, Letta Code, applies this architecture to coding agents, achieving the number-one ranking among model-agnostic open source agents on Terminal-Bench. The platform supports Python and TypeScript SDKs, a REST API, a web-based Agent Development Environment for debugging, and both cloud-hosted and fully self-hosted deployments.

What Letta actually does in April 2026

Letta ships two distinct products built on the same underlying framework. The first is the Letta API, a server-side platform for deploying and managing persistent agents at scale. Developers build agents programmatically, attach memory blocks, connect tools, and query agents via REST. Agents maintain separate core memory blocks for different knowledge domains, each block editable by the agent during operation. Archival memory stores a searchable history accessible via semantic queries, so an agent deployed for months can retrieve facts from its earliest interactions without those facts permanently occupying the context window.

The second product is Letta Code, the memory-first coding agent shipped as a desktop app, CLI tool, and SDK. It runs locally using your own API keys or existing model subscriptions. Letta Code tracks project conventions, architectural decisions, and past debugging sessions across every conversation, building a project-specific memory that evolves with the codebase. A Conversations API added in January 2026 enables shared agent memory across parallel experiences with multiple users, allowing multiple people to interact with the same agent while it maintains coherent cross-user context. In March 2026, Remote Environments enabled cross-device agent access via the letta server command.

The MemGPT paper (arXiv:2310.08560, October 2023) formally established the LLM-as-Operating-System paradigm. It drew 154+ academic citations within two years and introduced the architectural vocabulary the field now uses: context window as RAM, external storage as disk, and interrupt-driven memory management. The paper's impact moved from academic to commercial directly through the Letta rebrand and company formation.

"The stateless vs stateful distinction you highlighted is the critical decision point. Pick the paradigm that matches your use case from the start." - Ezra, Letta support lead, Letta Developer Community forum, 2025

Where Letta sits versus LangGraph and Mem0

LangGraph and Letta solve adjacent but distinct problems. LangGraph models agent workflows as directed graphs: nodes are agents or functions, edges define conditional routing, and a shared state object flows through the execution sequence. Its standout persistence feature is checkpointing on every state transition, which enables time-travel debugging, human-in-the-loop approvals, and mid-execution failure recovery. LangGraph's memory is state-based, meaning it travels with execution; Letta's memory is storage-based, meaning it exists independently of any single execution cycle. LangGraph is the better fit when your problem is a complex conditional workflow with many branches and explicit approval gates. Letta is the better fit when the problem is a long-running agent that needs to accumulate and evolve knowledge over months of operation. The two frameworks are not strictly competitive; teams running LangGraph often integrate Letta-style memory primitives separately, though doing so requires custom bridging code. LangChain's LangMem SDK (released early 2025) adds episodic, semantic, and procedural memory types to LangGraph, but these are modular additions rather than native to the execution loop, and they do not provide the agent self-editing mechanic that is Letta's core contribution.

Mem0 is the most direct competitor on the memory-specific axis. It operates as a standalone memory service with a two-call API: add() stores conversation or document input, search() retrieves by semantic similarity. The critical architectural difference is agency: Mem0 passively extracts memories from what you feed it; Letta agents actively decide what to remember by calling memory functions themselves during reasoning. This means Mem0's memory quality is bounded by its extraction pipeline, while Letta's is bounded by the agent's reasoning quality (and model capability). Mem0 takes roughly ten minutes to integrate into an existing agent loop; Letta requires adopting the full platform. On the LongMemEval benchmark, independent testing places Letta at approximately 83.2% accuracy versus Mem0's 49.0%, a substantial gap on long-horizon retrieval tasks. Mem0's switching cost is low, replacing a few API calls; Letta's switching cost is high, realistically two to six weeks to rebuild the agent loop, tool execution, and state management for a mid-complexity project. For teams building CrewAI or other framework-native workflows that just need "remember the user," Mem0's narrow API surface is the practical choice. For teams whose core product is the agent's evolving memory and behavior, Letta's architecture is the only production option at this level of depth.

"Letta is not yet production-ready for mission-critical applications. Effectiveness depends heavily on the underlying LLM capabilities." - Calvin Ku, Medium (Asymptotic Spaghetti Integration), 2025

What the agent loop reality looks like

Deploying a Letta agent follows a consistent workflow. You instantiate an agent with an initial persona and human-memory block. As the agent interacts with users, it calls memory tools to update its core memory in real time, move long-content to archival storage, and retrieve relevant past context via semantic search. This happens within every conversation turn, not as a background job. The agent is the author of its own memory, not a passive beneficiary of an external extraction process. This is both the architecture's strength and its cost structure: every memory operation consumes LLM tokens, breaking prompt caching and adding latency.

The Agent Development Environment provides a visual debugger showing memory state, tool calls, and reasoning traces in real time, which meaningfully reduces debugging time compared to raw API introspection. The platform also supports multi-agent configurations where multiple specialized agents share a common memory block, useful for research assistants, enterprise knowledge management, or customer support systems that need cross-session continuity.

Letta Code, the coding variant, adds project-specific memory management. Commands like /init and /remember let developers explicitly teach the agent facts about the codebase. Between sessions, memory compaction runs background consolidation to keep the context window from bloating. The platform ranks first on Terminal-Bench among model-agnostic open-source coding agents, though it competes in a narrower category than LlamaIndex data pipelines or DSPy program optimization, both of which solve different layers of the agent stack.

Who Letta is built for

Letta is designed for ML engineers and backend developers building agents where persistent identity and evolving memory are product-level features, not implementation details. The typical user is building a research assistant that needs to remember six months of paper summaries, a customer support agent that should recall every past interaction with each user, or a coding assistant that adapts to a team's specific conventions and bug history. These are use cases where the memory is the product, not incidental session state. The framework rewards teams willing to commit to its architecture: Letta handles the agent loop, tool execution, memory routing, and persistence layer in exchange for owning those components end to end.

Researchers and academics exploring agent cognition will find the architecture particularly legible. The three-tier model directly maps to classical OS memory management, the ADE provides visible reasoning traces, and the Apache 2.0 license means full access to modify and study the internals. Codecademy's "Intro to AI Agents with Letta" course suggests growing adoption in education contexts. Teams already using Pydantic AI or other typed Python frameworks will appreciate Letta's Python-first SDK design, though TypeScript support exists for web-native teams.

What Letta is not

Letta is not a plug-and-play memory module. You cannot add Letta's memory to an existing LangGraph or AutoGen workflow in an afternoon; you adopt the platform or you do not. Teams with established agent architectures face two to six weeks of refactoring to migrate, and that cost is real. Do not start with Letta if you are uncertain whether your use case requires long-horizon memory continuity; Mem0's narrower API is the lower-risk starting point for that evaluation.

Letta is not mature for non-OpenAI model providers. GitHub issues and forum threads document 90%+ error rates when using local models via Ollama or LiteLLM. The configure tooling suggests a narrow default set of model wrappers with no obvious path for newer models. This has improved across recent releases but remains unresolved for teams committed to fully local or open-weight deployments. If your stack is Ollama-first, expect friction and debugging time that the documentation does not adequately prepare you for.

Letta is not a complete data pipeline or RAG framework. For document ingestion, chunking, embedding, and retrieval at scale, LlamaIndex remains the more complete solution. Letta's archival memory covers the retrieval layer but not the pre-processing pipeline. Teams building document-heavy applications typically use Letta for agent memory and a dedicated retrieval library for document search.