Letta

What is Letta?

Letta is an open-source, model-agnostic framework/runtime for building stateful AI agents — agents whose memory, tools and configuration persist as a durable server-side object across sessions, instead of resetting on every new request the way a stateless orchestration framework does. It grew directly out of MemGPT, the UC Berkeley Sky Computing Lab research project that pioneered virtual context management for LLMs, and is built by Sarah Wooders and Charles Packer (both UC Berkeley PhD students on the original MemGPT paper), who founded the company in San Francisco. It raised a $10M seed round led by Felicis in September 2024 (with Sunflower Capital, Essence VC and angel investors including Google DeepMind's Jeff Dean, Hugging Face's Clem Delangue and Runway's Cristobal Valenzuela), at a $70M post-money valuation. The core framework (letta-ai/letta) is Apache 2.0-licensed and self-hostable; a newer, actively-developed CLI/agent-harness layer, "Letta Code" (npm package @letta-ai/letta-code, also Apache 2.0), adds git-based versioned "Context Repositories" for agent memory and a managed Letta Cloud option. It powers production deployments at companies including Bilt, 11x, Kognitos and Hunt Club.

What does Letta do?

Letta bundles persistent long-term memory, tool-calling and multi-step execution into a durable agent process: an agent's memory, message history, tools and model settings survive indefinitely rather than being reconstructed from a prompt on every call. Memory is versioned via git-based "Context Repositories," so an agent's accumulated knowledge can be branched, diffed and rolled back like code. A "sleep-time compute" feature lets an agent keep reasoning and reorganizing its own memory during idle periods, rather than only when actively handling a request. It can be used to build coding agents, AI coworkers deployable to Slack/Telegram/Discord, or fully custom stateful applications via an Agent SDK — accessible through a desktop app, CLI, web app, or direct SDK integration, and either self-hosted (the Apache 2.0 core) or run on the managed Letta Cloud.

Key features

• Stateful agents, not stateless calls: An agent's memory, tools and configuration persist as a durable server-side object across sessions — the central design difference from stateless orchestration frameworks like LangChain, CrewAI or the OpenAI Agents SDK.
• Git-based versioned memory (Context Repositories): An agent's long-term memory is versioned like code — branchable, diffable and revertable — rather than a flat, unversioned context window or vector store.
• Sleep-time compute: Agents can keep reasoning and reorganizing their own memory during idle periods, not only while actively handling a request.
• Open-source core, optional managed cloud: The framework (letta-ai/letta, 23.9K+ GitHub stars) and the newer Letta Code CLI harness (letta-ai/letta-code, 2.9K+ stars) are both Apache 2.0 and self-hostable, with a managed Letta Cloud as an optional paid layer.

What are Letta's use cases?

• Long-running personal or coding assistant: A developer runs Letta Code via CLI or desktop app to build an assistant that remembers project context, prior decisions and conversation history across sessions instead of starting from a blank slate each time.
• AI coworker deployed to team chat: A team deploys a Letta-based agent to Slack, Telegram or Discord that accumulates and versions its own memory of team context over weeks, using sleep-time compute to reorganize what it has learned.
• Self-hosted, no vendor lock-in: A team runs the Apache 2.0-licensed core entirely on its own infrastructure, bringing its own model API keys, and opts into managed Letta Cloud only if it later wants a hosted deployment.

What does Letta integrate with?

• Desktop app, CLI, web app and Agent SDK access
• Deployable as AI coworkers to Slack, Telegram or Discord
• Bring-your-own API keys for any supported model provider

Why use Letta?

• A genuinely different architecture from every other framework in this category — memory-first and stateful, versus the stateless call-graph design of LangChain, CrewAI, LlamaIndex, AutoGen, the OpenAI Agents SDK, Pydantic AI and Mastra.
• Git-based versioned memory (Context Repositories) and sleep-time compute are capabilities no other listed framework offers.
• Apache 2.0 core is free, self-hostable and independently verifiable as active open source — 23.9K+ GitHub stars on the core framework, 2.9K+ on the newer Letta Code harness, both pushed within the last day.
• Real institutional backing: a $10M seed led by Felicis with a roster of notable individual angel investors (Jeff Dean, Clem Delangue, Cristobal Valenzuela among them), plus named production users including Bilt, 11x, Kognitos and Hunt Club.

Pros & cons

Letta pricing

The Apache 2.0 core framework is free to self-host with your own API keys; the managed Letta Code product has a genuine Free tier plus Pro/API/Teams Pro plans at $20/month(/seat), and custom-priced Enterprise.

• Free$0 / /month
• Pro$20 / /month
• API Plan$20 / /month base + usage
• Teams Pro$20 / /seat/month
• EnterpriseCustom

See current pricing on letta.com ↗Compare Letta alternatives →

Letta review

Letta is the one framework in this category built around a genuinely different premise: agents as stateful, persistent objects — with git-versioned memory and idle-period "sleep-time compute" — rather than stateless call graphs assembled fresh on every request. That premise traces directly back to MemGPT, the Berkeley research it grew out of, and its founders (Sarah Wooders, Charles Packer) are the same researchers behind that work. The open-source core is real and active (23.9K+ GitHub stars, Apache 2.0, self-hostable), backed by a $10M Felicis-led seed round and used in production at Bilt, 11x, Kognitos and Hunt Club. The tradeoffs: it's a much smaller, younger ecosystem than LangChain's, its funding is a single, smaller seed round rather than a later-stage raise, and its product surface is split across two differently-adopted repos. Pick it when persistent, evolving agent memory is the actual requirement; pick a stateless orchestration framework when the task is a bounded workflow that doesn't need to remember anything between runs.

The memory-first pick — genuinely stateful agents with versioned memory, direct from the MemGPT research team, but a much smaller ecosystem than LangChain's.

Frequently asked questions