# Letta — A stateful-agent framework — open-source, memory-first agents whose context, tools and identity persist as a durable server object instead of resetting between sessions.

> Source: The Agents Index — https://theagentsindex.com/letta (structured, researched, re-verified)
> Facts last verified: 2026-07-24

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.

| Fact | Value |
| --- | --- |
| Website | https://www.letta.com |
| 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. |
| API | Yes |
| Best for | Developers building agents that need to genuinely remember and improve across long-running sessions — a personal assistant, an AI coworker, or any application where context shouldn't reset between calls. |
| Not for | Teams that just need a stateless orchestration/workflow graph for a bounded task — LangChain, CrewAI or the OpenAI Agents SDK have larger ecosystems for that narrower job. |

## Verdict

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.

## Strengths and weaknesses

- ✓ A genuinely different, memory-first architecture — stateful agents whose memory, tools and identity persist server-side across sessions, versus the stateless call-graph design every other framework in this category uses.
- ✓ Git-based versioned memory (Context Repositories) and "sleep-time compute" (idle-period self-reorganization) are capabilities not offered by any other listed framework.
- ✓ Independently verifiable as real, active open source: the core framework carries 23.9K+ GitHub stars and the newer Letta Code harness 2.9K+, both pushed within the last day, both Apache 2.0.
- ✓ Real seed funding with notable backers: a $10M round led by Felicis (Sunflower Capital, Essence VC, plus angels including Jeff Dean, Clem Delangue and Cristobal Valenzuela) at a $70M post-money valuation.
- ✗ A single, smaller seed round (2024, $10M) rather than the larger later-stage rounds several rival frameworks' parent companies have raised — a much smaller balance sheet backing long-term maintenance.
- ✗ A much smaller community than the category incumbents — 23.9K GitHub stars versus LangChain's 142K+ — so fewer tutorials, integrations and battle-tested production patterns exist today.
- ✗ The product surface is split across two separate repos (the core "letta" framework and the newer "letta-code" CLI harness) with two different star counts and adoption levels — evaluate which one a given tutorial or integration actually targets.
- ⚠ Much smaller ecosystem and community than LangChain, LlamaIndex or Microsoft AutoGen.
- ⚠ Two separate GitHub repos (core framework vs. the newer Letta Code harness) can make it unclear which one a given doc or tutorial targets.

## 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.

## 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.

## Integrations

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

## Sources

- https://www.letta.com/
- https://docs.letta.com/letta-code/pricing
- https://github.com/letta-ai/letta
- https://github.com/letta-ai/letta-code
- https://www.prnewswire.com/news-releases/berkeley-ai-research-lab-spinout-letta-raises-10m-seed-financing-led-by-felicis-to-build-ai-with-memory-302257004.html