Open-Source Memory Layers for AI Agents: The Complete 2026 Comparison

The honest definition - what is an "AI agent memory layer"?

A memory layer for AI agents is an external system that gives a stateless LLM three capabilities it does not have by default:

1. 01 Persistence - facts survive between sessions.
2. 02 Retrieval - relevant facts can be surfaced when needed.
3. 03 Update - new facts override or complement old ones (not just append).

Most memory layers achieve persistence with a vector database, retrieval with similarity search, and update with one of several conflict-resolution strategies. The differences below are in the architecture of each of these three layers.

Comparison table - six major open-source memory layers, 2026

Benchmark scores from each vendor’s published papers. The Zep-Mem0 LOCOMO dispute is unresolved; LongMemEval scores are more widely accepted. (Atlan)

Deep dive - when to pick which

Mem0 - broad ecosystem compatibility, managed infrastructure

Mem0's architecture is vector-first with optional graph enhancement. It integrates natively with CrewAI, LangGraph, LangChain, LlamaIndex, and Vercel AI SDK. The MCP server makes it work with Claude Code and similar agentic hosts. AWS chose Mem0 as the exclusive memory provider for its Agent SDK. (Mem0)

Where it breaks: the absence of a temporal model. Mem0 stores and retrieves facts; it does not model time-bounded validity. For agents that need to reason about how things changed over time ("what did the user prefer last month?"), this is a meaningful gap. (Atlan)

Zep / Graphiti - reasoning about change over time

Zep’s killer feature is the temporal knowledge graph. Every fact has a validity window: when it became true, when it stopped being true. The shipping-address update example is the canonical case. Vector-first systems retrieve the old address because it is semantically close; Zep marks the old fact invalid with a timestamp and surfaces only the current one.

Zep’s v3 rebrand to "context engineering platform" - citing Karpathy and Tobi Lutke as endorsers - signals where the market is heading. (Atlan)

Where it breaks: Graphiti (the OSS engine) is "not plug-and-play. You’d need significant effort to build a functional solution around it." (Medium - Calvin Ku) And the full Zep platform is cloud-only - no on-premise. Pricing is credit-based and confusing.

Letta (formerly MemGPT) - long-running agents that manage their own memory

Letta’s architecture mirrors an operating system. Agents have core memory (always in context), recall memory (recently accessed), and archival memory (long-term storage). The LLM itself edits its memory blocks via dedicated tools. This matches Karpathy’s CPU/RAM mental model directly.

Where it breaks: Letta is the most opinionated of the six. You are buying a runtime, not just a memory library. "Letta comes with its own agent runtime." (Mem0 Blog) Teams that already picked LangGraph or CrewAI will find the switching cost steep.

Cognee - local-first, privacy-critical, graph-first

Cognee ships a semantic graph built on raw documents. Its Dreamify tuning tool is the key differentiator - it lets you tune the memory system against your specific data without re-training. Cognee is the answer for EU customers, healthcare, and any shop with strict data-sovereignty requirements.

Supermemory - coding agents (Claude Code, Cursor, OpenCode)

Supermemory’s MCP integrations are its primary differentiator. It hits state-of-the-art on LongMemEval (71.43% multi-session, 76.69% temporal), and its architecture is optimized for the coding-agent use case. (Supermemory Research)

LangMem - already all-in on LangGraph

LangMem is a library, not a service. `pip install langmem`, done. No API keys, no subscriptions. It plugs directly into LangGraph’s storage layer and works with `createreactagent` out of the box.

Where it breaks: if you are not on LangGraph, LangMem is the wrong choice.

What all six have in common - and what’s still missing

Every memory layer above solves the same problem: reactive retrieval. The agent asks, the memory answers. This is a huge step forward from stateless LLMs. It is also structurally incomplete.

None of these tools proactively surface change. If a customer’s engagement is cooling, if a commitment is slipping, if a champion has changed roles - the memory layer holds that data, but the agent has to think to ask for it. The agent does not think to ask for it, because the agent is not designed to continuously watch for organizational drift.

For why vector-only approaches fall short before reaching this layer, see Why Vector Databases Are Not Enough for AI Agents in 2026. For the harness layer above memory, see the Harness Engineering discipline post.

The benchmark-war caveat

Before you make a decision based on benchmark numbers: the Zep-Mem0 LOCOMO dispute and the general criticism from benchmarks like Hindsight’s AMB make clear that a published score is not a guarantee. Vectorize’s Hindsight team’s position: "LoCoMo and LongMemEval are still a valid foundation... but they only cover one slice of the problem. AMB is adding datasets that focus on agentic tasks: memory across tool calls, knowledge built from document research, preferences applied to multi-step decisions." (Vectorize Hindsight)

Run the benchmark on your own data. Every vendor number you see is a best-case result under a specific harness.