Letta Review 2026: Memory, ADE, Pricing, Alternatives

From MemGPT to Letta: History and Funding

What Is Letta?

• Core memory: a small set of labeled, structured memory blocks (commonly a "human" block and a "persona" block) that stay pinned inside the context window at all times, editable by the agent and shared between agents
• Archival memory: an out-of-context store, backed by PostgreSQL with pgvector, that the agent searches and writes to via tool calls (archival_memory_search and archival_memory_insert) rather than always keeping in view
• Self-editing memory: the agent decides what belongs in core memory, what to summarize, and what to move to archival storage — the model manages its own memory hygiene inside its normal reasoning loop
• Agent Development Environment (ADE): a visual interface for watching and editing an agent's memory blocks, context, and reasoning while it runs, aimed at making an otherwise opaque context window inspectable
• Letta Cloud vs. self-hosted server: the same open-source server can run on Letta's managed cloud or on your own infrastructure — both speak the same API
• Model-agnostic: works with OpenAI, Anthropic, and other providers through bring-your-own-API-key configuration, as well as local model backends

from letta_client import Letta
import os

client = Letta(api_key=os.getenv("LETTA_API_KEY"))

# Create a stateful agent with core memory blocks
agent = client.agents.create(
    model="openai/gpt-4o-mini",
    embedding="openai/text-embedding-3-small",
    memory_blocks=[
        {"label": "human", "value": "Name unknown yet. Learn and update as we talk."},
        {"label": "persona", "value": "I am a helpful assistant that remembers context across sessions."},
    ],
)

# Send a message — the agent can read and edit its own memory blocks
response = client.agents.messages.create(
    agent_id=agent.id,
    input="Hi, I am switching from Postgres to SQLite for this project.",
)
for message in response.messages:
    print(message)

How Much Does Letta Cost?

• Letta (the framework and self-hosted server): free forever under Apache 2.0, whether self-hosted, modified, or used commercially — you pay only your own infrastructure and model API costs
• Letta Cloud Free tier: $0 per month, a limited number of managed agents, bring-your-own API keys, no account required for local use
• Letta Cloud Pro tier: $20 per month, up to 20 stateful agents, a weekly/monthly usage quota for Letta's own managed model access, pay-as-you-go overage
• Letta API (developer) plan: $20 per month base, plus $0.10 per active agent per month and $0.00015 per second of tool execution, with LLM usage billed at provider cost
• Teams Pro: $20 per seat per month, adds shared organizations, teammate access, and agent-sharing controls
• Enterprise: custom pricing, adds volume-based rates, higher quotas, role-based access control, SAML/OIDC single sign-on, and dedicated support

How Do You Install and Get Started With Letta?

1. 1
   Install the client library: pip install letta-client (Python) — a JavaScript/TypeScript client is also available for the same API.
2. 2
   Choose self-hosted or cloud: run the open-source Letta server yourself (Docker image on GitHub), or point the client at Letta Cloud by creating an API key at letta.com.
3. 3
   Set your model provider credentials — Letta supports bring-your-own-API-key configuration for OpenAI, Anthropic, and other providers, as well as local model backends.
4. 4
   Create an agent with client.agents.create(), passing a model, an embedding model, and one or more memory_blocks (for example a "human" block and a "persona" block) that become the agent's core memory.
5. 5
   Send messages with client.agents.messages.create() — the same agent ID keeps its memory across every future call, including calls made days or weeks later.
6. 6
   Open the Agent Development Environment to watch and edit an agent's core memory, archival memory, and reasoning steps visually instead of only through API responses.
7. 7
   Read the official Letta documentation and browse the GitHub repository for the current API reference — Letta's product surface has expanded since 2024, so check which SDK version a tutorial targets.

Who Should Use Letta?

When Should You NOT Use Letta?

• A simple, stateless chatbot that answers one question at a time with no need to recall prior sessions — a plain API call or a lightweight chain is less overhead than a full memory-management framework
• A team that needs multiple agents with distinct roles collaborating on a task (researcher, writer, reviewer) — CrewAI is built specifically for role-based multi-agent collaboration, which is not Letta's focus
• A team that wants explicit, developer-defined control over agent state transitions, branches, and cycles rather than letting the model manage its own memory — LangGraph offers that graph-based explicit state control
• A .NET-first enterprise team already standardized on Microsoft tooling — Semantic Kernel integrates more directly with that stack
• Use Letta instead when the defining requirement is a single agent that needs to remember specific facts, preferences, or history across sessions without you writing custom persistence logic

Letta vs. Alternatives

Common Mistakes When Evaluating Letta

Frequently Asked Questions

Sources

Related Reading

• LangGraph Review: Features, Pricing, Alternatives — a closer look at the graph-based agent runtime for teams that want explicit state control instead of agent-managed memory.
• CrewAI Review: Features, Pricing, Alternatives — the role-based multi-agent alternative for teams coordinating several specialized agents rather than giving one agent long-term memory.
• AutoGen Review: Features, Pricing, Alternatives — Microsoft Research's multi-agent conversation framework, for comparison against Letta's single-agent memory focus.
• LangChain Review: Features, Pricing, Alternatives — the general-purpose framework most often combined with a dedicated memory layer like Letta.
• Semantic Kernel Review: Features, Pricing, Alternatives — Microsoft's .NET-first alternative for enterprise teams standardized on that stack.
• Local LLM Software Directory — the full catalog of local AI tools this article belongs to, including where Letta fits among agent frameworks.