Letta
Memory-first agent harness from the MemGPT team: Letta Agent and Letta Code, plus an Agent SDK and self-hosted App Server for embedding stateful agents that learn over time.
Letta describes itself as an AI research lab building agents that remember everything, learn continuously and improve over time. It was founded by the creators of MemGPT, the UC Berkeley research that treated a language model's context like an operating system's memory. Its research ships as Letta Agent, a self improving agent run through the Letta app, the Letta CLI (Letta Code) and a web app, on an open source agent harness.
Each agent keeps memory blocks and MemFS, a memory filesystem under Git version control that it reads, writes and reorganizes itself. That memory is shared across all its conversations and optionally with other agents, and background dreaming lets the agent reflect on and improve what it has learned. Agents run tools on a Letta cloud sandbox or on the customer's own machine, delegate to subagents, connect to MCP servers, and run on schedules or as Slack, Discord, Telegram, WhatsApp and Signal bots. Permissions control which tools an agent may run and which need approval. A catalog of 22 installable Mods, official and community, extends what agents can do.
For developers, the Letta Agent SDK embeds stateful agents in their own applications, and the Letta App Server runs the agent runtime on their own infrastructure with no Letta account required. Plans run from a free tier and a $20 Pro plan to a usage based API plan, Teams Pro per seat, and Enterprise with role based access and SAML or OIDC SSO.
Vendor details
Canonical URL
https://www.letta.com
Category
Agent infrastructure
Company status
independent
Use cases & customers
Target customers
Deployment options
In practice
Your assistant forgets everything between sessions and users have to re-explain themselves each time. Letta gives the agent persistent, self-managed memory, so it remembers who the user is and what was decided weeks ago, across conversations.
You want an agent that runs for weeks and keeps learning, not a fresh chatbot each request. Letta runs agents as long-lived services that edit their own memory, persisting state in a database rather than rebuilding context every turn.
Your coding agent re-learns the same project from scratch every session. Letta Code is a memory-first terminal agent that accumulates knowledge about your codebase over time, carrying project context forward instead of starting cold.
Sources & related URLs
Agentic Index coverage score
11.5 / 14 capabilities · 82%
| Integrations & Tool Calling | Full |
|---|---|
|
Agents connect to stdio, HTTP and SSE MCP servers, take controller-owned external tools registered on the App Server, use reusable skills, and reach GitHub repositories and Slack through native integrations. SourceLetta, docs.letta.com/agent-sdk/mcp and self-hosting/app-server/external-toolsread 2026-09-21 |
|
| Workflow Orchestration | Full |
|
Agents delegate to specialized subagents for task breakdown and parallel execution, agents in an organization communicate and collaborate, and agents share memory files backed by Git, so work runs across several steps and agents. SourceLetta, docs.letta.com/configuration/subagents, concepts/shared-memory and pricingread 2026-09-21 |
|
| Knowledge Grounding & RAG | Partial |
|
Agents read the customer's files on the computers they run on and the GitHub repositories they are given access to, so knowledge comes in through tools on each run. There is no document index or retrieval store over the customer's knowledge apart from the agent's own memory. SourceLetta, docs.letta.com/platform/cloud-agents/github and platform/computersread 2026-09-21 |
|
| Human Oversight & Guardrails | Full |
|
Permissions give allowlist and approval controls over which tools an agent may run, and the Agent SDK exposes permission modes with interactive tool approvals, so a person approves a gated call before it executes. SourceLetta, docs.letta.com/configuration/permissions and agent-sdk/permissionsread 2026-09-21 |
|
| Security, Identity & Governance | Partial |
|
Organization permissions control who can access agents and conversations, alongside API key authentication, secrets storage, and role based access control with SAML or OIDC SSO on Enterprise. Letta publishes no attestation, certification or trust center. SourceLetta, docs.letta.com/pricing and teams/permissionsread 2026-09-21 |
|
| Observability & Auditability | Partial |
|
Each turn streams the agent's reasoning, assistant messages, tool calls and results for inspection, and MemFS keeps a Git history of every memory change. There is no audit log separate from runtime traces, trace export or retention by plan. SourceLetta, docs.letta.com/agent-sdk/messages and concepts/memfsread 2026-09-21 |
|
| Memory & State Persistence | Full |
|
Each agent keeps memory blocks and MemFS, a Git versioned memory filesystem it reads, writes and reorganizes itself. Memory is shared across all of that agent's conversations and optionally with other agents, and background dreaming reflects on it and improves it. SourceLetta, docs.letta.com/concepts/memfs and configuration/memoryread 2026-09-21 |
|
| Deployment & Data Residency | Full |
|
Letta runs fully locally or on the customer's own infrastructure through a self hosted App Server, with no Letta account required. Agents can also run in Letta managed cloud sandboxes or on the customer's own laptop, workstation or cloud VM. SourceLetta, docs.letta.com/self-hosting and platform/computersread 2026-09-21 |
|
| Prebuilt Agents, Templates & Packs | Full |
|
Letta's site hosts a catalog of 22 installable Mods, official and community, each with a letta install command, alongside bundled skills, and Letta ships Letta Agent as a ready agent through the app and CLI. Sourceletta.com mod catalogread 2026-10-25 |
|
| Triggers & Channel Coverage | Full |
|
Schedules send one time or recurring prompts, such as daily briefings or hourly triage, without anyone asking, and agents can create their own schedules. Agents also run as Slack, Discord, Telegram, WhatsApp and Signal bots and through a GitHub action. SourceLetta, docs.letta.com/configuration/schedules and self-hosting/channelsread 2026-09-21 |
|
| Model Flexibility & Routing | Full |
|
The customer connects model providers with their own keys or coding plans and switches an agent's model at any time, with Letta Auto as an optional routed choice, so model choice sits with the customer. SourceLetta, docs.letta.com/configuration/models and pricingread 2026-09-21 |
|
| APIs, SDKs & MCP Extensibility | Full |
|
The Letta Agent SDK embeds stateful agents in the customer's own applications, with a published reference. The App Server has a WebSocket protocol and remote client API, the API plan gives API key access for automated workloads, and agents connect to editors over the Agent Client Protocol. SourceLetta, docs.letta.com/agent-sdk, self-hosting/app-server and pricingread 2026-09-21 |
|
| Testing, Debugging & Optimization | Partial |
|
Letta documents an evaluation harness for Letta Cloud agents, with datasets, rubric and tool graders, and pass or fail gates that set the exit code. Every page of it is marked legacy, and none appears in the current docs index. Sourcedocs.letta.com/v1-sdk/evalsread 2026-10-25 |
|
| Browser & Computer Use | Partial |
|
An agent's computer is a Letta cloud sandbox or the customer's own machine, where it runs code and handles files. The 0.31.8 changelog lists a built in browser-use skill. What that skill controls, and how, is not described in the docs. Sourcedocs.letta.com reference/changelogread 2026-10-25 |
|
The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded
Product updates
Agents running apps inside a Letta Code sandbox can now expose those apps' ports, so a service the agent starts can be reached from outside the sandbox. Version 0.34.41 also adds skill guidance that teaches agents how to expose the apps they run.
Bears on: Deployment / data residency
View sourceLetta Code v0.34.40 extends its subagents with one setting that picks the runner for each subagent, either Letta or an outside coding worker such as Claude Code or Codex. A parent agent can also fork its own conversation history into the subagent, so an outside coding worker starts with the parent's transcript instead of a fresh context.
Bears on: Workflow orchestration
View sourceEvery subagent task in Letta Code v0.34.38 now writes a full JSONL event log, including tasks run by remote workers on connected computers. Delegated work, which could already run on a connected computer, now leaves a step by step record of what each task did.
Bears on: Observability / auditability
View sourcePricing
Pro at $20/mo, and the API plan at $20/mo plus usage. A free tier exists, Enterprise is custom, and self hosting is free.
Usage on top of flat monthly plans. Pro and Teams Pro, the latter per seat, carry a Letta Auto quota with pay as you go overage beyond it, and the API plan bills per active agent, per second of tool execution and for model usage.
Included quota
Free includes limited agents and limited Letta Auto, with your own API keys. Pro at $20/month includes up to 20 stateful agents, a weekly and monthly Letta Auto quota, pay as you go overage and remote sandboxes. The API plan at $20/month includes unlimited agents at $0.10 per active agent per month and $0.00015 per second of tool execution, API key authentication and pay as you go model usage. Teams Pro at $20/seat/month adds shared agents with access control. Enterprise adds volume pricing, RBAC, SAML/OIDC SSO and dedicated support.
What is public
Letta publishes Free, Pro ($20/month), API plan ($20/month plus usage) and Teams Pro ($20/seat/month) rates, with Enterprise custom, plus a free self hosted path that needs no Letta account.
Billing mechanics
Flat monthly plans (Pro, Teams Pro per seat, and the API plan) plus usage. Model tokens bill at the underlying provider cost, and the API plan adds charges per agent and per second of tool execution. Your own API keys and external coding plans bypass Letta's model billing.
Cost watchouts
Personal plans are for hands on use, and automated workloads belong on the API plan, which adds charges per agent and per second of tool execution plus pay as you go model usage. Heavy tool use and token generation drain the Letta Auto quota faster.
Variable cost rationale
Letta meters model inference and tool execution. On Pro and Teams Pro, heavy tool use and token generation drain the weekly and monthly Letta Auto quota, and usage past it is billed pay as you go. The API plan bills $0.10 per active agent per month, $0.00015 per second of tool execution and model usage at the underlying token cost, so the bill grows with the number of active agents, how long their tools run and the models they call. The flat plan fee and the Letta Auto quota absorb light use, and no spending cap is published. Your own API keys or an external coding plan move model cost to that provider, and self hosting removes Letta's charges, leaving the customer's own compute.
Additional watchouts
Letta's product emphasis is now Letta Agent and Letta Code. The Agent SDK and the self hosted App Server remain documented for building on the runtime.
Overage / add-ons
Pro and Teams Pro add pay as you go overage beyond the Letta Auto quota. The API plan bills $0.10 per active agent per month, $0.00015 per second of tool execution and model usage at the underlying token cost.
Sales call required
Mixed (some tiers require a call)
Free / trial
Free plan at $0 a month with limited agents and limited Letta Auto, using your own API keys. Self hosting is free.
Lowest paid plan
Pro at $20 per month, with up to 20 stateful agents
Commercial notes
Letta describes itself as an AI research lab founded by the creators of MemGPT from UC Berkeley's Sky Computing Lab. Its research ships as Letta Agent, run through the Letta app, CLI and Agent SDK.
Key ambiguities
Enterprise pricing is by sales; the other plans publish their rates.
Support SLA / resale
Dedicated support comes with Enterprise.
Missing data
Enterprise pricing is not published.
Related vendors
- AgentOps — Agent observability and debugging platform: open source SDKs trace…
- AgentPhone — AgentPhone gives the AI agents a team builds their own US or…
- Agno — Python agent framework and AgentOS runtime (formerly Phidata) for…
- AIsa — Resource and payment gateway for AI agents, with one key to 110+…
- Albato — Albato is a no code integration platform that sells an embedded,…
- AlphaBitCore — AI control plane for regulated financial firms: one gateway enforces…
Alternatives to Letta
The closest documented capability profiles to Letta among agent infrastructure platforms tracked by Agentic Index, ordered by similarity on the same 14 point evidence the rankings use. No vendor pays for placement.
- Pydantic AI12.0 / 14Fuller documented coverage on Testing, Debugging & Optimization and Browser & Computer Use
- Kestra12.5 / 14Fuller documented coverage on Knowledge Grounding & RAG and Security, Identity & Governance
- LangChain11.5 / 14Fuller documented coverage on Knowledge Grounding & RAG and Testing, Debugging & Optimization
- Agno13.0 / 14Fuller documented coverage on Knowledge Grounding & RAG and Security, Identity & GovernanceLetta vs Agno →
- LlamaIndex12.0 / 14Fuller documented coverage on Knowledge Grounding & RAG and Security, Identity & Governance
- Mastra14.0 / 14Fuller documented coverage on Knowledge Grounding & RAG and Security, Identity & Governance
Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded