Eight Agent Memory Systems. None of Them Solve the Whole Problem
Part 2: A practical comparison of Mem0, Zep, Letta, Cognee, LangMem, AWS AgentCore, Anthropic managed memory, and OpenAI Memory—and the architectural gaps every production team still has to fill.
Your agent can remember a customer’s name and still forget what it promised them yesterday. The memory market is full of impressive products, but none of them solve the entire problem—and choosing the wrong one can quietly lock your architecture into stale facts, expensive context, or missing state.
In this article: The agent-memory market is growing quickly, but the products are solving very different problems under the same label. This article maps eight leading systems—Mem0, Zep with Graphiti, Letta, Cognee, LangMem, AWS AgentCore Memory, Anthropic managed memory stores, and OpenAI Memory—against seven distinct memory types. Rather than treating memory as a single feature, the comparison examines how each product handles working, semantic, episodic, procedural, retrieval, parametric, and prospective memory. It highlights the architectural model behind each system, the workloads it fits best, and the operational or governance tradeoffs that emerge in production. The conclusion is uncomfortable but useful: no product provides a complete memory layer.
Part 2 of a 3-part series on production agent memory. Part 1 covered the seven memory types and why two of them (retrieval and prospective) are not memory at all. Part 3 builds a cross-framework memory bus for LangChain DeepAgents and the Claude Agent SDK.
The Agent Memory Product Landscape, Mapped
Part 1 left you with a taxonomy: working, semantic, episodic, procedural, retrieval, parametric, prospective. The obvious next question is the one every architect actually cares about. Which products implement which types, and which one should you buy?
Here is the headline finding, and it shapes everything below: no product covers all seven types as first-class configurable primitives. Not one. Parametric memory lives in model weights, and nobody exposes weights as a memory API. Prospective memory is a scheduler concern, and every single vendor pushes it back to your application layer: cron, queues, Temporal, EventBridge. The competition is entirely in the middle five, and even there, coverage is uneven. Procedural memory, arguably the highest-leverage type, is first-class in exactly one product.
I compared eight systems: Mem0, Zep with its Graphiti engine, Letta (the project formerly known as MemGPT), Cognee, LangMem on LangGraph, AWS AgentCore Memory, Anthropic’s managed memory stores, and OpenAI’s ChatGPT memory. Every claim below comes from primary sources: official docs, GitHub READMEs, and vendor engineering blogs.
The landscape at a glance
A comparison table is a map, not the territory. Here is what each row means when you are actually holding a pager.
Mem0 is the low-friction option: pip install mem0ai and a few lines get you layered user and session memory with hybrid retrieval that fuses semantic search, BM25, and entity matching. Its benchmark numbers are genuinely good (roughly 7K tokens in its published benchmark, p50 latency around 0.9 to 1.1 seconds). The architectural bet to understand before you commit: extraction is single-pass and ADD-only. Nothing is ever overwritten. That keeps writes fast and simple, and it means stale facts accumulate until you build your own cleanup. Mem0’s own docs also warn against storing unredacted PII, because everything in memory is “retrievable by design.”
Zep and Graphiti take the opposite bet. Graphiti is the open-source temporal knowledge graph engine; Zep is the managed product on top. Every fact carries bi-temporal validity windows, and when new information contradicts old, the old fact is invalidated rather than deleted, with history preserved. On the managed Zep platform, retrieval comes back in under 200 milliseconds by combining semantic search, BM25, and graph traversal (self-hosted Graphiti latency is yours to engineer). This is the best-in-class answer for temporal accuracy and compliance-grade auditability. The cost: self-hosting Graphiti means operating a real graph database (Neo4j, FalkorDB, or Neptune plus OpenSearch) and tuning ingestion concurrency, and smaller LLMs that cannot do structured output will fail ingestion outright.
Letta, formerly MemGPT, is not a memory library you plug in. It is an agent runtime you adopt, and it persists everything: memories, messages, reasoning traces, tool calls, all of it in a database. Its signature move is “core memory” blocks that live in the context window every single turn and that the agent edits itself through tools. That gives you a self-improving agent with excellent debuggability, and it means you pay prompt tokens for those blocks on every request. Long-term knowledge goes to archival memory with semantic search. Great fit for long-running agents; heavy fit for adding memory to an existing app.
Cognee is less a memory sidecar than a document pipeline that turns text into a combined vector plus graph representation, backed by three coordinated stores: relational, vector, and graph. Its memory API is organized around four explicit operations (remember, recall, improve, and forget), and it generates a cognitive-science-grounded ontology so structure evolves with your knowledge, for domains where “close enough” retrieval is not good enough. The tradeoff sounds steep on paper, but cognee 1.0 lets you collapse all three stores onto a single Postgres instance (pgvector for embeddings, a Postgres graph backend for relationships), which takes most of the operational sting out of it.
LangMem deserves special attention for one reason: it is the only product that models procedural memory as a first-class concept. It natively distinguishes semantic memory (collections and profiles), episodic memory (few-shot examples of what worked), and procedural memory, which it implements as prompt-rule optimization: the agent’s own instructions evolve based on experience. It scores memories on importance and strength (a recency and frequency blend) to decide between inserting new memories and consolidating existing ones. The catches: active memory formation adds latency on the hot path, and the richer features assume you live in the LangGraph ecosystem.
AWS AgentCore Memory is the enterprise-shaped answer: fully managed, no infrastructure, with async extraction running configurable strategies (semantic facts, user preferences, summaries) after events land in short-term memory. Its consolidation pass is the reference design for governance: it decides ADD, UPDATE, or NO-OP for each candidate fact, deduplicates near-identical ones, and marks outdated memories INVALID rather than deleting them, leaving an immutable audit trail. Retrieval runs around 200 milliseconds, scoped by namespaces, and it integrates with LangGraph, LangChain, Strands, and LlamaIndex. The constraint is in the name: AWS only.
Anthropic’s managed memory stores are the most architecturally distinctive entry: no vectors anywhere. A store is a workspace-scoped collection of text documents that mounts into a session’s sandbox as a directory under /mnt/memory/, and the agent reads and writes memories with the same file tools it uses for everything else. Every change creates an immutable version (kept 30 days, with recent versions always retained), and there is a redaction API for scrubbing PII from history without breaking the audit trail. Hard limits shape the design: 100 kB per memory, 2,000 memories per store, 8 stores per session, attached only at session creation. What you do not get: salience scoring, dedup, or similarity search. Consolidation is delegated to a separate “dreaming session” that reads fragmented stores and writes a clean one. Note that Anthropic also ships a separate client-side memory tool on the Messages API, where your application executes Claude’s requested file operations against storage you control. That client-side tool, not the managed stores, is the path with zero-data-retention eligibility, and paired with context editing, Anthropic reports it improved agentic-search performance 39% over baseline. Two different products, frequently conflated.
OpenAI’s ChatGPT memory rounds out the list mostly as a contrast. It is a consumer product feature, not an embeddable API: it auto-captures context from chats and connected apps and auto-updates its memory over time, prioritizing what it judges relevant and important. But you cannot self-host it, you cannot customize retrieval, and you cannot build your product on it.
Which one, though?
If you are a paid subscriber, thank you. Your support makes this work possible.
If you are a free subscriber and find these articles useful, please consider upgrading. A paid subscription is $80 per year or $8 per month.
