What are the best alternatives to Letta?

Based on documented capability coverage across the Agentic Index 14 point taxonomy, the closest alternatives to Letta among agent infrastructure platforms are Thread AI, xpander.ai, AlphaBitCore, Beam. Each is graded on the same public evidence, and no vendor pays for placement.

Does Letta support MCP and tool calling?

Full under the Agentic Index verification standard. Letta publishes public evidence of Model Context Protocol (MCP) support, tool calling, and API or SDK extensibility for connecting agents to external tools. Evidence basis: The Letta Agent SDK embeds stateful agents in the customer's own applications with a published reference, the App Server exposes a documented WebSocket protocol and remote client API, the API plan gives API key access for automated workload. Graded from public evidence only against the Agentic Index 14 point capability taxonomy. No vendor pays for placement.

Can Letta be self hosted or run in a private VPC?

Full under the Agentic Index verification standard. Letta publishes public evidence of self hosted or private VPC deployment, along with data residency options for controlling where agent data is processed and stored. Evidence basis: Letta runs fully locally or on the customer's own infrastructure with no Letta account required, through a self-hosted App Server, and agents can also run in Letta-managed cloud sandboxes or on the customer's own laptop, workstation or clou. Graded from public evidence only against the Agentic Index 14 point capability taxonomy. No vendor pays for placement.

Does Letta require human approval before an agent acts?

Full under the Agentic Index verification standard. Letta publishes public evidence of human approval steps and guardrails, so an agent action can be held for review before it executes. Evidence basis: 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. Letta, docs.letta.com/conf. Graded from public evidence only against the Agentic Index 14 point capability taxonomy. No vendor pays for placement.

Back to vendors

Letta

Visit site

Agent infrastructureindependentVerified 2026-09-21

Entry priceFree tier · Pro $20/mo · API plan $20/mo plus usage · self-host freeFull 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 Git-versioned memory filesystem it reads, writes and reorganizes itself, shared across all its conversations and optionally with other agents, with background dreaming to 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.

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

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 genuinely learns, 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

Research sources

https://www.letta.com https://docs.letta.com/llms.txt https://docs.letta.com/pricing/

Agentic Index coverage score

10.0 / 14 capabilities · 71%

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 decomposition and parallel execution, agents in an organization communicate and collaborate, and agents share Git-backed memory files, which is multi-step, multi-agent execution. 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 is pulled in per run through tools; no document index or retrieval store over the customer's knowledge, separate from the agent's own memory, is documented. 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
Access controls are documented: organization permissions on who can access agents and conversations, API key authentication, secrets storage, and role-based access control with SAML or OIDC SSO on Enterprise. No attestation, certification or trust center is published on letta.com or in Letta's documentation. 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. No audit log separate from runtime traces, trace export or retention by plan is documented. 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, shared across all of that agent's conversations and optionally with other agents, with background dreaming to reflect on and improve it, which is a documented memory layer with a stated scope and lifetime. 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 with no Letta account required, through a self-hosted App Server, and agents can also run in Letta-managed cloud sandboxes or on the customer's own laptop, workstation or cloud VM, each a named customer environment option. SourceLetta, docs.letta.com/self-hosting and platform/computersread 2026-09-21
Prebuilt Agents, Templates & Packs	Partial
Letta ships one ready agent, Letta Agent, run through the Letta app and CLI, plus complete example applications for developers such as a mobile client and a React chat UI; the examples are interfaces to the same agent rather than separate agents doing their own jobs. SourceLetta, docs.letta.com/agent-sdk/examples and platform/cliread 2026-09-21
Triggers & Channel Coverage	Full
Schedules send one-time or recurring prompts such as daily briefings or hourly triage without a person 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 exposes a documented 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	Not documented
No evaluation harness, scored test cases, quality gate or post-deployment optimization loop for the customer's agents is documented in Letta's documentation index. SourceLetta, docs.letta.com/llms.txtread 2026-09-21
Browser & Computer Use	Not documented
An agent's computer is where it runs tools and accesses files, either a Letta cloud sandbox or the customer's own machine, which is code and file execution rather than browser, desktop or computer control; no browser or GUI automation capability is documented. SourceLetta, docs.letta.com/platform/computersread 2026-09-21

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

Recent platform changes

2026-09-28·Workflow orchestrationVerified

Letta Code's dynamic workflows, where the agent writes its own script to fan work out to many subagents, now run for both local and cloud agents. A new decide() step returns a choice, rating or yes or no answer with a confidence score, and each subagent can run on any connected model, including the team's own provider keys.

Bears on: Workflow orchestration

View source

2026-07-24·Memory / statePartially Verified

Letta released the open-source trajectory package, which normalizes coding-agent sessions from Claude Code, Codex, and Letta Code into a single JSON-compatible format. The schema captures user messages, agent reasoning, and tool results while stripping redundant payloads to reduce token usage by up to fivefold.

Bears on: Memory / state

View source

View all 2 changes for Letta →Tracked since Jul 2026 · Verified from public vendor sources

Pricing

Free tier · Pro $20/mo · API plan $20/mo plus usage · self-host free

usage

Free tier

Included quota

Free: up to 3 stateful agents, limited Letta Auto, bring your own keys. Pro ($20/month): up to 20 stateful agents, Letta Auto weekly and monthly quota, pay-as-you-go overage, remote sandboxes. API plan ($20/month): unlimited agents at $0.10 per active agent per month and $0.00015 per second of tool execution, API key authentication, pay-as-you-go model usage. Teams Pro ($20/seat/month): shared agents with access control. Enterprise: volume pricing, RBAC, SAML/OIDC SSO, 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, API plan) plus usage: model tokens at the underlying provider cost, per-agent and tool-execution charges on the API plan. Bring-your-own keys and external coding plans bypass Letta's model billing.

Cost watchouts

Personal plans are for hands-on use; automated workloads belong on the API plan, which adds per-agent and per-second tool execution charges plus pay-as-you-go model usage. Heavy tool use and token generation drain the Letta Auto quota faster.

Variable cost rationale

Credits meter inference and CPU directly, so cost tracks agent activity and model choice; identical subscriptions produce very different effective capacity.

Additional watchouts

Letta's product emphasis is now Letta Agent and Letta Code; the Agent SDK and 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 account, no card (up to 3 agents with managed state; BYOK unlimited locally)

Lowest paid plan

Pro $20/mo

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.

Missing data

Enterprise pricing is not published.

Agentic Index verified 2026-09-21

Official pricing page Docs

Related vendors

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.

Thread AI11.0 / 14Adds documented Testing, Debugging & Optimization
xpander.ai12.0 / 14Adds documented Testing, Debugging & Optimization
AlphaBitCore9.5 / 14Fuller documented coverage on Observability & Auditability and Prebuilt Agents, Templates & Packs
Beam7.5 / 14A lighter documented profile than Letta
Bernstein10.5 / 14Adds documented Testing, Debugging & Optimization
Kestra12.5 / 14Adds documented Testing, Debugging & Optimization

Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded

Compare Letta with other vendors →Compare all agent infrastructure platforms →See where Letta ranks →

Data confidence: high

Head to head

Letta vs Agno Letta vs Mem0 Letta vs Zep