Letta Stateful Agents Review 2026: Apache-2.0 Memory-First Runtime & Verified Pricing

A week after Anthropic shipped Skills API + Files API + Computer Use on August 19, 2026, the conversation about what an "agent platform" should look like in 2026 has split into two camps: closed vendor stacks where memory, skills, and tools live behind the API, and open-source agent runtimes that put the developer — and the agent — in charge of all three. Letta (legal entity Letta, Inc., San Francisco) is the most consequential open-source play in that second camp right now. Its main repository letta-ai/letta holds 24,416 GitHub stars, is Apache-2.0 licensed, and was last pushed on August 23, 2026; its CLI @letta-ai/letta-code sees 64,176 weekly downloads on npm. This review covers what the Letta Agents SDK actually does, verified pricing (Free $0, Pro $20/mo, Teams Pro, Developer Plan, Enterprise), the persistent-memory model, Skills + Mods + Channels, and when it makes sense to choose Letta over a closed agent platform.

What Letta actually is

Letta positions itself as "The platform for building stateful agents." The agent harness is fully open source (Apache-2.0), and the Letta Agents SDK runs the same agent across three surfaces: a desktop app, a CLI (@letta-ai/letta-code, requires Node.js 22.19+), and Cloud Agents on platform.letta.com. Capabilities verified from the docs and blog:

• Persistent memory as the agent's responsibility. Three memory blocks — core (always in context), archival (long-term searchable), recall (recent messages) — plus runtime memory-editing tools so the agent can rewrite its own memory files at runtime, not just retrieve from a vector store.
• Skills API (docs.letta.com/configuration/skills) packages reusable workflows the agent invokes on demand. This is directly comparable to Anthropic Skills API (Aug 19, 2026) — both are about reusable agent workflows, but Letta's runs against any LLM you bring.
• Mods (June 2026) extend the Letta Code harness itself, so the agent can reshape its own tool stack as it learns. This is "harness-level adaptation," distinct from regular plugins.
• Channels (docs.letta.com/configuration/channels) ship an AI coworker into Slack, Telegram, or Discord with an always-on cloud VM deployment (platform/computers/byom) so the agent is reachable from a phone.
• Conversations API (January 2026) maintains shared memory across concurrent experiences — multiple users can collaborate with the same agent without losing context.
• BYOK everywhere. All plans support bringing your own API key (OpenAI, Anthropic, Google, Kimi, Z.AI). /connect in the CLI routes usage through your provider account — no Letta credit burn.

Letta's bet is a position statement: "Why memory isn't a plugin" (April 2026 blog post). Memory cannot be bolted onto an agent as a vector store or a RAG call. Context and state management are core responsibilities of the agent harness itself. That philosophy is what the open-source license protects: if you do not like how Letta models memory, you can fork the harness and run it your way.

Verified pricing (letta.com/pricing, 2026-08-25)

Letta bills by plan and usage. There is no per-token model rate because the model is bring-your-own (or pay-as-you-go through Letta Auto on the Pro plan and above). All rates below are verified on the live pricing page.

Per the FAQ on letta.com: server-side Letta API tools bill CPU time at $0.00015/sec; remote MCP tools run on the MCP provider (no Letta credit cost); Letta built-in tools are free except web search/fetch. BYOK usage on any plan routes through your own provider account, so caching and rate-limit policies inherit from your OpenAI/Anthropic/Google contract, not Letta's. The pricing page explicitly tells heavy users to budget above Pro: casual coding users hit roughly $100/mo in usage, power users can exceed $200/mo.

The persistent-memory model, in detail

Most "memory" features in modern agent frameworks are retrieval features in disguise: take a vector store, embed past context, and let the agent pull relevant snippets. Letta's model is fundamentally different. The agent owns three explicit memory blocks and can edit them at runtime using memory tools — not just query, but write.

• core memory — the always-in-context block. Think of it as the agent's persistent self-description: who it is, what project it is working on, key facts about the user. The agent updates this block when those facts change.
• archival memory — long-term, searchable storage for facts the agent does not need every turn but should remember. Inserts go through a tool call, so the agent decides what is worth remembering.
• recall memory — recent-message search, the shortest horizon. Used to look up what the user said a few turns ago without re-reading the whole transcript.

The practical difference from a vector-store-only design: a Letta coding agent that learned your repository's build commands last week rewrites those commands into core and carries them forward forever, instead of forcing you to re-explain them every session. A Letta personal assistant that learned your meeting cadence writes "standup at 10:00 Mon/Wed/Fri" into archival memory and surfaces it when relevant. The agent is the curator, not the developer.

Where Letta fits the Skills+Computer Use moment

The August 19, 2026 Anthropic launch of Skills API + Files API + Computer Use put reusable workflows and desktop control on the same vendor stack. Letta is the open-source answer to that stack, with one important difference: each Letta layer is independent.

The two stacks compose well. A Letta agent can call Claude for inference (BYOK), wrap the call in a Skill, register the Skill in Mods so the agent learns when to use it, and deliver the result through a Channel — with persistent memory across every step. The composition is opt-in rather than vendor-locked, and the Apache-2.0 license means the runtime itself cannot be retracted.

Mods (June 2026): when the agent reshapes its own harness

Mods are Letta's most opinionated feature. Where Skills are reusable workflows the agent invokes, Mods extend the Letta Code harness itself. That means the agent can rewrite how it runs — adding tools, swapping in new behaviors, reshaping the prompt structure — as it learns what works. The June 2026 launch post frames it as "an agent-friendly way to extend and adapt the Letta Code harness."

The distinction matters for risk modeling. Skills add new actions to the agent's toolbox; Mods change the engine. In production this is the difference between "the agent can now run a new query type" and "the agent has rewritten part of how it makes decisions." Letta's framing assumes the latter is a feature: the agent gets better over time because it adapts its own substrate. The open-source license protects the developer here: if a Mod goes wrong, the agent and the harness are both readable and auditable. Compare with closed agent platforms where the harness itself is opaque.

Channels and the always-on AI coworker

Channels turn a Letta agent into something you can ping from a chat client. The channels docs cover Slack, Telegram, and Discord as first-class delivery surfaces. Each channel connects the agent to a specific chat platform; the agent runs in the background and answers when addressed.

For an AI coworker to be reachable from a phone, the harness has to be running somewhere. Letta's always-on cloud VM deployment (in platform/computers/byom) keeps an agent alive across restarts. The Pro plan and above include remote sandboxes for this; the Enterprise plan extends it with custom regions and self-hosting options.

Limitations and gotchas

1. Agent runtime, not a model API. Letta does not provide its own LLM. You bring your own API key (BYOK) or pay for inference via the Pro plan's Letta Auto router. If you only want a model API, Letta is the wrong layer — start with OpenAI, Anthropic, DeepSeek, or one of the dedicated providers.
2. No mainland-China direct endpoint. Letta, Inc. is a US entity and platform.letta.com is a single global endpoint. Production traffic from China needs a proxy or relay (typical cross-Pacific first-byte latency ~150-250ms). The Apache-2.0 license means self-hosting is the answer for China residency.
3. Heavy users exceed Pro plan quickly. The pricing page itself estimates power users at $200+/mo in total usage. Plan at list pricing, not at the $20/mo entry point.
4. Server-side tools bill CPU time. Server-side Letta API tools cost $0.00015/sec of CPU. Long-running tool calls (heavy MCP, long bash) make single-task costs non-trivial. Client-side tools in the CLI are free because they run on your machine.
5. Free tier caps at 3 agents. If you are evaluating a real production workload, Free runs out fast. Pro ($20/mo) is the practical floor for any serious personal use.
6. Agent-framework semantics have a learning curve. The vocabulary (core / archival / recall, Mods, Skills, Channels, byom) is new. Plan a day or two to read the docs and run the quickstart before committing.

FAQ

Is Letta a vector database? No — Letta is an agent runtime with first-class persistent memory. The archival memory block is searchable, but it is the agent's own memory layer, not a general-purpose vector store. For dedicated vector-DB options, see our Weaviate, Pinecone, and Qdrant reviews.

Can I self-host the full Letta stack? Yes. The letta-ai/letta repository is Apache-2.0; the desktop app, CLI, and Agents SDK all run on your own infrastructure. Enterprise plans support custom regions and dedicated support on top of self-hosting.

What models does Letta support out of the box? BYOK covers OpenAI, Anthropic, Google, Kimi, and Z.AI. The Letta Auto option adds automatic frontier-model routing (with Auto Chat and Auto Fast variants) for Pro and above. Any other OpenAI-compatible endpoint can be added via the SDK.

How does Letta compare to Mem0 or Letta-style memory layers? Mem0 focuses on the memory layer itself (extracting and storing user facts). Letta's memory is broader — it includes core/archival/recall blocks, runtime editing, and the full agent harness around it. If you want the whole agent, Letta; if you only want a memory layer to drop into your own agent, Mem0.

Is Letta the same as the old MemGPT project? Letta was founded by the MemGPT research team at UC Berkeley. The commercial Letta, Inc. entity took the research and turned it into the Letta Agents SDK and Cloud Agents product; the research lineage continues in their research publications.

Bottom line

Letta is the strongest open-source, memory-first agent runtime available in 2026, and it lands cleanly as the agent-harness half of the Skills+Computer Use moment. Where Anthropic ships Skills API + Files API + Computer Use on a closed Claude-only stack, Letta ships the same conceptual layers (Skills, Mods, Channels) on an Apache-2.0 runtime that works against any model you bring. Pricing is transparent and plan-based: Free $0 (3 agents, BYOK), Pro $20/mo (20 agents, Letta Auto quota + overage), Developer Plan (API-key usage-based, no agent cap), Enterprise (self-host, custom models). The trade-off is exactly the right shape: Letta does not try to be a model API, so you compose it with the model provider that fits your cost and quality needs, and the Apache-2.0 license protects the runtime itself from vendor retreat. If you are building a stateful AI coworker or coding agent and want cross-session memory without giving up model choice, Letta is the pick. The authoritative sources are the Letta pricing page, the docs, and the letta-ai/letta repository.

If you are wiring Letta (or Claude, GPT, DeepSeek, Qwen) behind a single OpenAI-compatible key and want cross-region failover for the agent stack, FreeModel is the simplest handoff: one dashboard, one billing relationship, and routing controls without glue code.