6 Best LangMem Alternatives for LangGraph and Multi-Framework Agent Memory in 2026

The best LangMem alternative for teams that want long-term memory their LangGraph agents can share with agents built in any other framework is Caura. It connects over MCP or REST, handles conflicting facts, and records which agent wrote what. That choice matters now because LangMem “has not shipped a PyPI release since version 0.0.30 in October 2025, and a LangGraph upgrade has already broken one of its modules.” Mem0, Hindsight, Zep, Letta and Cognee each fit a narrower reason for leaving, covered below.

LangMem alternatives covered:

• Caura: framework-agnostic governed memory for LangGraph and every other agent in the fleet.
• Mem0: a fast, drop-in memory API for per-user personalization.
• Hindsight: an MIT memory engine with a first-party LangGraph integration.
• Zep: a temporal knowledge graph for facts that change.
• Letta: a stateful runtime where agents edit their own memory.
• Cognee: a knowledge graph built from documents and code.

Why do teams choose LangMem in the first place?

LangMem is the memory toolkit from the LangChain team, and it fits LangGraph with almost no glue. Memories live in LangGraph’s BaseStore, the same store LangGraph Platform deploys by default. Two helper functions, create_manage_memory_tool and create_search_memory_tool, give an agent tools to write and search memory “in the hot path” while it works. A background memory manager extracts, consolidates, and updates knowledge after a conversation. And LangMem does something few memory layers attempt: procedural memory, where it refines the agent’s own prompt from feedback.

It is MIT licensed, free, and needs no external service. For a Python team already on LangGraph, that is the lowest-friction way to add memory.

The reasons teams search for LangMem alternatives are mostly about what happened after launch.

Why are LangMem users looking for alternatives?

Five problems show up in LangMem’s release history, issue tracker, and published benchmarks.

1. No release since October 2025

Every other memory library in this space shipped dozens of releases in 2026. LangMem shipped none.

“LangMem’s last PyPI release is 0.0.30, published on 27 October 2025. The repository has 153 commits in total and 51 open issues as of 30 September 2026, and the version number has never left 0.0.x.”

2. LangGraph upgrades can break it

LangMem depends on LangGraph internals. In issue #104, “LangGraph 0.6.0 removed the CONFIG_KEY_STORE constant that LangMem’s reflection.py imports, and the reporter could not tell how the new configuration should be wired.” With no release since, teams on current LangGraph either pin old versions or patch LangMem themselves.

3. Memory search is slow at the tail

“The Mem0 paper benchmarked LangMem on LoCoMo and reported a p95 search latency of 59.82 seconds, against 0.200 seconds for Mem0 and 0.778 seconds for Zep.” A memory lookup that takes a minute at p95 cannot sit in front of a user-facing reply.

4. Open bugs in core paths

Two open issues touch everyday use. In issue #98, “summarization duplicates tool messages that follow an AI tool call, which then fails provider validation because tool messages must answer a preceding tool call.” In issue #55, create_memory_store_manager “raises an attribute error when used with Postgres, the store most production deployments choose.”

5. Memory stays inside LangGraph

“LangMem stores memory as namespaced items in LangGraph’s store. That is an advantage while everything runs in LangGraph and a wall when it does not.” A CrewAI crew, an OpenAI Agents SDK service, or a Claude Code session cannot read or write the same memory without custom code, and LangMem has no concept of which agent wrote a fact, what it may read, or what to do when two agents disagree.

What do LangMem alternatives roundups leave out?

We searched for pages ranking for “LangMem alternatives”. Only two dedicated roundups rank, together 10,058 words, and both are written by memory vendors whose own product is the first recommendation. There is no independent comparison for a maintained, free, MIT tool used by a large LangGraph community, which is why this guide is built from LangMem’s release history and issue tracker instead.

The question those pages do not answer is the one most LangGraph teams reach eventually: what happens when agents outside LangGraph need the same memory. LangMem’s store cannot serve them, and the answer decides which alternative fits.

Where is LangMem actually strong, and what fully replaces it there?

LangMem does four jobs. Only some of them need replacing.

Procedural memory and prompt optimization

No memory layer on this list rewrites your agent’s system prompt from feedback the way LangMem’s optimizer does. If you use that feature, keep it, pinned to a version that works with your LangGraph, and move only long-term memory elsewhere.

LangGraph-native storage

If all you use is the store, LangGraph’s own BaseStore with semantic search works without LangMem at all. You lose the helper tools and background manager and keep native integration.

Hot-path tools and background consolidation

These are the parts worth replacing with something maintained. Letta covers agent-edited memory as a full runtime. Caura covers both halves as a service: agents can write through tools during a task, and its Interviewer writes memories from transcripts on a schedule, which does the background manager’s job without a LangGraph dependency.

How do the best LangMem alternatives compare?

The table scores each of the six LangMem alternatives on the reasons teams leave.

1. Caura: one memory for LangGraph and every other agent

Repository: github.com/caura-ai/caura

Caura is the LangMem alternative for teams whose LangGraph agents are not the only agents they run. It connects to LangChain, LlamaIndex, CrewAI, AutoGen and the OpenAI Agents SDK, and to Claude Code or Cursor over MCP, as listed on its MCP server page. A fact your LangGraph research agent learns is recallable by the CrewAI crew and the coding agent, under rules you set.

How Caura answers each reason teams leave LangMem

Active maintenance. As of 30 September 2026, the repository shows 1,472 commits. The open-source release runs on PostgreSQL with pgvector and Redis, so there is no dependency on LangGraph internals to break.

Fast recall. In Caura’s separate warm, single-tenant benchmark, search ran at 23 ms p50 and 27 ms p95, fast enough to run before every model call.

Capture the model cannot skip. LangMem’s hot-path tools rely on the model deciding to save. Caura adds deterministic capture, where recall runs before each turn and commit after it as code, and scheduled reflection through the Interviewer. Caura’s 12 September 2026 Interviewer write-up reports a read-only analysis of an eToro deployment snapshot dated 25 August 2026, where the Interviewer recovered 48% of decisions and 66% of preferences. Caura’s deterministic memory write-up compares what LangGraph, Mem0, Zep and Letta each ship for this.

Shared memory with rules. Each agent has a trust level checked on every call, keystones deliver mandatory policies at session start, and every write is audit-logged. Contradiction detection supersedes stale facts instead of storing both.

Pricing. Every plan, including Free, allows unlimited agents. As of 30 September 2026, Pro is $49 a month on the pricing page.

Caura benchmark results and production proof

Caura scores 92.2% on LongMemEval, 461 of 500 questions under the GPT-4o reference judge, with a 22.4k-token median context. The evaluation code is public in caura-longmemeval. eToro’s Company Brain runs 300+ agents on Caura with 26,500+ memories and 1,372 shared skills.

Where Caura is weaker: it does not optimize prompts from feedback, and it is an external service where LangMem runs in-process. Its community is small.

Best for: LangGraph teams that also run agents in other frameworks, or that need memory shared under permissions and audit.

2. Mem0: fast drop-in personalization

Repository: github.com/mem0ai/mem0

Mem0 is the quickest swap if LangMem’s latency is the problem: add() after a turn and search() before the next, with p95 search around 0.2 seconds in its own paper. It works from any framework. Its v3 algorithm keeps both versions of a changed fact for your code to resolve, as users describe in issue #4956, and as of 30 September 2026, graph memory is on the $249 Pro plan.

Best for: single-agent LangGraph apps that need faster, maintained personalization.

3. Hindsight: MIT memory with a LangGraph integration

Repository: github.com/vectorize-io/hindsight

Hindsight ships a LangGraph and LangChain integration that binds memory tools into a LangGraph agent, which makes it the closest match to LangMem’s developer experience. It runs as one Docker container with embedded Postgres, combines four retrieval strategies, and its reflect operation builds observations and mental models, a relative of LangMem’s background manager. Its PyPI package reached v0.10.2 on 29 September 2026.

Best for: LangGraph teams that want a maintained, self-hosted replacement with a similar tool-based pattern.

4. Zep: temporal memory for changing facts

Repository: github.com/getzep/graphiti

Zep stores facts as edges with validity windows in its Graphiti engine, so it knows a user’s plan was Starter until June and Pro after. LangMem namespaces have no time model. As of 30 September 2026, Zep Cloud bills by bytes written with retrieval unmetered, and self-hosting means running Graphiti with a graph database, covered in our Zep alternatives guide.

Best for: agents where “what was true then” matters as much as “what is true now”.

5. Letta: agent-edited memory in its own runtime

Repository: github.com/letta-ai/letta

Letta takes LangMem’s hot-path idea to its conclusion: agents rewrite their own memory blocks through built-in tools, and sleep-time agents consolidate between sessions. The cost is leaving LangGraph for Letta’s runtime, which itself moved to the TypeScript Letta Code in August 2026. Our Letta alternatives guide covers that shift.

Best for: teams willing to change runtime to get self-editing memory as the core design.

6. Cognee: graph memory from documents

Repository: github.com/topoteretes/cognee

If your LangMem store mostly held facts pulled from documents, Cognee builds a proper knowledge graph from them through remember and recall, and integrates with any framework. Conflict resolution and provenance are listed on its Enterprise plan, covered in our Cognee alternatives guide.

Best for: LangGraph agents that answer from a corpus of documents and code.

How to choose the right LangMem alternative

Four key questions

Start by identifying why you’re leaving LangMem, then address these questions:

Will every agent stay in LangGraph? If yes, LangGraph’s store plus Hindsight keeps you closest. If agents live elsewhere, choose a framework-agnostic option like Caura or Mem0 before memory fragments.

Is recall on the critical path? Test p95 latency on your data. LangMem’s published tail was approximately one minute.

Should the model decide what gets saved? LangMem and Letta let models decide. Mem0 and Zep let code decide. Caura supports both approaches plus scheduled reflection.

Do you use the prompt optimizer? If yes, keep that feature and migrate only storage. No alternative replaces it.

Which LangMem alternative should you pick?

Choose Caura if your LangGraph agents collaborate with other frameworks, need fast recall for every turn, or require permissions and audit trails. It’s the only option combining framework-agnostic access, code-driven capture, and per-agent governance—running in production at 300+ agents.

Select Mem0 for fastest integration, Hindsight for closest LangGraph experience under MIT, Zep for evolving facts, Letta for self-editing memory as runtime, and Cognee for document graphs.

Test quickly: connect your LangGraph agent to Caura’s free tier alongside another framework agent. Write a fact from one agent, recall it from the other. If both answer consistently, your memory is framework-independent.

Frequently Asked Questions

Is LangMem still maintained?

LangMem’s last PyPI release was version 0.0.30 from October 27, 2025. It shipped no releases in 2026. While occasional commits continue and 51 issues remain open, teams using current LangGraph versions should verify compatibility first.

Does LangMem work with LangGraph 0.6?

Not without issues. LangGraph 0.6.0 removed the CONFIG_KEY_STORE constant that LangMem’s reflection module requires, per issue #104. Either pin compatible versions or manually patch the import.

Why is LangMem search slow?

The Mem0 paper measured LangMem’s p95 search latency at approximately 60 seconds versus 0.2 seconds for Mem0. Hot-path tools add model round trips to every save. Test on your own data for accurate results.

Can I use LangMem without LangGraph?

LangMem’s core functions work with any storage, but tools, background manager and store integration target LangGraph specifically. Non-LangGraph agents cannot share a LangMem store without custom code. Framework-agnostic alternatives like Caura, Mem0, and Hindsight solve this.

What is the best LangMem alternative for LangGraph?

For agents sharing memory across frameworks: Caura. For LangGraph-native MIT experience: Hindsight. For fast single-agent integration: Mem0.

How do I migrate from LangMem?

Read items from your LangGraph store by namespace, map each namespace to users, agents, or fleets in the new system, and batch-write records. Run both stores in parallel during one release while reading from the new system before switching over.

Related reading: What Is Agent Fleet Memory? · How Agents Share Knowledge · Deterministic Memory