Best Agent Memory Tools in 2026: 8 Platforms for Production AI Agents

If an agent needs to remember a user across sessions, the fastest path for most teams is Mem0 or Zep for a managed API, Letta if memory and reasoning need to run as one system, or Cognee if the whole thing has to be self-hosted and backend-agnostic. This guide evaluates eight purpose-built agent memory platforms plus the memory features that already ship free inside OpenAI's and Anthropic's own APIs.

Agent memory is a young category and the vendor list from six months ago is already wrong in places. Zep quietly stopped maintaining its open source core in 2026. Graphlit, one of the more ambitious platforms here, is winding down entirely, new signups closed and customer data scheduled for deletion. This guide leads with the question most vendors would rather you skip: do you need a dedicated memory product at all, or does a Postgres table and a native model feature already cover your case?

Key Facts

• The global vector database market, the infrastructure layer under most agent memory products, is projected to reach $3.2 billion in 2026, up from $2.58 billion in 2025, growing at roughly 24% a year through 2034 (Fortune Business Insights).
• A bigger context window is not memory: on the RULER long-context benchmark, GPT-4's accuracy fell from 96.6% at 4,000 tokens to 81.2% at 128,000 tokens, a 15.4-point drop even on a model advertising support for that full range (RULER, arXiv:2404.06654).
• Anthropic reports that pairing its memory tool with context editing lifted performance 39% over baseline on an internal agentic-search evaluation, versus 29% from context editing alone, a vendor-reported figure worth testing against your own workload (Anthropic).
• OpenAI's Responses API keeps response objects for 30 days by default and Conversation objects indefinitely, at standard token pricing with no separate storage fee, but it stores transcripts, not extracted memories (OpenAI).
• Redis has been tri-licensed since version 8.0 in May 2025: AGPLv3, the only OSI-approved option of the three, or one of two source-available licenses, a reversal of its 2024 move away from open source that also produced the Linux Foundation's Valkey fork (Redis).

Do You Actually Need a Memory Product?

Before you shortlist anything, ask whether you're solving a real problem or buying insurance against one you don't have yet.

A dedicated agent memory layer earns its cost when your agent needs genuine cross-session recall (not just a long transcript), when you need entity and relationship tracking that a plain similarity search won't give you, or when nobody on your team has the bandwidth to own embedding refresh, deduplication, and summarization logic by hand. That's a real, specific job, and it's different from retrieval-augmented generation over your own documents, which a plain vector database already handles well.

It's a different story pre-product-market-fit, or when your agent only needs to recall the current conversation. Every frontier model vendor now ships some persistence for free: OpenAI's Responses and Conversations APIs store transcripts, and Anthropic's context editing and memory tool manage a long session at standard token pricing. Neither does true memory consolidation, but neither does most of what a one-person team needs in month one. A Postgres table with a pgvector column and a weekly summarization job covers a surprising amount of ground, free, on infrastructure you already run. pgvector vs Pinecone vs Weaviate works out when that stops being enough.

The honest rule: start with what you already pay for. Move to a dedicated memory platform once you can name the specific gap it closes, not because the category is trending. For where memory fits inside the rest of your stack, see how AI agents use retrieval, choosing an AI agent platform, and how to choose AI knowledge base software.

Quick Comparison Table

Licensing and Self-Hosting

This is the table to check before legal or security signs off on a self-hosted deployment. Licensing in this category has moved twice in 2026 alone.

Pricing at Real Usage, Not the Headline Rate

Headline prices rarely survive contact with a real workload, because every vendor here meters a different unit: add events, "episodes," tokens processed, flat operations, or raw compute. To make them comparable, we modeled one scenario: a support agent handling roughly 10,000 conversations a month, writing about 300,000 memory events and running about 30,000 retrievals, assuming an average memory entry of 50 to 80 tokens (up to 350 bytes).

These are illustrative estimates from each vendor's own published rates and a stated workload assumption, not a quote: your actual mix of short facts versus long documents will move the numbers, so treat this as a method to re-run on your own traffic rather than a guaranteed bill. The flip worth noticing: Zep's $125/mo sticker looks cheapest at a glance, but its per-episode credit metering means that at 300,000 memory events a month, the pricier $375/mo Flex Plus tier wins, because its larger credit bucket and cheaper overage rate beat 25 top-up blocks on Flex. Papr shows the opposite problem: nothing sits between $100 and $500, so a workload barely above Starter's cap still pays for Growth's full 750,000-operation ceiling.

1. Mem0: The Default Starting Point

Mem0 is the closest thing this category has to a default choice, and the free tier is the reason why: 10,000 memory writes and 1,000 retrievals a month, no card required. The Starter tier at $19/mo multiplies both ceilings by five. The jump to Pro is steep ($249/mo for 500,000 writes, 50,000 retrievals, and graph memory for entity tracking), and there's no middle option, so budget for it rather than being surprised.

The product itself is a straightforward memory API: SDKs across Python and Node, an Apache 2.0 open source server you can self-host for free, and the same interface works against OpenAI, Anthropic, or a local model. That portability, decoupling memory from your choice of LLM, is Mem0's real strength for a team that hasn't committed to one model vendor long-term.

2. Zep: Built on a Temporal Knowledge Graph

Zep's differentiator is Graphiti, its open source temporal knowledge graph framework: it tracks not just what a user said, but when a fact became true and when it stopped being true, which matters for agents that need to reason about state changes ("they used to be on the free plan, now they're on Enterprise") rather than just retrieve similar text.

The catch is Zep's open source story changed in 2026: the company discontinued Zep Community Edition, the self-hosted version of its core memory service, and now concentrates its open source effort entirely on Graphiti. If you want to self-host the full memory service rather than just the graph library underneath it, that option is gone. What's left is a credit-metered hosted product: free up to 10,000 credits a month, $125/mo for 50,000 (Flex), $375/mo for 200,000 (Flex Plus), with storage, retrieval, and users unmetered, only writing an "episode" costs a credit.

3. Letta (formerly MemGPT): Memory and Reasoning as One System

Letta is the commercial continuation of MemGPT, the 2023 Berkeley research project that modeled agent memory after an operating system: a main context window acts like RAM, archival memory acts like disk, and the agent decides what to page in and out through tool calls. The rebrand happened in 2024, the Apache 2.0 license hasn't changed since, and the GitHub repository confirms the full framework and server remain open source and self-hostable.

What sets Letta apart from Mem0 or Zep is architectural: memory isn't a separate API call, it's part of the same stateful agent, sharing context with reasoning instead of syncing between two systems. Pricing reflects that integration: a $20/mo base plan, then $0.10 per active agent/mo and $0.00015 per second of tool execution, with LLM token costs passed through separately. That's granular and genuinely hard to forecast until you've run a full billing cycle, the honest tradeoff for a platform-level product instead of a simple metered API.

4. Cognee: The Self-Hosted, Backend-Agnostic Option

Cognee is built for teams who want the memory layer itself to be infrastructure they own, not a vendor they depend on. It's Apache 2.0, it ingests data in essentially any format, and it builds a structured knowledge graph your agents can query and update across sessions, running against whichever backend you already operate: Neo4j, Amazon Neptune, or a standard relational or vector store.

The hosted option, Cognee Cloud, is new and intentionally thin: a free tier (1 million tokens, one workspace), a Standard tier at $1 per 1 million tokens processed plus $5 per additional workspace, and an Enterprise bring-your-own-cloud tier with vendor support. For most teams, the honest expectation is that production use means self-hosting and owning the operational overhead, with the cloud tier more a way to try it than a mature managed product yet.

5. LangMem and LangGraph Persistence: Memory Inside Your Orchestrator

If you're already building on LangGraph, LangMem isn't a separate purchase decision, it's a library (MIT, free) that stores memories inside LangGraph's own structured store. There's no standalone LangMem pricing because there's no standalone LangMem service: your cost is whatever you pay to run LangGraph, self-hosted (free, MIT) or through LangGraph Platform, where the Plus tier runs $39 per seat a month with 10,000 base traces included, plus usage billed in LangChain Standard Units at $1.00 each against compute and storage.

The tradeoff is specialization: this only makes sense if LangGraph is already your orchestration layer, not a product you'd adopt independently. And because LangGraph Platform meters infrastructure (vCPU-hours, GiB-hours) rather than memory events, you can't isolate "how much memory costs" the way Mem0 or Zep's per-write pricing lets you. That's fine if you reason about agent cost as a whole; it's a real limitation if you need to budget memory as its own line item. For frameworks more broadly, see our roundup of AI agent frameworks for developers.

6. Supermemory: Memory With Connectors Built In

Supermemory's pitch is that memory shouldn't require manual feeding: the Pro tier ($19/mo, roughly $20 of usage included) ships Google Drive, Notion, and OneDrive connectors, and Max ($100/mo) adds Gmail, so memory can ingest from where work already happens instead of waiting for your app to push data in. The core repository is MIT licensed, with some SDKs under Apache 2.0, and the vendor documents it as runnable fully locally if you want to self-host rather than pay.

Where it gets complicated is billing: four separate usage meters (memory ingestion by token, SuperRAG retrieval by token, search by query, and a catch-all "operations" meter at $100 per million), each with its own rate and its own plain-text versus rich-content split. That's flexible, but you can't eyeball a monthly bill from the plan price alone; you need a week or two of real traffic before the number stabilizes.

7. Redis: Your Existing Cache, Stretched Into a Memory Store

Redis isn't a purpose-built agent memory product, and it doesn't pretend to be one on its pricing page. It's positioned as infrastructure: caching, a vector database and semantic search, session management, and, explicitly, a memory store for AI agents and RAG applications, all on the same engine most engineering teams already run for something else. That's the appeal: if Redis is already in your stack, extending it into a fast, low-latency memory layer avoids adding a new vendor, a new bill, and a new set of credentials.

It's also the limitation. Redis gives you the storage primitive, not the memory logic: you write your own consolidation, deduplication, decay, and entity-extraction code, none of which ships the way Mem0's graph memory or Cognee's knowledge graph does. Before committing to self-hosting it commercially, get legal sign-off on licensing: since Redis 8.0 in May 2025 it ships tri-licensed under AGPLv3, RSALv2, or SSPLv1, after a 2024 detour into source-available-only licensing that pushed the Linux Foundation to fork the last BSD version as Valkey. AGPLv3 is the only one of the three that's OSI-approved open source; the other two carry commercial-use restrictions worth reading closely.

8. Papr: The Simple Metered API

Papr's pitch is simplicity: one metered unit (memory operations), a free developer tier (1,000 operations, 1GB, 2,500 active memories), and two paid tiers, Starter at $100/mo (50,000 operations, 10GB, 100,000 active memories) and Growth at $500/mo (750,000 operations, 100GB, 1 million active memories). There's no graph-memory upsell and no multi-axis credit system to model, genuinely easier to reason about than Mem0's or Supermemory's pricing pages.

The tradeoff shows up at the edges. Papr is closed source, so there's no self-hosted fallback, and the gap between tiers is large: a team needing 80,000 operations a month has no $150 or $250 option and must buy the full $500 Growth tier. Papr also carries the smallest public footprint here, with fewer third-party integrations and less independent benchmarking than Mem0, Zep, or Letta, which matters if you want evidence beyond the vendor's own claims.

The One That Died: Graphlit

Graphlit is the cautionary example this category needed. It was pitched as a "context layer for AI agents," semantic infrastructure with ingestion, knowledge graphs, and RAG chatbots in one platform, and its own pricing page, when we fetched it, still listed four live tiers. But a second page on the same domain tells the real story: Graphlit's own sunset notice confirms the service is winding down, is no longer accepting new customers, and has scheduled customer accounts and project data for deletion once each account's offboarding window closes.

The lesson generalizes beyond Graphlit: a comprehensive-sounding platform in this category can close its doors the same year it's being compared favorably to Zep and Letta elsewhere. Check a vendor's own legal or status page before you build on it, not just its marketing homepage, which in Graphlit's case still reads as if nothing has changed (Graphlit sunset notice).

What OpenAI and Anthropic Ship for Free

If you're comparing this against an older guide that mentions "OpenAI Assistants," that product is gone: OpenAI deprecated the Assistants API on August 26, 2025 and fully removed it a year later, on August 26, 2026, a date already past as of this writing (OpenAI). What replaced it, the Responses plus Conversations APIs, is what matters now, alongside Anthropic's separate context tooling for Claude.

For a lot of teams under real production load, this trio genuinely is enough, especially pre-product-market-fit, when you don't yet know what "memory" should mean for your specific agent. For a side-by-side of the underlying models these features ship on, see Claude vs ChatGPT vs Gemini. Reach for one of the eight platforms above once you can name a gap none of these three options closes.

How to Choose: Decision Framework

Team Size and Who Runs It

What to Do Next

Don't pick a platform before you've modeled your own numbers. Take the metric that matters for your agent (writes per month, retrievals per month, and whether you need relationship tracking or just similarity search) and run it through two candidates: one managed option (Mem0 or Zep) and one self-hosted option (Letta or Cognee), using the method above rather than the headline rate. Spend a week on real traffic before committing to an annual plan, check a vendor's status or legal page the same day you check its pricing page, and confirm you need a dedicated memory layer before adding a ninth vendor to your stack. A Postgres table plus your model provider's native memory feature is the right answer too, when it's enough. Once memory is live, tracing the retrieval step behind a wrong answer is an observability job, and the LLM observability roundup compares 12 platforms for it.