Back to vendors
L

Letta

Visit site
Entry pricePro at $20/mo, and the API plan at $20/mo plus usage. A free tier exists, Enterprise is custom, and self hosting is free.Full pricing detail

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

AI developers

Deployment options

SaaSself-hosted

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.

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

·Agent capabilityVerified

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 source
·Workflow orchestrationVerified

Letta 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 source
·Observability / auditabilityVerified

Every 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 source
View all 6 Letta updates →Tracked since Jul 2026 · Verified from public vendor sources

Pricing

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.

Free tier

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.

Agentic Index verified 2026-10-25

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

Contact us

Found a vendor we missed? Have feedback on the index? We'd love to hear from you.