Open-source agent platform from the MemGPT team. Agents remember across chats, run in a CLI, web app or SDK, and reply on Slack, Telegram and more.
Choose Letta if you want an agent that remembers you and can be self-hosted, rather than a memory API bolted onto another framework. It suits developers comfortable with a CLI or SDK. The free plan caps you at 3 agents, so serious use means paying or bringing your own keys.
Git-versioned, agent-editable memory that stays readable and portable across terminal, web and chat channels.
The MemGPT research lineage and an open-source runtime with a large contributor base give it credibility, but memory layers and coding-agent notes are being copied by every framework.
Main trade-off
The product has been rebuilt more than once, so docs, APIs and tutorials drift and newcomers hit stale material.
| Plan | Monthly price |
|---|---|
| Free | Free |
| Pro | $20/mo |
| API Plan | $20/mo |
| Teams Pro (per seat) | $20/mo |
| Enterprise | Custom |
Five plans per docs.letta.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. The API Plan is $20 a month plus $0.10 per active agent per month and $0.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.
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.
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.
Most users expect these and they are not currently supported.
| Tool | Price from | Free plan | Runs on | Rating |
|---|---|---|---|---|
| $20/mo | Yes | Web | -- | |
| -- | Yes | Web | 3.6 | |
| $39/mo | Yes | Web · Mac · Windows | -- | |
| -- | Yes | Web | -- |
Apache-2.0 (open-source harness)
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.
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.
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.
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.
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.
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.
Product facts on this page (pricing, plans, integrations, compliance) are read from Letta's own pages and documentation. The verdict is Hokai's reading of them, not the vendor's claim.