(01)The safest default when you want persistent memory in an existing agent without redesigning it. Mem0 extracts salient facts from conversations, deduplicates and updates them, then retrieves the relevant subset per turn. Broadest ecosystem in the category — 62,000+ GitHub stars, SDKs for Python and TypeScript, and drop-in providers for the common agent frameworks. Its own ECAI 2025 paper reports roughly 91% lower p95 latency and over 90% token savings versus stuffing full conversation history into context, which is the comparison that actually matters in production.
General-purpose personalisation and long-term recall for existing agentsFree open source; managed tiers from a free plan upward — see pricing pageAI-Native
(02)The strongest choice when *when* a fact was true matters as much as the fact. Zep builds a temporal knowledge graph on its open-source Graphiti engine (29,000+ stars, Apache-2.0), so superseded facts are invalidated with a timestamp rather than overwritten — an agent can answer "what is the customer's plan now" and "what was it in March" from the same store. Zep is also the loudest critic of the LoCoMo benchmark that most competitors quote, and argues for the harder LongMemEval instead. Managed cloud with a documented 200ms retrieval target; Graphiti is self-hostable on its own.
Production agents needing temporal, auditable fact historyGraphiti free and open source; Zep Cloud usage-based — see pricing pageAI-Native
(03)The reference implementation of agent-managed memory. Letta treats context like an operating system treats RAM and disk: the agent itself decides through tool calls what to promote into its limited context and what to page out to external storage, and it can rewrite its own persona and instruction blocks over time. That makes it the natural fit for long-running assistants that must genuinely learn rather than merely look things up. 24,000+ stars, Apache-2.0, and the team publishes its own memory leaderboard that holds the framework constant and varies the model — a useful counterweight to vendor-versus-vendor benchmarks.
Long-running stateful agents that edit their own memoryFree open source; managed cloud usage-based — see pricing pageAI-Native
(04)The best option when memory must be a queryable knowledge graph you own end to end. Cognee runs an ECL pipeline — extract, cognify, load — that turns documents, conversations and code into an entity graph with multiple retrieval modes, and it deliberately supports pluggable storage backends so the graph can live on your infrastructure. Local-first operation and a native MCP server make it the pragmatic pick for GDPR-sensitive DACH deployments where sending conversation history to a US memory API is the blocking objection. 29,000+ stars, Apache-2.0.
Graph-native memory over documents, code and conversations; data-sovereign deploymentsFree open source; managed tiers — see pricing pageAI-Native
(05)The choice for TypeScript and edge stacks that want memory as a fast API call rather than a Python service to operate. Written in TypeScript under an MIT licence with 28,000+ stars, it indexes content with temporal metadata and optimises hard for retrieval latency, and it can run fully locally. The trade-off is deliberate: it is a memory and context engine with strong RAG characteristics rather than an agent-managed memory hierarchy, so it personalises well and reasons about relationships less.
Low-latency memory plus RAG for TypeScript, Next.js and edge applicationsFree open source; managed tiers — see pricing pageAI-Native
(06)The lowest-effort memory in the category, and the honest answer for a large share of teams: no database, no service, no vendor to add. Claude manages a directory of memory files itself through tool calls — it reads them at the start of a task, writes what it learned at the end, and you store the directory wherever you already store state. Because the memory is plain files, it is trivially inspectable and version-controllable, which is a real governance advantage. The limits are equally clear: it is Claude-only, has no graph or temporal reasoning, and retrieval quality is whatever the model's own file discipline delivers.
Claude-native agents that want durable memory with zero infrastructureNo separate fee — you pay the tokens the memory files consume
(07)The most interesting new mechanism of 2026, with the caveat attached. Instead of only storing what the agent learned, it offloads verbose tool logs out of context and leaves a compact symbolic task canvas behind, then distils long histories into layered personas and scenes rather than a flat vector pile. The figures in Tencent's repository — clearly lower token use and a higher WideSearch pass rate in an agent integration — are vendor-produced with no independent reproduction, and the repository carries 450+ open issues. Worth prototyping for the context-offloading pattern; not yet a safe production default.
Cutting token cost on long-horizon agent sessions through context offloadingFree and open source; hosted backend billed by TencentDB usageAI-Native
(08)The right answer only if you are already committed to LangGraph. LangMem puts memory management inside the orchestration layer you are running anyway, so there is no second system to deploy and no cross-service latency. Treat it as working memory rather than a long-term memory layer: it handles within-thread and short-horizon cross-thread state well, and long-range recall is markedly weaker than the dedicated engines above. Smallest project here at roughly 1,600 stars, MIT.
Memory inside the LangGraph orchestration layerFree and open source (MIT)AI-Native
