AI Agent Long-Term Memory: Mem0, Zep, Redis, and Neo4j Compared

Every Reddit thread about AI agent memory in early 2026 eventually devolves into the same argument: “just use Mem0” vs. “Zep’s temporal graphs are the only real solution” vs. “Redis handles this fine, stop overcomplicating it.” Meanwhile, Neo4j quietly shipped a new agent-memory library in February that nobody is talking about yet.

The honest answer is that none of these tools is universally best. Mem0 wins on simplicity, Zep wins on temporal reasoning, Redis wins on raw speed, and Neo4j wins on relationship depth. The right choice depends on what your agent actually needs to remember and how it needs to retrieve those memories.

Here is what each tool does, what it costs, and what the benchmark numbers actually say once you strip away the marketing.

The Agent Memory Landscape: A Quick Overview

Before getting into each tool, here is the high-level picture. These four tools occupy different positions in the agent memory stack:

Two things jump out. First, Mem0 and Zep are managed platforms that charge for cloud usage, while Redis and Neo4j’s agent-memory project are open-source infrastructure you run yourself. Second, the GitHub star counts reveal market attention, not quality: Mem0 has 50K stars and a $24M Series A, while Neo4j’s agent-memory library has 55 stars despite arguably deeper technical capabilities. The project launched in February 2026 and simply has not had time to build an audience.

The 2025 Stack Overflow Developer Survey found that 43% of developers building AI agents use Redis as their data management layer. That does not mean Redis is the best memory system. It means Redis is already in most production stacks, so teams reach for it first.

Mem0: Three Lines of Code to Agent Memory

Mem0 is the easiest entry point. You initialize a client, call add() with a message and user ID, and the system extracts facts, stores them in a vector database, and retrieves relevant memories on the next call. It genuinely takes three lines of Python to add persistent memory to a chatbot.

from mem0 import MemoryClient
client = MemoryClient(api_key="your-key")
client.add("I prefer dark mode and hate email notifications", user_id="alice")

Behind the scenes, Mem0 runs extracted facts through a vector database (Qdrant, Chroma, pgvector, or Redis), a key-value store, and optionally a graph database. That graph layer is important, and we will come back to it.

The Numbers

Mem0 raised $24 million in a Series A in October 2025, led by Basis Set Ventures with Y Combinator participation. API calls grew from 35 million in Q1 2025 to 186 million in Q3 2025. AWS selected Mem0 as the exclusive memory provider for its Strands Agents SDK, which is a significant enterprise endorsement.

Pricing Reality

The catch: Mem0’s graph memory feature, which enables entity relationship tracking and multi-hop queries, is only available on the Pro tier at $249/month. Free and Starter users get vector search only. If you need the feature that makes Mem0 more than a glorified embedding store, you are paying $3,000/year minimum.

The Benchmark Controversy

Mem0 published a research paper claiming 66.9% on the LoCoMo benchmark (Long Conversation Memory, 81 Q&A pairs), beating OpenAI’s native memory at 52.9%. That is a 26% relative improvement, plus 91% lower p95 latency and 90% token cost savings compared to full-context approaches.

Independent evaluations paint a different picture. Third-party benchmarks put Mem0 closer to 58% on LoCoMo, which is still better than stuffing everything into the context window but significantly below the self-reported number. The gap likely comes from differences in evaluation methodology and prompt formatting.

Zep and Graphiti: When Facts Have Expiration Dates

Zep takes a fundamentally different approach. Instead of storing memories as vectors and hoping cosine similarity retrieves the right one, Zep builds a temporal knowledge graph where every fact has a validity window. If a customer said “I use AWS” in January and “We migrated to GCP” in March, Zep does not store two conflicting facts. It marks the January fact as invalidated by the March statement and returns only the current truth.

The open-source engine powering this is Graphiti, which has 24,000 GitHub stars and supports Neo4j, FalkorDB, Kuzu, and Amazon Neptune as graph backends. Graphiti handles incremental graph construction (new data integrates immediately, no batch recomputation) and hybrid retrieval combining semantic embeddings, BM25 keyword search, and graph traversal.

Where Zep Differs from Mem0

The key architectural difference: Zep can ingest structured business data, not just chat messages. You can feed it JSON payloads from CRM systems, order databases, or support ticket queues. This means an agent’s memory is not limited to what was said in conversations. It knows the customer returned the product three days after the chat where they said they loved it. That return event, pulled from the order system, invalidates the “loves the product” fact extracted from the conversation.

Mem0 is fundamentally a conversation memory layer. Zep is trying to be a full context engineering platform.

Pricing

One credit equals one episode (a message or JSON payload up to 350 bytes; larger items are billed in multiples). You pay for ingestion, not storage. At the Flex tier, $25 gets you 20,000 episodes, which is roughly 20,000 conversation turns or data events.

Benchmark Honesty

Zep self-reported approximately 85% on LoCoMo, but a GitHub issue on their research repository challenged that number, with a corrected evaluation showing 58.44%. Both Mem0 and Zep have benchmark credibility problems, which is a pattern worth noting. Self-reported numbers from companies selling memory products should come with an asterisk.

Redis: The Speed Layer Underneath Everything Else

Redis is not a memory framework. It is the infrastructure that memory frameworks run on. Mem0 supports Redis as a vector backend. Graphiti can use Redis for caching. When teams say they “use Redis for agent memory,” they usually mean Redis sits underneath a higher-level abstraction.

That said, Redis released an Agent Memory Server in early 2026 that functions as a standalone memory system. It provides a REST API and an MCP (Model Context Protocol) server with two-tier memory: working memory scoped to individual sessions and long-term memory that persists across sessions. It supports automatic topic extraction, entity recognition, and conversation summarization using 100+ LLM providers via LiteLLM.

Why Teams Reach for Redis First

The performance numbers explain the adoption: sub-millisecond read/write latency for session state, compared to the tens-of-milliseconds range for graph database queries. Relevance AI reported that migrating their vector search to Redis reduced latency from 2 seconds to 10 milliseconds, a 99.5% improvement.

Redis also handles the memory lifecycle problem elegantly through built-in TTL (time-to-live) and eviction policies. Working memory that should expire after a session automatically gets cleaned up. Long-term memories that have not been accessed in months can be gradually deprioritized. You do not need custom garbage collection logic.

Redis Open Source 8 supports scaling to 1 billion vectors, which matters when your agent serves millions of users, each with their own memory store. The RedisVL (Redis Vector Library) hit approximately 1 million downloads in December 2025, a 10x year-over-year increase.

The Trade-off

Redis gives you speed and scale at the cost of relationship depth. It stores memories as JSON documents with vector embeddings, which is fast to query but cannot natively traverse multi-hop entity relationships the way a graph database can. If your agent needs to answer “which customers who bought product X also complained about shipping in the last 90 days,” Redis alone will not get you there. You need a graph layer on top.

Neo4j Agent Memory: The New Entrant Worth Watching

Neo4j Labs released neo4j-agent-memory in February 2026. With 55 GitHub stars, it is the least-known tool in this comparison. It is also the most architecturally ambitious.

The project implements three memory types: short-term (conversation history), long-term (facts and entities extracted via a POLE+O model covering Person, Object, Location, Event, and Organization entities), and reasoning memory (decision traces and tool usage audits). That reasoning layer is unique. No other tool in this comparison stores why the agent made a decision, which matters for debugging and compliance.

Technical Depth

Entity extraction runs through a multi-stage pipeline: spaCy for basic NER, GLiNER2 for zero-shot entity recognition, and an LLM extractor for complex cases. Entity resolution uses exact, fuzzy, and semantic matching to deduplicate entities across conversations. Relationship extraction uses GLiREL, which means many relationships are extracted without LLM calls, reducing cost and latency.

The project already integrates with LangChain, Pydantic AI, LlamaIndex, CrewAI, OpenAI Agents SDK, AWS Strands, Microsoft Agent Framework, and Google ADK. That integration breadth for a project with 55 stars suggests Neo4j is positioning this as a foundational layer, not a standalone product.

The Catch

It is a Neo4j Labs project, which means it is experimental. The README says “not officially supported.” You need a Neo4j instance running (AuraDB free tier works), and the documentation is sparse. This is a tool for teams that are comfortable reading source code and do not mind being early adopters.

For teams already running Neo4j in their stack, this is a natural fit. For everyone else, the operational overhead of adding a graph database just for agent memory is hard to justify unless your use case demands deep relational reasoning.

What Developers Actually Pick

Forum discussions, Reddit threads, and community comparisons reveal clear patterns in how practitioners choose:

“I need memory working in 30 minutes”: Mem0. The API is dead simple, the free tier is enough to prototype, and the AWS Strands partnership means it will be around for a while. The ceiling is that vector-only memory (without the $249/month Pro tier) misses relationship context.

“My agent needs to track facts that change over time”: Zep/Graphiti. Temporal fact invalidation is the killer feature. If your agent handles cases where user preferences, account states, or project contexts change between sessions, this is the only tool that handles it natively. The open-source Graphiti library gives you the engine without the cloud pricing.

“Speed is non-negotiable and I already run Redis”: Redis Agent Memory Server. Sub-millisecond reads, battle-tested infrastructure, and the MCP interface means any agent framework can connect to it. You lose graph traversal but gain operational simplicity.

“My agent needs to reason about entity relationships across thousands of interactions”: Neo4j agent-memory. The POLE+O model and reasoning traces give you the deepest entity understanding. Accept the early-adopter risk and the operational cost of running a graph database.

The emerging pattern: teams that ship production agents increasingly use two of these tools together. Redis for the speed-critical working memory layer, plus either Mem0 or Zep for the semantic/relational long-term layer. This is not over-engineering. It reflects the reality that different memory types need different storage backends.

A Note on Letta

Letta (formerly MemGPT, 21,700 GitHub stars) deserves mention even though it is not in this comparison’s title. Letta takes a “LLM-as-OS” approach where the agent manages its own memory tiers, including a “sleep-time compute” feature that processes and consolidates memories in the background. If you want the agent itself to decide what to remember and forget, Letta is the closest thing to that vision. It scored approximately 83% on LoCoMo in independent evaluations, the highest verified score among open-source tools.

Frequently Asked Questions

What is the best AI agent memory tool in 2026?

There is no single best tool. Mem0 is easiest to implement (3 lines of code), Zep/Graphiti is best for temporal reasoning where facts change over time, Redis is fastest for speed-critical retrieval (sub-millisecond latency), and Neo4j agent-memory offers the deepest entity relationship modeling. Many production teams combine Redis for working memory with Mem0 or Zep for long-term storage.

How much does Mem0 cost for AI agent memory?

Mem0 offers a free Hobby tier (10,000 memories, 1,000 retrieval calls/month), a Starter tier at $19/month (50,000 memories), a Pro tier at $249/month (unlimited memories with graph memory features), and custom Enterprise pricing. The graph memory feature, which enables entity relationship tracking, requires the $249/month Pro tier.

What is the difference between Mem0 and Zep for AI agent memory?

Mem0 stores extracted facts as vectors and retrieves them by semantic similarity, making it simple and fast but unable to track how facts change over time. Zep builds a temporal knowledge graph where every fact has a validity window, so it can automatically invalidate outdated information. Zep can also ingest structured business data (orders, tickets), not just chat messages. Mem0 is easier to implement; Zep handles complex, evolving contexts better.

Can Redis be used as AI agent memory?

Yes. Redis released an Agent Memory Server in early 2026 that provides two-tier memory (working memory and long-term memory) with REST API and MCP server interfaces. Redis delivers sub-millisecond read/write latency and scales to 1 billion vectors. However, Redis lacks native graph traversal for complex entity relationships, so teams often pair it with a graph-based tool for long-term relational memory.

Are AI agent memory benchmarks reliable?

Self-reported benchmarks from memory tool vendors should be treated with caution. Both Mem0 and Zep have faced challenges to their LoCoMo benchmark scores, with independent evaluations showing significantly lower numbers than self-reported claims. Mem0 self-reported 66.9% but independent tests showed approximately 58%. Zep self-reported approximately 85% but a corrected evaluation showed 58.44%. Always look for independent, third-party evaluations when comparing tools.