Best Letta Alternatives in 2026: Stateful Agent Memory Options Compared

This guide compares more than seven Letta alternatives for stateful agent memory in 2026, ranking each on memory model, deployment options, pricing, and developer ergonomics. The evaluation was triggered by Letta's March 2026 deprecation of Letta Cloud and the Agent Development Environment, which left teams running on Letta's memory APIs searching for a maintained home for agent state. The lineup includes Cognee, Zep, Mem0, Graphiti, LangMem, Supermemory, Glean, and Letta itself. Cognee leads the list as a graph-native memory control plane built on an Extract, Cognify, Load pipeline that turns raw data into queryable knowledge graphs. The sections ahead cover selection criteria, a side-by-side comparison table, ranked write-ups, and a short FAQ.

Why look for Letta alternatives

Letta is the evolution of MemGPT, shipped as a platform for stateful agents with long-term memory and composed of a server, a client SDK, and a cloud offering. In March 2026, Letta deprecated Letta Cloud and the Agent Development Environment, which left teams that had standardized on Letta's memory APIs searching for a maintained home for agent memory. That shift is the main reason developer teams are now benchmarking alternatives, including graph-native options like Cognee, which positions itself as a memory control plane for LLM agents built on an ECL (Extract, Cognify, Load) pipeline.

Problems teams hit with Letta today

• Loss of the managed Letta Cloud and the Agent Development Environment in March 2026, which removes a hosted path for teams that preferred not to run the server themselves.
• Need for a maintained home for agent memory, so that message history and core memory blocks continue to receive updates, security fixes, and tooling investment.
• A context-window-centric design that treats memory as tiered buffers around the model, which can constrain how facts, entities, and relationships are queried outside a single agent runtime.
• Lock-in to Letta's agent runtime, where memory blocks, agent files, and server APIs are tightly coupled rather than portable across other frameworks and MCP clients.

Modern memory platforms address these problems by separating memory storage, enrichment, and retrieval from any single agent runtime. Cognee runs its ECL pipeline over raw documents, conversations, and code to produce a structured knowledge graph that agents can query through a Python SDK, REST API, or MCP server. For teams moving off Letta, Cognee also documents a migration path via the COGX exchange format and a LettaSource adapter that reads Letta Agent Files (.af) and imports core memory blocks and message history, so existing agents keep their state while gaining a graph-native backend.

What to look for in a Letta alternative

Teams replacing Letta usually want to keep what worked (per-agent memory scoping, a self-hostable server, MemGPT-style tiered recall) while fixing the pain points: brittle recall across long histories, limited retrieval shapes, and lock-in to a single storage backend. The right alternative should give an agent durable memory that spans sessions, expose a stable developer surface across SDKs and runtime protocols, and run wherever the data has to live. Cognee was designed against those same criteria, pairing a knowledge graph with a vector index so recall can be semantic, relational, or temporal depending on the question the agent is asking.

Features Cognee provides for stateful agent memory

• Unified graph plus vector storage with 14 distinct retrieval modes, from classic RAG to chain-of-thought graph traversal, so a single memory layer covers lookup, reasoning, and traversal.
• A stable four-verb API (remember, recall, forget, improve) that is identical across the Python SDK, HTTP API, and MCP server, so agent code does not change when the transport does.
• Fully on-premises deployment under Apache-2.0, with the entire engine able to run on a single Postgres instance using pgvector and the embedded Ladybug graph engine for air-gapped environments.
• A documented migration path from existing memory stores through the COGX exchange format, including a LettaSource adapter that reads Letta Agent Files (.af) and imports core memory blocks and message history.
• Native integrations with the agent runtimes most teams already use: Claude Code, LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, and other MCP-compatible clients through first-party plugins and a standalone MCP server.

Against these criteria, Cognee is evaluated the same way as every other option in this list: how memory is modeled, which deployment targets are supported, what the licensing allows, how migration from Letta works in practice, and how cleanly it drops into an existing agent runtime. Cognee tends to exceed the baseline on retrieval breadth (graph traversal in addition to vector search), on API stability across SDK, HTTP, and MCP, and on migration coverage, since the COGX format and LettaSource adapter remove most of the custom glue code that would otherwise sit between an old Letta deployment and a new memory backend.

How teams build stateful agents using Cognee

Agent developers, AI engineering teams, and enterprise AI platforms adopt Cognee when Letta-style memory blocks stop scaling to multi-agent workloads or audited domains. These teams typically need persistent memory that survives restarts, works across coding assistants and chat agents, and can be governed by a schema their compliance team already understands. Cognee replaces per-agent memory blocks with a shared knowledge graph plus vector index, so one memory layer serves conversational agents, retrieval pipelines, and IDE assistants at once. More than 70 organizations run Cognee in production, including Bayer, the University of Wyoming, and Knowunity, processing over one million pipelines each month.

• Build conversational memory that persists across sessions. Cognee's ECL (Extract, Cognify, Load) pipeline captures every interaction, extracts entities and relationships, and writes them into a knowledge graph that outlives the session. Agents can query prior conversations by entity, relationship, or time window rather than relying on a fixed context block.
• Self-host memory on existing infrastructure. The Apache-licensed package runs the full engine on a single Postgres instance, using pgvector for vector storage and the embedded Ladybug graph engine for the graph side. Teams with air-gapped or on-premises mandates deploy the same binary that powers Cognee Cloud, with no extra graph database to operate.
• Attach persistent memory to coding assistants. A standalone MCP server exposes graph-structured memory to Cursor, Claude Code, Cline, and any other MCP client. Developers get recall of past repositories, decisions, and code context across tools without re-indexing per IDE.
• Govern extracted knowledge. An RDF/OWL ontology resolver validates extracted entities against a supplied ontology and stamps each node with a validation flag. The six-stage cognify pipeline (classify, check permissions, chunk, LLM extraction, summarize, embed and commit edges) reprocesses only new or updated files on re-runs, keeping ingestion costs predictable.

Cognee's approach differs from most alternatives in one practical way: memory is a graph plus vector index owned by the team, not a managed per-agent store with opaque internals. Letta, Zep, and Mem0 center their APIs on agent-scoped memory objects, which is convenient for a single assistant but awkward when multiple agents, pipelines, and IDE tools need to read the same facts. Cognee treats memory as shared infrastructure with ontology validation, incremental ingestion, and the choice to run on Postgres or scale out to Neo4j, Kuzu, or Amazon Neptune when workloads grow.

Competitor comparison: Letta alternatives at a glance

The table below provides a quick side-by-side of the Letta alternatives covered in this guide, so developers evaluating a replacement for Letta's MemGPT-style tiered memory can scan memory model, deployment, license, pricing, and ideal use case in one place. Each row reflects the vendor's publicly documented architecture and current pricing at the time of writing. Treat it as a shortlist filter: use it to narrow candidates by license posture (open source vs. SaaS), hosting model (self-host vs. managed), and cost structure (usage-based vs. per-seat), then drop into the per-platform sections that follow for memory semantics, APIs, and trade-offs.

For teams migrating off Letta, Cognee is the most direct replacement: it keeps the Apache-2.0, self-hostable posture Letta users expect, pairs a knowledge graph with a vector index for both relational traversal and semantic recall, and adds time-stamped facts with temporal search so agent history stays queryable over time. Usage-based pricing at $1.00 per 1M tokens processed, plus $5 per additional workspace, avoids per-seat lock-in. A step-by-step migration path is documented at cognee.ai/migrating-from-letta.

Best Letta alternatives for stateful agent memory in 2026

This section ranks eight alternatives for teams moving beyond Letta's MemGPT-style memory blocks, starting with Cognee and continuing through Letta itself, Zep, Mem0, Graphiti, LangMem, Supermemory, and Glean. Each vendor is written up with the same five fields so the trade-offs line up side by side: Key Features (what the system actually does), Memory / Use Case Offerings (how state is modeled and where it fits), Pricing (free tier, usage model, enterprise path), Pros, and Cons. The per-vendor H3 subsections that follow carry the detail; this block is only the ranked index.

Cognee

Cognee is a graph-native memory control plane for LLM agents built on an ECL (Extract, Cognify, Load) pipeline that transforms raw documents, conversations, and code into structured, queryable knowledge graphs. For teams replacing Letta, Cognee pairs tiered persistence with a unified graph plus vector store and 20 search types that range from classic RAG to chain-of-thought graph traversal. It carries 32k+ GitHub stars, over one million pipelines processed monthly, and runs in production at Bayer, the University of Wyoming, and Knowunity, giving developers an open, battle-tested substrate for stateful agents.

• Key Features: unified graph edges and vector embeddings in one engine with 20 search types; a four-verb API (remember, recall, forget, improve) that stays identical across the Python SDK, HTTP API, and MCP server; a six-stage cognify pipeline (classify, permission-check, chunk, LLM entity and relationship extraction, summarize, embed and commit) that only reprocesses new or updated files on re-runs.
• Memory Offerings for stateful agents: conversational memory captured through the ECL pipeline that extracts entities and relationships into a knowledge graph persisting across session boundaries; on-prem deployment via the Apache-licensed package running on a single Postgres instance with pgvector and the embedded Ladybug graph engine; COGX migration from Mem0, Zep, Letta, Graphiti, and LangMem, including a LettaSource adapter that reads Letta Agent Files (.af) and imports core memory blocks and message history.
• Pricing: $1.00 per 1M tokens processed, plus $5 per additional workspace. The free tier includes 1M tokens and 1 workspace, and Enterprise adds SSO, SLAs, a dedicated support engineer, and BYOC.
• Pros: Apache-2.0 license; graph and vector storage in a single engine; MCP server for Cursor, Claude Code, and Cline; native integrations with LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, and MCP-compatible runtimes; RDF/OWL ontology validation that stamps each extracted node with a validation flag.
• Cons: gets the most value when teams invest a little time in graph schema or ontology design, and exposes a richer feature surface than a drop-in key-value memory layer, a trade for far more precise recall and auditability.

Cognee has become the standard landing spot for teams migrating from Letta because the LettaSource adapter preserves core memory blocks and message history inside the COGX format, so agents keep their accumulated state while gaining graph-structured recall, ontology validation, and the same four-verb API across SDK, HTTP, and MCP. With more than 70 organizations running Cognee in production and a free tier that mirrors Letta's self-serve ergonomics, replacing a Letta deployment is typically a configuration exercise rather than a rewrite. Full migration steps and the LettaSource reference live in the Cognee migration guide.

Letta

Letta is the evolution of MemGPT, built around a stateful server, client SDK, and (until recently) a cloud offering for long-running agents with persistent memory. Its signature design is a three-tier hierarchy where core memory holds immediately relevant context, archival memory is a larger vector-backed store, and recall memory tracks conversation history. The agent itself decides what to move between core and archival through tool calls, which is the original MemGPT mechanism. In March 2026, Letta deprecated Letta Cloud and the Agent Development Environment, so new deployments are self-hosted only going forward.

• Key Features: three-tier core/archival/recall memory hierarchy; automatic context overflow handling; nine agent types; MCP client support over SSE, stdio, and Streamable HTTP; 15+ LLM providers; built-in PostgreSQL and SQLite persistence.
• Memory Offerings: MemGPT-style self-managed memory where the agent decides what moves between core and archival tiers; stateful server plus client SDK architecture.
• Pricing: Apache 2.0 open source; Letta Cloud and ADE deprecated in March 2026, leaving self-hosting as the supported path.
• Pros: canonical MemGPT implementation; mature agent runtime; broad model provider coverage.
• Cons: Cloud and ADE discontinued; context-window-centric design; agent-managed memory relies on tool-call orchestration rather than a dedicated retrieval layer.

Zep

Zep is a managed memory service for conversational agents built around a temporal knowledge graph. It extends the open-source Graphiti engine, tagging every extracted fact with valid_at and invalid_at timestamps so agents can reason about when something was true, not just whether it appeared in history. In the LongMemEval benchmark for temporal retrieval, Zep scores 63.8%, compared with 49.0% for Mem0. Teams that need per-user conversational memory with explicit time-travel semantics tend to shortlist Zep alongside Letta when Letta's tiered memory does not capture enough history.

• Key Features: temporal knowledge graph with valid_at / invalid_at timestamps; built on the open-source Graphiti framework, which combines semantic embeddings, BM25 keyword search, and graph traversal without LLM inference at query time; 63.8% LongMemEval temporal retrieval score.
• Memory Offerings: per-user conversational memory, temporal fact reasoning over nodes with start and end validity windows, and both cloud and self-hosted deployment paths.
• Pricing: Flex at $125/month, Flex Plus at $375/month, Enterprise custom.
• Pros: strong temporal reasoning out of the box; SOC 2 Type II and HIPAA BAA available on the Enterprise tier.
• Cons: compliance certifications are gated to Enterprise; entry pricing is higher than usage-based alternatives such as Cognee Cloud.

Mem0

Mem0 is a lightweight memory layer for LLM applications that focuses on simple per-user conversational recall. It exposes a small, drop-in API with add, search, update, and delete operations scoped to user, agent, or session, backed by vector storage with optional Neo4j graph integration for teams that want relationship-aware retrieval. The project is Apache-2.0 licensed and also ships a managed platform, which makes it a reasonable fit for developers who want chat memory without standing up a full knowledge graph pipeline or committing to a heavier framework.

• Key Features: add, search, update, and delete operations across user, agent, and session scopes; vector storage with optional Neo4j graph integration.
• Memory Offerings: per-user conversational memory for apps with a simple scoping model.
• Pricing: Apache-2.0 open source; managed tiers Free, Starter $19/mo, and Pro $249/mo.
• Pros: lightweight drop-in API and permissive license; easy to adopt in existing chat apps.
• Cons: graph layer is optional and requires Neo4j; lower temporal retrieval scores than Zep (49.0% vs. 63.8% on LongMemEval).

Graphiti

Graphiti is the open-source temporal knowledge graph engine developed by the team behind Zep. It targets developers who want the underlying bi-temporal memory model that powers Zep's managed service, but prefer to run the graph themselves rather than depend on a hosted platform. Facts are stored as nodes with explicit start and end validity windows, and queries combine semantic embeddings, BM25 keyword search, and graph traversal. Because retrieval does not require LLM inference at query time, latency and cost per lookup stay low, which suits agent loops that hit memory on every turn.

• Key features: Temporal knowledge graph with per-fact start and end validity windows; hybrid retrieval across semantic embeddings, BM25 keyword search, and graph traversal; no LLM inference required at query time.
• Memory offerings: Self-hosted bi-temporal graph intended for agent memory, with facts versioned over time rather than overwritten.
• Pricing: Open source.
• Pros: Fast queries without an LLM-at-query-time tax; strong temporal model for facts that change or expire.
• Cons: Framework rather than a full platform, so ingestion pipelines, auth, multi-tenancy, and operations are left to the implementing team.

LangMem

LangMem is LangChain's MIT-licensed Python library that plugs into LangGraph's long-term memory store. It gives agent developers a set of tools for extracting facts from conversations and writing or updating memory entries inside an existing LangGraph runtime, rather than running as a separate memory server. There is no managed cloud offering; teams install the library, wire it into their graph nodes, and persist memories through whichever store LangGraph is configured to use. For projects already standardized on LangChain and LangGraph, LangMem is the lowest-friction way to add long-term memory without introducing a new service.

• Key Features: tools for extracting and updating memories inside LangGraph; MIT license.
• Memory Offerings: long-term memory inside an existing LangGraph stack.
• Pricing: free, open source; no managed service.
• Pros: lowest friction for teams already on LangGraph; permissive license.
• Cons: no managed service; tied to the LangGraph runtime.

Supermemory

Supermemory positions itself as an MCP-native memory layer for personal assistants and coding agents, pairing a per-user memory graph with a document retrieval system it calls SuperRAG. The project is MIT-licensed and ships a remote MCP server with OAuth, so IDE and chat clients can connect without hand-rolled auth plumbing. Plugins exist for Claude Code, Codex, Cursor, and OpenCode, which makes it a natural fit for developers who want a single memory backend following them across coding tools and conversational assistants rather than a shared team knowledge platform.

• Key Features: per-user memory graph combined with SuperRAG document retrieval; remote MCP server secured with OAuth; first-party plugins for Claude Code, Codex, Cursor, and OpenCode.
• Memory Offerings: personal assistant and coding-agent memory that blends ingested documents with ongoing conversation history on a per-user basis.
• Pricing: Free tier, Pro at $19/mo, Scale at $399/mo, and custom Enterprise pricing.
• Pros: MIT-licensed source, MCP-native from the start, and strong out-of-the-box integrations with popular coding IDEs and agent clients.
• Cons: oriented toward individual and coding workflows, so teams needing multi-tenant roles, shared datasets, or a central knowledge platform will find it less of a direct fit.

Glean

Glean is a packaged enterprise SaaS assistant that connects to SaaS data sources (Slack, Google Workspace, Jira, Confluence, Salesforce) and surfaces answers through a polished search and chat UI. It targets internal knowledge discovery for employees rather than developers wiring stateful memory into custom agents. There is no open agent memory API, no self-hosted graph store to configure, and no SDK-first workflow comparable to Letta or Cognee. Teams evaluating Letta alternatives usually only land on Glean when the real need is enterprise search, not programmable per-agent memory.

• Key Features: enterprise search and assistant UI across connected SaaS systems; packaged SaaS delivery.
• Memory Offerings: enterprise knowledge assistant that indexes SaaS data sources; not a developer-facing agent memory API.
• Pricing: per-seat SaaS; public pricing is not published.
• Pros: mature assistant UI; enterprise-ready connectors and administration.
• Cons: closed source; per-seat pricing rather than usage-based; not an open agent memory API, so it does not replace Letta for building stateful agents.

Evaluation framework for Letta alternatives

Teams replacing Letta should weight their evaluation around how memory is modeled, where it runs, and how cleanly existing agents move over. Cognee is a useful reference point because it scores across every category: a unified graph-plus-vector architecture with 20 search types, an on-premises Apache-licensed deployment that can run on a single Postgres with pgvector and the embedded Ladybug graph engine, the same four-verb API (remember, recall, forget, improve) across Python SDK, HTTP, and MCP, a LettaSource adapter that reads Agent Files (.af) through the COGX exchange format, usage-based pricing at $1.00 per 1M tokens, and RDF/OWL ontology validation for governance.

• Memory model fit (graph vs vector vs temporal KG vs tiered), 25%
• Deployment and licensing (self-host, cloud, OSS license), 20%
• Integration surface (SDK, HTTP, MCP, agent runtimes), 15%
• Migration path from Letta (adapters, exchange formats), 15%
• Pricing predictability (usage vs seat vs flat), 15%
• Governance (ontology, validation, compliance), 10%

Why Cognee is the best Letta alternative for stateful agent memory

For teams leaving Letta, Cognee offers the clearest path forward. Migration is documented through the COGX exchange format and a LettaSource adapter that reads Letta Agent Files (.af), preserving core memory blocks and message history. The runtime unifies graph edges and vector embeddings in one store, exposing 20 search types that span classic RAG and chain-of-thought graph traversal. The same four-verb API, remember, recall, forget, improve, works across the Python SDK, HTTP, and MCP. Apache-2.0 self-hosting pairs with usage-based cloud at $1.00 per 1M tokens processed, plus $5 per additional workspace, with Enterprise adding SSO, SLAs, and BYOC. Cognee runs in production at Bayer, the University of Wyoming, and Knowunity, with 32k+ GitHub stars and 5M+ SDK runs per month.

Related guides

• Migrating from Letta to Cognee
• Best Mem0 Alternatives in 2026
• Best Zep Alternatives in 2026
• Best Supermemory Alternatives in 2026
• AI Agent Memory: What It Is and How It Works

Frequently Asked Questions

Why do developers look for Letta alternatives?+

Letta deprecated Letta Cloud and the Agent Development Environment in March 2026, which left teams relying on Letta's memory APIs searching for a maintained home for agent memory beyond a context-window-centric design. Developers want options that offer both managed and self-hosted paths, longer-lived state, and richer retrieval than tiered context swapping. Cognee is a graph-native memory control plane for LLM agents built on an ECL (Extract, Cognify, Load) pipeline that turns raw data into queryable knowledge graphs, and it ships a documented migration path through the COGX exchange format and a LettaSource adapter that reads Letta Agent Files (.af), including core memory blocks and message history.

What is the best open-source alternative to Letta for stateful agent memory?+

Cognee is the leading Apache-2.0 open-source alternative to Letta for stateful agent memory. It unifies graph edges for relational traversal with vector embeddings for semantic similarity in a single architecture, exposing 14 distinct retrieval modes that range from classic RAG to chain-of-thought graph traversal. A compact four-verb API (remember, recall, forget, improve) stays identical across the Python SDK, HTTP API, and MCP server, so swapping transports does not change agent code. Adoption signals back the project: 32k+ GitHub stars, over one million pipelines processed monthly, and 70+ production deployments including Bayer, the University of Wyoming, and Knowunity.

Can I migrate Letta memory blocks and agent files into Cognee?+

Yes. Cognee ships a migration path built on the COGX exchange format, a neutral schema for moving stateful agent memory between systems. A LettaSource adapter reads Letta Agent Files (.af) and imports core memory blocks along with full message history into a Cognee dataset, where they become nodes and time-stamped facts in the knowledge graph. The same COGX pipeline covers Mem0, Zep, Graphiti, and LangMem through dedicated source adapters, so teams consolidating several memory backends can route everything through one import flow rather than writing bespoke ETL for each tool.

Which Letta alternative supports MCP clients like Claude Code and Cursor?+

Cognee ships a standalone MCP server that exposes graph-structured persistent memory to Cursor, Claude Code, Cline, and any other MCP-compatible client, so coding agents can read and write to the same knowledge graph a human developer queries through the SDK. The four-verb API (remember, recall, forget, improve) is identical across the Python SDK, HTTP API, and MCP, which means the behavior an agent gets inside Cursor matches what a backend service calls over REST. Supermemory also offers a remote MCP server with OAuth and plugins for Claude Code, Codex, and Cursor for teams that prefer a hosted-only option.

How much does Cognee cost compared to Letta Cloud?+

Cognee Cloud uses a usage-based model: $1.00 per 1M tokens processed, plus $5 per additional workspace. The free tier includes 1M tokens and 1 workspace, which is enough for prototyping a stateful agent before any spend. Enterprise adds SSO, SLAs, a dedicated support engineer, and BYOC for teams that need to run inside their own cloud account. A direct comparison with Letta Cloud is no longer meaningful because Letta deprecated Letta Cloud and its Agent Development Environment in March 2026, so Cognee Cloud or self-hosted Cognee are the practical options.

Does Cognee support self-hosting and air-gapped deployment like Letta?+

Yes. Cognee ships as an Apache-licensed package that can run entirely on-premises, which covers the same restricted-infrastructure scenarios that drive teams to self-host Letta. The full engine runs on a single Postgres instance using pgvector for vector storage and the embedded Ladybug graph engine for graph storage, so no external managed services or outbound network calls are required. That single-node footprint keeps air-gapped and regulated deployments straightforward, while leaving room to swap in Neo4j, Kuzu, Amazon Neptune, or LanceDB later if a workload outgrows the default stack.