Last updated: 2026-10-26
Letta, the company behind MemGPT, raised a $10 million seed round in September 2024 and ships an open-source agent runtime with 25.3k GitHub stars. Its agents keep memory in a git-versioned filesystem, run background reflection between sessions, and work across a terminal, a web app and five messaging platforms.
About Letta
Letta is the company and open-source project behind MemGPT, the 2023 research on giving a language model a virtual context window so an agent can remember across sessions. It is based in San Francisco, was founded by Charles Packer and Sarah Wooders from UC Berkeley's Sky Computing Lab, and raised a $10 million seed round led by Felicis in September 2024. Today it ships as Letta Agent: an agent runtime, a terminal app, a web app, an SDK and a hosted cloud, all built around agents that keep their own memory.
The core idea is that memory is context management. A Letta agent stores what it learns in a git-versioned memory filesystem called MemFS, can rewrite its own system prompt, picks up reusable skills, and runs background subagents (the docs call it dreaming) that reorganize what it knows between sessions. One agent holds many conversations that share the same memory, and the memory stays visible and editable instead of hiding inside a vector index. That white-box approach is the main difference from Mem0, which sells memory as a layer you plug into an app you already built.
Letta is also a place for agents to run. The docs describe a CLI, a web app and an Agent SDK for TypeScript applications. Agents can run on a schedule, work in cloud sandboxes, and answer in Slack, Discord, Telegram, WhatsApp or Signal. You can bring your own model keys, including coding plans from ChatGPT, GitHub Copilot, Kimi and Z.AI, or use Letta Auto, which picks frontier models for you. Self-hosting is supported: the local runtime keeps all agent state on your machine and needs no Letta account. The vendor site names Bilt, 11x, Kognitos and Hunt Club as case studies.
It overlaps with several kinds of tool. Agent frameworks such as LangChain, CrewAI and LlamaIndex hand you building blocks and leave state to you, while Letta makes persistent state the starting point. Coding agents like Claude Code, Cursor, Windsurf, Replit and Devin also keep project notes, but Letta treats the agent, not the repository, as the thing that remembers. Personal agents such as Manus, Lindy and OpenClaw are the closer comparison for the assistant use case. For no-code automation look at n8n or Zapier, and for sandboxed code execution as its own service, E2B or Modal.
Plans are split into personal, developer and team tiers, and the free plan is limited to 3 stateful agents, so read the cost answer below before committing. The agent code is Apache-2.0 on GitHub, although the current source has moved from the original repository to letta-code and the older V1 API server is archived. The vendor published a research post in October 2026, FrontierMemory, that benchmarks how agents improve with memory. Those results are the vendor's own and we have not reproduced them.
Pricing
com/pricing, as checked on the day of upload. Free is $0 with 3 stateful agents, 5 MiB per memory repository and bring-your-own keys. Pro is $20 a month with up to 20 agents and 50 MiB per repository.
00015 per second of server-side tool time, with LLM usage billed at the model rate. Teams Pro is $20 per seat per month. Enterprise is custom.
The vendor says casual coding users typically spend about $100 a month or more in usage.
| Tier | Monthly price | What it includes |
|---|---|---|
| Free | Free | |
| Pro | $20/mo | |
| API Plan | $20/mo | |
| Teams Pro (per seat) | $20/mo | |
| Enterprise | Custom |
Key Features
- Git-versioned memory (MemFS): Agent memory lives in a git-versioned filesystem the agent can read, write and reorganize, capped at 5 MiB per memory repository on the free plan and 50 MiB on Pro.
- Background reflection: Sleep-time subagents review and reorganize memory between sessions, the technique behind the vendor's sleep-time compute research.
- Five messaging channels: One agent can answer in Slack, Discord, Telegram, WhatsApp and Signal while keeping the same memory and identity as in the terminal.
- Bring your own model: Every plan accepts your own API keys, including ChatGPT/Codex, GitHub Copilot, Kimi Code and Z.AI coding plans, with Letta Auto as the managed option.
- Skills, schedules and mods: Agents learn reusable skills, run one-time or recurring scheduled prompts, and extend their own runtime through mods.
- Self-hosting: The local runtime keeps all state on your machine with no account, and the App Server hosts agents centrally for the TypeScript Agent SDK.
Pros
- Open-source runtime with 25.3k GitHub stars, so the agent code can be audited and self-hosted.
- Memory is white-box: files in a git repository you can read and diff, not an opaque vector index.
- The free plan accepts your own keys, so you can try it for $0 with a coding plan you already pay for.
- The same agent identity and memory follow you across the terminal, the web app and 5 messaging platforms.
Cons
- Free-plan agents are capped at 3, and each memory repository gets only 5 MiB.
- Usage is quota based with pay-as-you-go overage, and heavy coding use costs far more than the base plan, by the vendor's own guidance.
- The project moved: current source is letta-ai/letta-code and the V1 API server is archived, so older MemGPT-era tutorials no longer match.
- No SOC 2, HIPAA or ISO 27001 attestation appeared on the public pages we read, which matters for procurement.
- Memory-benchmark results (FrontierMemory) are self-published by the vendor.
Frequently Asked Questions
How much does Letta cost in 2026?
Letta publishes five plans. Personal use is free or $20 a month on Pro. Developers on the API Plan pay a flat $20 monthly fee, a small charge per active agent and a per-second charge for server-side tools. Teams Pro adds seats at $20 each, Enterprise is quoted, and model usage is billed at the provider rate.
Can I use Letta without paying?
Yes. The free plan allows 3 stateful agents, 5 MiB of storage per memory repository and limited use of Letta Auto, and you can connect your own provider keys or an existing coding plan. The local runtime also runs on your own machine without a Letta account, which keeps all agent state on-device.
What are the best alternatives to Letta?
Mem0 fits teams that only want a memory API inside an existing app. LangChain and LlamaIndex suit builders who want general frameworks and will manage state themselves. CrewAI is the pick for several cooperating role-based agents, and Claude Code is closer if the main job is coding in a repository.
Should I pick Letta or Mem0 for agent memory?
Mem0 is a memory layer that you call from your own agent code. Letta is the agent runtime itself, so memory, skills, schedules and channels come together, and the memory is files you can read in git. Choose Mem0 when you already have an agent and need recall, and Letta when you want the agent to own its memory.
How do you get started with Letta?
Install the CLI with npm i -g @letta-ai/letta-code and run letta, or open the web app. Connect your own provider keys with /connect, or use Letta Auto on a paid plan. Developers who want it inside an application start with the Agent SDK and choose Letta Cloud or a self-hosted App Server.
Top Alternatives
- Mem0: Pick Letta if you want a whole agent runtime with visible memory; pick Mem0 if you only need a memory API for an app you already run.
- LangChain: Pick Letta when persistent state is the point; pick LangChain when you want the widest set of building blocks and integrations.
- CrewAI: Pick Letta for one long-lived agent that learns; pick CrewAI for a team of role-based agents on a defined workflow.
- LlamaIndex: Pick Letta for agent memory and identity; pick LlamaIndex when document retrieval is the main job.