AI Agent Memory in 2026: Frameworks Ranked

If you are choosing an AI agent memory framework in 2026, here is the short answer: for drop-in personalization pick Mem0, for time-aware reasoning pick Zep or Graphiti, for long-running self-managing agents pick Letta, and for graph-native document reasoning pick Cognee. Everything else on this page is about why those defaults exist, what the alternatives are, and how to avoid picking a project that looks popular but is quietly unmaintained.

Agent memory frameworks are the fastest-moving sub-category of the whole agent stack right now. A year ago most teams bolted a vector database onto an agent, called it memory, and moved on. Today there is a real product category with funded startups, competing architectures, and a genuine debate about how agents should remember. This post maps that landscape and ranks the open-source options so you can pick with your eyes open.

What is agentic memory, exactly?

Agentic memory is the layer that lets an AI agent remember across sessions. Concretely, it does four things: it extracts durable facts from interactions, it consolidates and updates those facts over time, it forgets stale ones, and it re-injects the relevant slice back into a future context window when the agent needs it.

That last part is the whole point. A context window is short-term working memory that gets wiped between sessions. A memory framework gives the agent something durable underneath, so the tenth conversation with a user builds on the first nine instead of starting cold. If you want the ground-level version of how agents work before going deeper, our primer on what AI agents are is a good starting point.

How is agent memory different from RAG?

People conflate these constantly, so let us be precise. RAG is stateless retrieval over a static, someone-else-authored corpus - your docs, a knowledge base, a set of PDFs. It reads. It never writes. AI agent memory is a dynamic store the agent writes and updates itself, with a lifecycle RAG simply does not have: extraction, then consolidation, then update, then decay and forgetting.

The confusing part is that memory frameworks often use vector retrieval as a mechanism, the same tech RAG uses, which is why teams assume they are the same thing. They are not. Memory is a different abstraction that happens to share plumbing. We break this down properly in AI agent memory vs RAG if the distinction matters for your architecture.

What kinds of memory does an agent actually need?

The useful taxonomy comes from the CoALA framing, which splits agent memory into four types. Most production systems end up needing more than one.

The frameworks below differ mostly in which of these types they treat as first-class. A simple fact layer nails semantic memory. A temporal knowledge graph shines at episodic memory with time. A memory OS tries to manage all four at once.

What are the three architectural camps?

Every serious agent memory framework in 2026 falls into one of three camps. Understanding the camp tells you more than any single feature list.

1. Vector / fact “memory layer.” Cheap, drop-in, LLM-extracted facts. The agent hands over a conversation, an LLM pulls out the durable facts, and they get stored and retrieved by similarity. Examples: Mem0, Memobase, LangMem. This is the category default because it is easy to adopt and good enough for personalization.

2. Temporal knowledge graph. Models how facts change over time using bi-temporal data, fact invalidation, and point-in-time queries. Instead of just “the user prefers window seats,” it knows when that became true and whether it is still true. Examples: Zep/Graphiti, Cognee. We go deep on this in advanced agent memory with temporal knowledge graphs.

3. Memory OS / self-editing agent runtime. The agent manages its own memory the way an operating system manages RAM and disk, paging things in and out and editing what it stores. Examples: Letta (formerly MemGPT), MemOS.

On top of these three camps sits a tier of managed memory-as-a-service offerings - Mem0 Platform, Zep Cloud, supermemory, Google Vertex AI Memory Bank, and Redis - plus provider-native memory now baked into ChatGPT, Claude, and Gemini. Not everyone needs to self-host.

Which agent memory frameworks are most popular?

Here is the centerpiece: purpose-built open-source agent memory frameworks ranked by GitHub stars. Star counts are approximate and current as of 2026. Read them as a popularity signal, not a quality score.

A few honest caveats. Stars do not equal production-readiness. Always check the maintenance status before you commit. Several once-prominent projects are now dead ends: Zep Community Edition OSS (getzep/zep, ~5k) was deprecated in April 2025 in favor of Graphiti plus Zep Cloud, Motorhead (getmetal/motorhead) has been deprecated since December 2023, and both Memary and Memoripy are effectively unmaintained. Do not build on those.

One more clarification that saves a lot of confusion: raw vector databases like Pinecone, Chroma, Qdrant, Weaviate, and Milvus are storage substrates, not memory frameworks. Memory frameworks are built on top of them. If someone tells you “we use Pinecone for agent memory,” what they have is storage, not a memory lifecycle.

What changed in 2025 and 2026?

The category matured fast. The big shifts worth knowing:

• The “memory layer” became a real product category. Mem0 raised $24M in October 2025 and supermemory got funded, which tells you investors now treat memory as its own market rather than a feature.
• Temporal knowledge graphs went mainstream. Bi-temporal reasoning moved from research curiosity to something teams actually ship.
• Consolidation, decay, and forgetting became table stakes. A memory system that only appends is now considered broken.
• Self-editing and sleep-time compute arrived. Letta popularized agents that reorganize their own memory during idle cycles.
• Memory operating systems emerged. MemOS pushes the OS metaphor furthest, unifying different memory representations.
• MCP memory servers proliferated. OpenMemory, Basic Memory, and the Graphiti MCP server let any MCP-aware agent plug into memory. If you are new to this protocol layer, our Cloudflare AI capabilities guide covers where MCP fits.
• Consumer memory went default. ChatGPT, Gemini, and Claude all remember by default now, which reset user expectations for every product.
• “Context engineering vs memory” became the framing. The useful mental model: memory is the library, context engineering is the librarian deciding what to pull off the shelf for this specific request.
• Shared multi-agent memory raised new risks. When agents share a memory store, memory poisoning becomes a real attack surface, and governance starts to matter.

On benchmarks, a quick word of caution. You will see numbers thrown around from LOCOMO and similar tests. Treat any single vendor’s benchmark claim skeptically - Mem0 and Zep publicly dispute each other’s LOCOMO results, and vendor-run evaluations tend to flatter the vendor. We dig into the contested numbers properly in the Mem0 vs Zep vs Letta vs Cognee comparison; for this overview just know that no published number is the last word.

Which agent memory framework should you choose?

Match the framework to the problem, not to the star count.

That last row matters. If you already run a framework, use its native agentic memory before you reach for a separate library - CrewAI has memory=True, LlamaIndex has Memory blocks, and Google ADK ships a MemoryService. Start there, then layer Mem0 on top when you need proper multi-tenant user scoping that the built-in memory does not handle. If you are still choosing a framework at all, our AI agent framework comparison covers the surrounding decision.

Where does this leave you?

The honest summary: there is no single best AI agent memory framework, there is a best framework for your workload. Pick your camp first - fact layer, temporal graph, or memory OS - then pick within it, and always verify the project is actually maintained before you ship on it. Start simple with Mem0 or your framework’s native memory, and only graduate to a knowledge graph or a memory OS when you have a concrete reason.

Getting agent memory right is the difference between an agent that feels genuinely useful over weeks and one that greets every user like a stranger. If you want help designing that architecture, our AI Agent Development team builds it in from day one, and Enterprise AI Integration wires it into your existing data and identity boundaries so memory works inside your compliance perimeter, not around it.