Key takeaways
- Born from the influential MemGPT research paper at UC Berkeley, now a YC-backed startup with $10M seed funding
- Tiered memory architecture (core, archival, recall) gives agents persistent state across conversations
- Model-agnostic design supports OpenAI, Anthropic, Mistral, and local models — no vendor lock-in
- Letta Code is a memory-first coding agent ranked #1 model-agnostic agent on Terminal-Bench
FAQ
What is Letta?
Letta is a platform for building stateful AI agents with advanced memory. Originally the MemGPT research project from UC Berkeley, it provides tiered memory systems that let agents remember, learn, and self-improve over time.
How much does Letta cost?
Letta offers a free tier with 3 agents and BYOK, a Pro plan at $20/month with unlimited agents and $20 API credits, a Max plan at $200/month for power users, and custom Enterprise pricing.
How is Letta different from Mem0?
Letta provides a full agent framework with built-in memory management, tool calling, and an agent development environment. Mem0 is more focused on being a standalone memory layer you add to existing agents. Letta is heavier but more integrated.
Can I self-host Letta?
Yes, the core Letta framework is open source (Apache 2.0) and can be self-hosted. The cloud platform adds hosted infrastructure, the ADE (Agent Development Environment), and managed scaling.
Executive Summary
Letta is a platform for building stateful AI agents with advanced memory systems. Originally the MemGPT research project from UC Berkeley's AI Research Lab (BAIR), it introduced the concept of virtual context management — using an OS-inspired memory hierarchy to give LLMs effectively unlimited context. The company emerged from stealth in September 2024 with $10M in seed funding led by Felicis, with participation from Founders Fund and YC.
| Attribute | Value |
|---|---|
| Company | Letta (formerly MemGPT) |
| Founded | 2023 (research), 2024 (company) |
| Funding | $10M seed (Felicis, Founders Fund, YC) |
| Founders | Charles Packer, Sarah Wooders, Vivian Myers |
| Origin | UC Berkeley BAIR Lab |
| GitHub Stars | 21.2K+ |
| License | Apache 2.0 |
How It Works
Letta's core innovation is a tiered memory architecture inspired by operating system memory management. Agents have:
- Core Memory — always in the LLM context window. Contains the agent's persona and key info about the current user. Editable by the agent in real-time.
- Archival Memory — a vector database for long-term storage. Agents can write observations and retrieve them later via search. Scales to unlimited size.
- Recall Memory — full conversation history stored in a database. Agents can search past messages rather than relying on a fixed context window.
The agent autonomously decides when to read/write across these tiers using tool calls. This creates a self-managing memory system where the LLM acts as its own memory controller — the key insight from the original MemGPT paper.
Recent Developments
Letta has expanded beyond pure memory into a full agent platform:
- Letta Code — a memory-first coding agent that runs in your terminal, ranked #1 model-agnostic agent on Terminal-Bench
- Context Repositories — git-based memory for coding agents (Feb 2026)
- Conversations API — shared agent memory across concurrent user sessions
- ADE (Agent Development Environment) — web UI for building and managing agents
Pricing
| Plan | Price | Key Features |
|---|---|---|
| Free | $0 | 3 agents, BYOK, ADE access, Letta Code |
| Pro | $20/mo | Unlimited agents, frontier model access, $20 API credits |
| Max | $200/mo | Higher limits, optimized for Letta Code, early access |
| Enterprise | Custom | RBAC, SSO (SAML/OIDC), dedicated support, volume pricing |
BYOK (Bring Your Own Key) is available on all tiers. Client-side tool execution (e.g., bash tools in Letta Code) incurs no server credit cost.
Strengths
- Deep research pedigree — born from a well-cited academic paper, not hype-driven
- Model-agnostic — works with OpenAI, Anthropic, Mistral, and local models via Ollama
- Open source core — Apache 2.0 license, self-hostable, 21K+ GitHub stars
- Full Python and TypeScript SDKs with a proper REST API
- Memory transparency — developers can inspect and control agent memory state, unlike black-box alternatives
- Active development — regular releases, expanding into coding agents and context repositories
Cautions
- Complexity overhead — the tiered memory system adds latency and token cost from internal tool calls
- Stability concerns — some users report instability, especially with local models
- Scope creep risk — expanding from memory layer into full agent framework and coding agent puts them in competition with many more players
- Community perception — some view the pivot from pure memory research to agent platform as chasing hype, though the founders dispute this
- Local model support — while technically model-agnostic, reliability with smaller local models can be poor
Competitive Positioning
| Feature | Letta | Mem0 | LangGraph | CrewAI |
|---|---|---|---|---|
| Primary Focus | Stateful agents with memory | Memory layer | Agent orchestration | Multi-agent teams |
| Memory System | Built-in tiered (core/archival/recall) | Standalone memory API | Manual state management | Basic memory |
| Self-Hosted | Yes (Apache 2.0) | Yes (Apache 2.0) | Yes | Yes |
| Cloud Offering | Yes | Yes | LangSmith | CrewAI Enterprise |
| Coding Agent | Yes (Letta Code) | No | No | No |
| Model Agnostic | Yes | Yes | Yes | Yes |
| Best For | Long-running agents needing persistent memory | Adding memory to existing agents | Complex agent workflows | Team-based agent orchestration |
Bottom Line
Letta occupies a unique niche: it's the most serious open-source attempt at solving LLM memory as a first-class concern. The MemGPT paper was genuinely influential, and the tiered memory architecture remains the most principled approach to agent state management available.
The risk is strategic focus. Letta started as a memory system and is now also a coding agent, an API platform, and a cloud service. Each of these puts them in competition with well-funded incumbents. The memory layer — their core differentiator — risks being overshadowed by frontier model providers building native memory features.
For developers building agents that need to remember and learn over long time horizons, Letta is the most mature open-source option. The free tier and BYOK model make it low-risk to evaluate. Just be prepared for the additional complexity that comes with a self-managing memory system.