Best AI Agent Memory Systems in 2026: A Developer's Comparison

July 2026

Nine different open-source and commercial projects now ship something they call "agent memory." They don't agree on what that means. Some store conversation turns in a vector database. Some build a knowledge graph. Some are a library you import; others are a hosted API you call. Picking one by name recognition alone means picking blind.

This post compares nine memory systems developers are actually using in 2026: Mem0, Hindsight, Letta, Zep, Cognee, Supermemory, LangMem, LlamaIndex Memory, and MemNexus. We built the ninth one, so read our section with that in mind — but the goal here is a map of where each system is strongest, not a scoreboard. Several of these projects beat MemNexus outright on dimensions that matter for their use case, and we say so.

Quick Comparison

| Framework | License | Stars | MCP Tools | Hosted | Self-Hosted | Best For | |---|---|---|---|---|---|---| | Mem0 | Apache 2.0 | 61.6k | Yes (official server) | Yes | Yes (OpenMemory) | General-purpose agent memory, broad ecosystem | | Hindsight (Vectorize) | MIT | 18.7k | Yes (27-30 tools) | Yes | Yes (Postgres) | Retrieval quality / benchmark performance | | Letta | Apache 2.0 | 23.9k | Consumes MCP (no server) | Yes (Constellation) | Yes | Building new agents with memory built in | | Zep | Commercial core, OSS engine (Graphiti) | 4.8k | Yes | Yes | Graphiti only | Conversation apps needing temporal knowledge graphs | | Cognee | Apache 2.0 | 29.2k | Yes (14 tools) | Yes (cloud + self-hosted) | Yes | Maximum architectural flexibility | | Supermemory | MIT | 28.6k | Yes + Claude Code plugin | Yes (freemium) | Yes (free) | Open-source base you can self-host and extend | | LangMem | MIT | 1.6k | No | No | Yes (library) | LangGraph teams that want memory without another service | | LlamaIndex Memory | MIT | 51k (framework-wide) | No | No | Yes (library) | LlamaIndex agents needing session-scoped memory | | MemNexus | Commercial (managed) | — | Yes (12 tools) | Yes (only option) | No | Structured, scoped memory across coding agents |

Stars are a proxy for community size, not quality — worth noting before you weight them too heavily below. MemNexus has no public repository, so there's no star count to list.

Pricing, star counts, and feature details current as of July 2026. Check each project's official site before making a decision — this space moves fast.

Mem0

Mem0 is the market leader by adoption, and the numbers back that up: 61.6k GitHub stars, an official MCP server, and OpenMemory as a self-hosted option for teams that don't want their memory data leaving their infrastructure.

Architecture. Mem0 extracts facts from conversation turns and stores them with vector embeddings, retrieving relevant memories by similarity search at query time. It's framework-agnostic — you can drop it into LangChain, CrewAI, AutoGen, or a bare API integration without rewriting your agent.

MCP support. Official server, actively maintained. If you want an agent to call memory tools directly rather than going through an SDK, this is turnkey.

Pricing. Free tier covers 10,000 memory adds per month. Starter is $19/month, Pro is $249/month, and Enterprise is custom. That's a wide range, which suits Mem0's wide range of use cases — solo hobby projects and production fleets both fit somewhere on that ladder.

Strengths. Ecosystem size is the real differentiator. More integrations, more Stack Overflow answers, more people who've already hit your bug. If you want the option with the largest community behind it, this is it.

Limitations. General-purpose fact extraction doesn't give you a structured way to scope memory by team, service, or role out of the box — you build that convention yourself if you need it.

Best for: general-purpose agent memory where ecosystem size and integration breadth matter more than a specialized retrieval architecture.

Hindsight (Vectorize)

Hindsight is the benchmark leader in this comparison. On LongMemEval — a standard benchmark for long-conversation memory recall — Hindsight scores 94.6%, the highest of any system covered here with a published number.

Architecture. Hindsight is Postgres-only by design, not by limitation — it leans on Postgres's maturity (transactions, indexing, operational tooling most teams already run) rather than adding a second database to the stack. MIT licensed, 18.7k stars.

MCP support. 27 to 30 MCP tools depending on version — the largest tool surface of anything in this list, giving an agent fine-grained control over retention, recall, and retrieval tuning rather than a handful of coarse verbs.

Pricing. Usage-based: $10 per million tokens to retain (write) memory, $0.75 per million tokens to recall (read). Cheap to query, priced for the storage work up front.

Strengths. If recall accuracy on long, messy conversation histories is your top priority and you're comfortable with Postgres as your only backend, Hindsight's benchmark number is hard to argue with. This is the system to reach for when "does it actually remember the right thing" matters more than anything else on this list.

Limitations. Postgres-only means no pluggable backend if your infrastructure runs something else. The large MCP tool surface is powerful but is more to learn than a 12-tool API.

Best for: teams where retrieval quality on long conversation histories is the deciding factor, and Postgres is already the backend of choice.

Letta

Letta takes a different approach entirely: instead of memory as a bolt-on service, it builds agents with memory as a first-class architectural primitive from the start.

Architecture. Letta's MemFS gives agents a persistent, file-system-like memory abstraction baked directly into the agent runtime, not queried from an external store after the fact. Apache 2.0, 23.9k stars, with a hosted cloud offering called Constellation for teams that don't want to run the runtime themselves.

MCP support. Letta is an MCP host, not an MCP server — it consumes external MCP servers as tools for its agents, but it doesn't expose its own memory as an MCP server for other agents to call into. If your workflow is "many different agent frameworks all reading the same memory store," Letta isn't built for that role; if your workflow is "one agent framework, memory included," it fits well.

Strengths. If you're building a new agent from scratch and want memory management to be part of the agent's core loop rather than an afterthought, Letta's architecture removes an entire integration step other frameworks require.

Limitations. The tight coupling between agent and memory that makes Letta convenient for new builds is the same thing that makes it awkward to bolt onto agents you didn't build in Letta, or to share across a multi-framework agent team.

Best for: building new agents where memory is architected in from day one, not retrofitted.

Zep

Zep is worth including with a clear qualifier up front: what's open-source here is Graphiti, the temporal knowledge graph engine underneath. Zep itself — the product most people mean when they say "Zep" — is a commercial managed service, and Zep's Community Edition has been deprecated.

Architecture. Zep builds a temporal knowledge graph over conversation history via Graphiti, tracking not just what was said but when facts became true or stopped being true. That temporal dimension is genuinely distinctive among the systems here.

MCP support. Included with the managed service.

Pricing. Credit-based pricing starting at $104/mo for 50,000 credits (~1 credit per message). Free tier: 10,000 credits/month.

Strengths. For conversation-heavy applications — support bots, long-running assistants — where knowing when something changed matters (a user's address, a preference, a subscription status), Zep's temporal graph is purpose-built for exactly that problem in a way none of the vector-similarity-based systems here directly address.

Limitations. 4.8k stars is the smallest community of any hosted option in this list, and the deprecation of Community Edition means self-hosting the full Zep experience (not just Graphiti) isn't an option anymore. Budget for the managed service if you want the whole product.

Best for: conversation-heavy apps that need temporal knowledge graphs — tracking how facts change over time, not just what was said.

Cognee

Cognee's pitch is flexibility: rather than picking one storage architecture and optimizing it, Cognee lets you plug in the backend that fits your infrastructure.

Architecture. Pluggable storage across graph, vector, and relational backends — swap the underlying store without rewriting the memory layer on top. Apache 2.0, 29.2k stars.

MCP support. 14 MCP tools, including 14 distinct retrieval modes — GRAPH_COMPLETION among them — giving an agent multiple ways to query the same underlying memory depending on what kind of answer it needs.

Pricing. $2.50 per million tokens, flat. Simple to reason about compared to Hindsight's split retain/recall pricing. Cognee also offers a hosted cloud tier at the same $2.50/M rate if you don't want to run it yourself.

Strengths. If your team already has strong opinions about which database belongs in production — or needs to support several backends across different deployments — Cognee's architecture bends to that instead of forcing one choice.

Limitations. That flexibility is a trade-off, not a free lunch: more retrieval modes and pluggable backends mean more configuration surface to understand before you're confident you've picked the right combination for your workload.

Best for: teams that want maximum architectural flexibility and are willing to invest time in configuration to get it.

Supermemory

Supermemory positions itself as the open-source base you build on, not the finished managed product you rent.

Architecture. MIT licensed, 28.6k stars, with an MCP server and a Claude Code plugin that makes it one of the more direct integrations with coding-agent workflows on this list.

MCP support. Yes, plus first-party Claude Code plugin support.

Pricing. Self-hosted is free — genuinely, not a trial. The hosted option is freemium: a free tier with $5/month in credits, with paid tiers above that for teams that want the hosted convenience without operating infrastructure themselves. The DIY open-source install is free forever (MIT); Supermemory also sells a managed self-hosted deployment (Scale tier, $399/mo) for teams that want them to operate it.

Strengths. The self-hosted free path with an MIT license means no vendor lock-in and no cost floor if you're willing to run it yourself. The Claude Code plugin is a meaningful head start if that's your primary coding agent.

Limitations. Free is genuinely free only in the self-hosted path — the hosted convenience option has the same “pay past the free tier” dynamic as everything else in this list once you outgrow $5/month in credits.

Best for: teams that want an open-source base they can self-host and extend on their own terms.

LangMem (LangChain)

LangMem is the smallest project by community size in this list — 1.6k stars — and the most narrowly scoped by design: it's a library, not a service.

Architecture. Pure SDK. No hosted backend, no server to run, no MCP integration. Python only, and still pre-1.0, which is worth knowing before you build production infrastructure on top of it.

Standout feature. Prompt optimization — LangMem can have an agent update its own system prompt based on what it's learned, a capability none of the other eight systems in this list offer in the same form.

Strengths. If you're already on LangGraph, LangMem adds memory with zero new infrastructure and no new service to operate. The prompt-optimization capability is a genuinely distinctive idea worth exploring even outside a LangGraph context.

Limitations. No MCP support means no path to exposing memory as tools for non-LangChain agents. Pre-1.0 status and Python-only scope mean this is a fit for a specific stack, not a general-purpose choice.

Best for: teams already on LangGraph that want memory without standing up another service.

LlamaIndex Memory

LlamaIndex Memory isn't a standalone project — it's a module inside the broader LlamaIndex framework, which has 51k stars across its entire codebase.

Architecture. Composable memory blocks — Static, FactExtraction, Vector — that you assemble to fit the session you're building rather than adopting one fixed memory shape.

MCP support. None. This is a library-level integration, not a service with its own tool-calling surface.

Strengths. If you're already building agents in LlamaIndex, the composability of memory blocks means you're not adopting an entirely separate system — memory follows the same patterns as the rest of your LlamaIndex code.

Limitations. No MCP support and no hosted option — this is scoped to LlamaIndex-based agents, not a fit for multi-framework or cross-agent memory sharing.

Best for: teams already using LlamaIndex agents that need session-scoped memory without adopting a separate system.

MemNexus

We built MemNexus for a specific job: giving coding agents — and the teams of coding agents that increasingly work on the same codebase — structured, scoped memory without asking anyone to run infrastructure.

Architecture. MemNexus is fully managed — there's no self-hosted path, which is a deliberate trade-off, not an oversight. What you get in exchange is a codeContext taxonomy: six typed fields (product, repo, service, component, team, role, plus an open extra map) that every memory carries. Instead of a flat pile of facts, memory in MemNexus is scoped the way a codebase is — by team, by service, by role — so a search from the frontend team's agent doesn't surface noise from the payments team's agent by accident. For example, a memory created with codeContext: { product: "acme-app", team: "payments", service: "billing-api" } is invisible to an agent scoped to team: "frontend" — no prompt engineering or manual filtering required.

MCP support. 12 MCP tools, plus named and versioned memories with SUPERSEDES chains — when a fact changes, the old version doesn't disappear, it's marked superseded and stays in the history. That matters for coding agents specifically: "we used to rate-limit at 100 req/min, now it's 250" is a fact whose history is often as useful as its current value.

Pricing. Free tier available with generous limits. Paid tiers for teams. See memnexus.ai/pricing for current plans.

Strengths. If your primary use case is a coding agent — or several coding agents working as a team on one codebase — the combination of structured codeContext scoping and named/versioned memories is built directly for that job in a way none of the other eight systems in this list are. This is where MemNexus is strongest, and we'd rather say that plainly than pretend we're the best fit for every workload above.

Limitations. Fully managed means no self-hosted option — if data residency requirements mean you must run memory infrastructure yourself, look at Cognee, Supermemory, or Hindsight instead. And MemNexus isn't purpose-built for the temporal-knowledge-graph use case Zep covers, or the long-conversation benchmark ceiling Hindsight has set at 94.6% on LongMemEval. MemNexus is closed-source and the newest project in this comparison. We haven't published a LongMemEval score. We don't have the multi-year track record or public issue history that Mem0, Cognee, or Hindsight do.

Best for: dev teams that want structured, scoped memory across coding agents without standing up and operating memory infrastructure themselves.

How to Choose

Start with what kind of agent you're building, not with a features list. If you're building a conversational assistant where users interact turn by turn and facts about them change over time — a subscription tier, an address, a stated preference — Zep's temporal knowledge graph is doing something the others aren't: it can tell you not just what's true, but when it became true. If your bar for success is raw recall accuracy on long, sprawling conversation histories and you already run Postgres, Hindsight's 94.6% LongMemEval score is the number to beat.

If you're building or already have a LangGraph or LlamaIndex agent, reach for LangMem or LlamaIndex Memory first — you'll add memory with zero new services to operate, at the cost of MCP support and cross-framework portability. If you want the largest community and the broadest integration surface with no single opinionated architecture, Mem0 is the safe, well-trodden default. If you want an open-source base you fully control, Supermemory's self-hosted free tier and Claude Code plugin are a strong starting point; Cognee gives you similar control with more backend flexibility if you're willing to configure it.

If your agents are coding agents — one or several, working across a real codebase with teams, services, and changing facts about the system itself — that's the job MemNexus is built for. The codeContext taxonomy and versioned memory chains solve a scoping problem the general-purpose systems above don't address directly, because it isn't the problem they were built to solve. No single system here is the right answer for every workload; the honest answer is to match the tool to the job in front of you.

Get Started

Every system in this comparison is worth evaluating against your actual workload — not a features table. If that workload is a coding agent or a team of them, you can set up MemNexus in about two minutes:

npm install -g @memnexus-ai/cli
mx auth login
mx memories create --conversation-id "NEW" --content "Starting: [your project]" --name "your-project-state"

Full CLI reference is at docs.memnexus.ai/reference/cli.

Related Reading

• Wiring Shared Memory Into a Multi-Agent Claude Code Team
• How to Brief Your Coding Agent Before It Writes a Line of Code