Letta Alternatives in 2026: 7 AI Agent Memory Tools Compared

Membase Team · Last updated: November 2026

Disclosure: Membase is our product. We list it first because it’s the alternative we know best, and we say plainly where Letta or another tool is the better fit. Facts were checked on each vendor’s docs, pricing page and GitHub repository in November 2026.

Letta (formerly MemGPT) builds stateful agents that manage their own memory. In 2026 it changed shape: the open-source Letta V1 API server is retired, and Letta is now an agent harness (CLI, web app and a TypeScript Agent SDK) where each agent keeps its memory in a git-backed file system called MemFS.

Teams look for an alternative when they want a memory layer, not a whole agent runtime: memory their own agents and tools call, in the language and framework they already use.

The alternatives:

1. Membase: one memory your agents and AI tools share, with access per app. Free in beta.

2. Mem0: the most widely used memory API, with per-user scoping.

3. Zep / Graphiti: a temporal knowledge graph that tracks how facts change.

4. Supermemory: a managed memory graph with many built-in connectors.

5. Cognee: open-source graph memory built from documents.

6. Hindsight: an MIT-licensed memory engine you can self-host for free.

7. LangMem: memory tools for agents built on LangGraph.

Stay on Letta if you want agents that own their memory and improve themselves, with a ready harness for coding, chat and messaging channels.

Why teams look for a Letta alternative

1. The V1 API server is retired. Letta’s original repository now points to letta-ai/letta-code, and its README says the retired V1 API server lives on an archive branch. Self-hosting today means running the Node-based Letta harness and App Server. (Letta on GitHub)

2. You adopt an agent harness, not a memory API. In Letta, memory belongs to the agent: it lives in the agent’s MemFS repository, and the agent reads and edits it with file tools. That’s powerful if you’re building on Letta, and a lot to adopt if you only need memory for agents you already have. (MemFS)

3. The Agent SDK is JavaScript and TypeScript. Letta’s Agent SDK targets JavaScript or TypeScript projects; running the runtime yourself needs Node.js 22.19 or later. (Agent SDK)

4. Usage-based cost is hard to predict. Free and Pro ($20 a month) include limited Letta Auto quota, then pay-as-you-go credits. Letta’s own guidance says casual coding users typically spend about $100 a month or more, and power users $200 or more. The API plan is $20 a month plus $0.10 per active agent and tool execution time. (Letta pricing)

5. Shared memory is cloud-only. Shared memory repositories, which let several agents work from the same files, are hosted in Letta Cloud. The older shared memory blocks are a legacy API. (Shared memory)

1. Membase: one memory for your agents and AI tools

Membase, built by Unibase, is the memory layer for AI agents. Instead of living inside one agent, memory lives in your Membase account, and everything you connect reads it: your own agents through the Python or TypeScript SDK or REST, and Claude Code, Cursor, Codex, ChatGPT, Claude and Grok through MCP.

from membase import Membase

m = Membase()  # reads MEMBASE_API_KEY
m.add("Acme requires SSO via Okta before the pilot.", container="mv-...")
m.search("what does Acme need before the pilot?")

Pick it over Letta when:

• you want memory for agents you already have, in any framework, not a new agent harness;

• your coding tools and chat apps should share the same memory as your code;

• each agent should get its own key with a level (Read, Read & write, Full) and a reach (which Memories), enforced on the server;

• you want a Python SDK as well as TypeScript.

Watch out for:

• Membase doesn’t run your agents or let them rewrite their own prompts and skills; it’s memory only.

• Learning happens when a Memory runs, so a new write isn’t searchable instantly.

• It’s in beta: expect API changes, and no compliance certifications are published yet.

Pricing: Free in beta · Paid plans coming soon.

2. Mem0: the default memory API for multi-tenant apps

Mem0 extracts facts from conversations and scopes them by user_id, agent_id and run_id. On Mem0 Platform, newer facts supersede older ones and memories are linked by shared entities.

• Pick it over Letta when: you need per-user memory behind one API key in a SaaS app, with Python and TypeScript SDKs and an Apache 2.0 library you can self-host.

• Watch out for: request quotas (the free Hobby plan has 10,000 adds and 1,000 retrievals a month; Starter is $19, Pro $249).

3. Zep and Graphiti: memory that tracks change

Zep builds a temporal knowledge graph that records when each fact became true and when it stopped being true. Its engine, Graphiti, is open source under Apache 2.0.

• Pick it over Letta when: you need fact history over time, or context from business data joined with chat history.

• Watch out for: Zep Cloud bills credits per byte ingested (Flex is $125 a month); self-hosting means running Graphiti with a graph database. SOC 2 and a HIPAA BAA are on Zep’s Enterprise plan.

Full comparison: Mem0 vs Zep vs Membase

4. Supermemory: managed memory graph with connectors

Supermemory builds a memory graph where new facts update or extend old ones, temporary facts expire, and each user gets a profile.

• Pick it over Letta when: you want memory filled from Google Drive, Notion, OneDrive, Gmail or GitHub, plus plugins for coding agents.

• Watch out for: usage draws on monthly credits (Pro is $19 a month), and connectors are tiered by plan. Its self-hosted binary is free up to 10,000 documents and isn’t open source.

Full comparison: Membase vs Supermemory

5. Cognee: graph memory from documents

Cognee turns documents and conversations into a knowledge graph plus vectors, with open-source pipelines under Apache 2.0.

• Pick it over Letta when: most of your agent’s memory comes from documents, and you want it open source with a simple cloud price (free for 1M tokens, then $1 per 1M tokens).

• Watch out for: it’s better suited to knowledge bases than to an agent’s personal working memory.

6. Hindsight: free, open-source memory engine

Hindsight, from Vectorize, extracts facts, entities and time data from what your agent sees, then runs four retrieval strategies in parallel and reranks the results.

• Pick it over Letta when: you want a free, MIT-licensed memory engine to self-host, with no agent framework attached.

• Watch out for: you operate it yourself unless you use its usage-based cloud.

7. LangMem: memory inside LangGraph

LangMem gives agents tools to save and search memories, works natively with LangGraph’s long-term memory store, and can refine an agent’s prompt from its interactions.

• Pick it over Letta when: your agents already run on LangGraph and you want memory in the same stack, MIT-licensed.

• Watch out for: you choose and run the store, and access control is up to your code.

How to choose

• Memory for agents you already have, shared with Claude Code, Cursor and ChatGPT: Membase

• Each agent with its own scoped key, some read-only: Membase

• Per-user memory in a multi-tenant app: Mem0

• Facts whose history matters: Zep or Graphiti

• Memory filled from Gmail, Drive or GitHub: Supermemory

• Memory built mostly from documents: Cognee

• Free, open-source engine to self-host: Hindsight, Graphiti, Cognee or Mem0’s library

• Already on LangGraph: LangMem

• Agents that own their memory and improve themselves, with a ready harness: stay on Letta

Moving from Letta to Membase

1. Export what your agent knows. In MemFS, memory is Markdown files in the agent’s repository; in the legacy API, it’s memory blocks.

2. Choose your Memories. Map each agent or topic to a Membase Memory, such as Project decisions or Customer Acme.

3. Import. Add each file or block with add, using its path or ID as custom_id, so a re-run never creates duplicates.

4. Wait for learning. Check each document’s learned flag before your agents depend on it.

5. Connect. Point your agents’ SDK calls and your MCP clients at Membase, and compare answers on your own test questions before switching over.

Get started: Open Membase · Docs · GitHub · Discord