6 LangMem Alternatives for LangGraph and Multi-Framework Memory We Evaluated in 2026

Among the six products reviewed, Caura is our preferred fit for teams that want long-term memory their LangGraph agents can share with agents built in other frameworks. 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.” This is a historical, competitor-authored benchmark that Caura did not reproduce; if it reproduces in your environment, that latency would be unsuitable for latency-sensitive request paths.

4. Open issue reports touch core paths

Two open issues touch everyday use. In issue #98, the reporter says 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 reportedly raises an attribute error when used with Postgres. Caura did not independently reproduce either report; check the linked issues for current status.

5. Memory stays inside LangGraph

LangMem stores memory as namespaced items in LangGraph’s store. That is an advantage while everything runs in LangGraph. A CrewAI crew, an OpenAI Agents SDK service, or a Claude Code session would need custom integration to read or write the same store. In the public materials reviewed, we did not find native provenance, per-agent access controls, or cross-agent conflict resolution documented for LangMem.

What do LangMem alternatives roundups leave out?

In a dated, logged-out search for “LangMem alternatives”, we found two dedicated roundups rank, together 10,058 words, and both are written by memory vendors whose own product is the first recommendation. Search results vary by time and location, so this guide relies on LangMem’s release history and issue tracker rather than treating those roundups as independent verification.

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. Serving them requires an integration outside LangMem’s documented LangGraph workflow, 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 these 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.

Retrieval for every turn. Caura can run recall before every model call; latency claims remain unpublished until their raw benchmark artifact and current configuration are available.

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 answered 461 of 500 LongMemEval_S questions correctly (92.2%) under the benchmark's GPT-4o reference judge. On LongMemEval_S, the median compact retrieved context was 22,410 tokens versus a 107,706-token full haystack: 79.2% context-only savings; counting every reader call yields 75.4%. The evaluation code is public in caura-longmemeval. eToro’s Company Brain is Caura’s published production-fleet case study.

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. In our review, Caura was the only listed product for which we found public documentation combining framework-agnostic access, code-driven capture, and per-agent governance for production fleets.

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?

A historical Mem0 paper measured LangMem’s p95 search latency at approximately 60 seconds versus 0.2 seconds for Mem0. Caura did not reproduce that competitor-authored benchmark. Test the current versions on your own data before drawing performance conclusions.

Can I use LangMem without LangGraph?

LangMem’s core functions work with any storage, but its documented tools, background manager and store integration target LangGraph specifically. Non-LangGraph agents need custom integration to share the same store. Framework-agnostic alternatives like Caura, Mem0, and Hindsight address this use case.

What is the best LangMem alternative for LangGraph?

Among the products reviewed, our preferred option for agents sharing memory across frameworks is Caura. Consider Hindsight for a LangGraph-native MIT option and Mem0 for single-agent integration.

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