What are the alternatives to FAISS among AI memory agent frameworks?

FAISS is a vector-similarity library, not a memory system: it stores and searches embeddings but does not extract facts, persist them per user, resolve contradictions or track time. The agent memory frameworks that replace it, as of November 6, 2026, are Mem0 (fact extraction with add/search, Apache 2.0, about 68,500 GitHub stars), Hindsight (facts consolidated into observations and mental models, MIT, about 59,300 stars), Zep with Graphiti (temporal knowledge graph, Apache 2.0), Letta (a full stateful-agent runtime, Apache 2.0) and cognee (knowledge-graph memory pipelines, Apache 2.0). All five run self-hosted for free; most use Postgres or a graph database underneath rather than an in-process FAISS index.

What is the best AI agent memory system in 2026?

There is no single winner as of November 2026. Mem0 is the default for most teams: the most adopted (about 68,500 GitHub stars on November 6, 2026; 62,500 in September), self-reported 92.5% LoCoMo and 94.4% LongMemEval, simple add/search API. Hindsight is the pick for agents that must learn across sessions — consolidated observations, background-maintained mental models, and LongMemEval results independently reproduced. Zep (Graphiti) wins when time matters, with a temporal knowledge graph that tracks when facts were valid. Letta is a full stateful-agent runtime rather than a memory layer. cognee is the open-source knowledge-graph choice with a free cloud tier that includes 1M tokens.

Mem0 vs Hindsight: which should I use?

Use Mem0 if you need a memory layer bolted onto an existing chatbot fast: two calls, hosted platform, the widest integrations. Use Hindsight if the agent is supposed to get better with use — it consolidates facts into evidence-backed observations, maintains standing 'mental models' that are read with no retrieval or LLM call, and has a reflect operation for reasoning over memories. Hindsight is MIT-licensed and Mem0 Apache 2.0, and both run on Postgres; Hindsight's benchmark claim is the one with independent reproductions (Virginia Tech, The Washington Post), while Mem0's numbers are self-reported on its research page.

Are agent memory benchmarks reliable?

Only as a starting point. LoCoMo, LongMemEval and BEAM are the standard three, but vendors run them with different models, judges and retrieval settings, and scores conflict: Zep claims 94.7% on LoCoMo while a third-party run put it at 75.1%; ByteRover has published both 92.2% and 96.1% for itself. Mem0's own September 2026 leaderboard says none of the published numbers were generated on the same stack. Run your own evaluation on your own conversation logs before choosing.

How much do agent memory systems cost?

Self-hosting is free for Hindsight (MIT), Mem0 (Apache 2.0), Zep's Graphiti (Apache 2.0), Letta (Apache 2.0) and cognee (Apache 2.0). Hosted tiers as of November 6, 2026: Hindsight Cloud is usage-based with free credits, and its new Hindsight Inference API starts at $0.005 per million input tokens; Letta Pro is $20/month; Zep Flex is $125/month for 50,000 credits (Flex Plus $375 for 200,000); cognee cloud is free with 1M tokens, then a flat per-token rate plus $5 per extra workspace; Mem0 dropped its Starter and Pro plans in early November and now offers Free (50,000 adds and 10,000 retrievals a month with your own LLM key) and Custom. The LLM calls the memory layer makes for extraction are the bigger cost in every case.

Quick Answer

Best AI Agent Memory Systems 2026: Hindsight, Mem0, Zep

Published: September 28, 2026 • Updated: November 6, 2026

The short answer

Pick by what the agent needs to do with its memory, not by leaderboard. Re-checked November 6, 2026: Mem0 for the fastest, most widely integrated memory layer; Hindsight for agents that must learn and consolidate across sessions, with the only independently reproduced LongMemEval results; Zep / Graphiti for temporal reasoning over facts that change; Letta if you want a stateful-agent runtime rather than a library; cognee for open-source knowledge-graph memory with Python, TypeScript and Rust SDKs. All five are open source; the hosted tiers range from usage-based (Hindsight, cognee) to $20/month (Letta Pro) to $125/month (Zep Flex), and Mem0’s hosted platform is now Free or Custom.

Alternatives to FAISS for agent memory: FAISS only stores and searches vectors. If you are replacing it with a memory framework, Mem0 is the drop-in add/search layer, Hindsight adds consolidation and learning, Zep/Graphiti adds time-aware facts, Letta gives you the whole stateful agent, and cognee builds a knowledge graph. For the vector-store side of that migration, see alternatives to FAISS for AI agent memory.

What changed as of November 2026

Mem0 changed its hosted plans. Its pricing page (updated November 2, 2026) now lists only Free (first 30 days: 10,000 adds and 1,000 retrievals a month with model calls on Mem0; then 50,000 adds and 10,000 retrievals with your own LLM key, usage-based billing above that with a cap you set) and Custom (graph memory, user profiles, “Dream” consolidation, SSO, on-prem). The self-serve Starter and Pro plans are gone. Mem0’s open-source repository is Apache 2.0 and has about 68,500 GitHub stars.
Hindsight shipped its own models. On November 3 Vectorize released Hindsight Models: a decision model (hs-decide-1-flash, Apache 2.0) plus a reranker and embedding model (MIT), open weights on Hugging Face or hosted on a new Hindsight Inference API from $0.005 per million input tokens. Vectorize reports memory operations 2.5x cheaper and 1.9x faster on gemini-3.8-flash with better answers (vendor figures). The repository has about 59,300 stars, up from roughly 4,500 gained in two days in late September.
Zep’s prices are now credit-based and confirmed: Flex $125/month (50,000 credits, then $25 per 10,000), Flex Plus $375/month (200,000 credits), free prototyping at 10,000 credits a month.
cognee’s cloud is now free with 1M tokens included, then a flat per-token rate and $5 per additional workspace. We could not re-confirm the $2.50 per 1M token figure on cognee’s pricing page on November 6, so it is no longer quoted.
Licences corrected: Mem0, Graphiti, Letta and cognee are all Apache 2.0 (GitHub, November 6); only Hindsight is MIT.
New since this ranking: LLM Wiki vs OpenMemory vs GBrain for file-based and personal memory patterns.

The ranking

Rank	System	Core idea	License	Hosted price (Nov 6, 2026)	Best for
1	Mem0	Extract facts from conversations, add/search API, optional graph memory	Apache 2.0	Free (50K adds / 10K retrievals with your LLM key), then Custom	Most production chatbots and assistants
2	Hindsight (Vectorize)	Facts → observations → mental models; retain / recall / reflect	MIT (models: Apache 2.0 / MIT)	Usage-based, free credits; Inference API from $0.005/1M input	Agents that learn over time; always-on agents
3	Zep / Graphiti	Temporal knowledge graph with fact-validity windows	Apache 2.0 (Graphiti)	Flex $125/mo (50K credits), Flex Plus $375/mo	Time-sensitive facts, CRM-style memory
4	Letta (ex-MemGPT)	Agent runtime with self-editing in-context vs archival memory	Apache 2.0	Pro $20/mo	Teams that want the whole agent, not a layer
5	cognee	Knowledge-graph memory pipelines; Python/TS/Rust SDKs, MCP	Apache 2.0	Free with 1M tokens, then per-token + $5/extra workspace	Graph-heavy, multi-language stacks

1. Mem0 — the default

Mem0 is the most adopted memory layer, at roughly 62,500 GitHub stars in September 2026 (about 68,500 on November 6), and the one most other tools compare themselves against. The model is simple: pass conversation turns to add, and it extracts and stores facts per user, agent or session; call search at inference time to retrieve them. It reports 92.5% on LoCoMo, 94.4% on LongMemEval and 64.1% on BEAM-1M on its own research page (updated September 22, 2026). Graph memory is optional. It is the right answer when the requirement is “the assistant should remember what the user said three weeks ago” and nothing more exotic. Weakness: the numbers are self-reported, and consolidation is shallower than Hindsight’s — facts accumulate rather than resolve into beliefs.

2. Hindsight — memory that learns

Hindsight’s difference is the two layers above facts. Observations are deduplicated beliefs consolidated in the background with supporting quotes and a proof count; new evidence strengthens or weakens them instead of overwriting. Mental models are standing answers to a question about a memory bank that Hindsight rewrites as it learns and that the agent reads as a plain database read at boot. The third operation, reflect, reasons over memories rather than retrieving them. It runs on Postgres + pgvector via Docker, embedded Python, Helm or Cloud; supports 25+ LLM providers including fully local ones; and can use existing ChatGPT, Claude, Cursor or Copilot subscriptions as the LLM with no API key. Its LongMemEval results are the only ones in this list independently reproduced (Virginia Tech’s Sanghani Center, The Washington Post). It gained about 4,500 GitHub stars on September 27-28, 2026 as persistent agents (Meta Muse, Microsoft Autopilot, OpenAI “o”) became the story. Detail in what is Hindsight.

3. Zep / Graphiti — when time matters

Zep wraps Graphiti, an open-source temporal knowledge graph that records when each fact became true and when it stopped being true. That makes it the strongest option for memory where facts get superseded — a customer’s plan, an employee’s role, a project’s status — and for questions like “what was true in March.” Zep’s own LoCoMo claim is 94.7%, but a third-party run put it at 75.1%, and its consistently cited LongMemEval figure is 71.2% under a GPT-4o judge. The hosted Flex plan is $125/month for 50,000 credits (confirmed on Zep’s pricing page November 6, 2026); self-hosting Graphiti is free but you own a graph database.

4. Letta — the runtime, not the layer

Letta (formerly MemGPT) is an agent framework in which the agent itself manages what stays in context versus what goes to archival storage, using memory-management tools. It positions around 74% on LoCoMo under an agent-autonomy framing. If you want to adopt an opinionated stateful-agent server with a REST API and development environment, Letta is the most complete; if you already have an agent and want to add memory to it, it is the heaviest option here. A $20/month Pro cloud tier shipped in 2026.

5. cognee — graph memory, many languages

cognee (topoteretes/cognee) builds knowledge-graph memory pipelines from documents and conversations, with Python, TypeScript and Rust SDKs and an MCP server. It is Apache 2.0, with a free cloud tier that includes 1M tokens and a flat per-token rate above it (the $2.50 per 1M figure we quoted in September was last confirmed on September 28, 2026). It trended alongside Hindsight in late September 2026. Choose it when your memory is document-and-entity heavy rather than conversation heavy, or when you need a non-Python client.

How to choose

Chatbot that should remember users: Mem0. Done in an afternoon.
Agent that runs unattended and must improve: Hindsight. Mental models at boot are the feature you will notice.
Facts that expire or change: Zep / Graphiti.
Greenfield stateful agent, no existing framework: Letta.
Graph-shaped knowledge, Rust or TypeScript backend: cognee.
Any of them: run LoCoMo or LongMemEval yourself on your own logs. Vendor scores do not share a stack, and the gaps between claims (Zep 94.7% vs 75.1%) are bigger than the gaps between products.

For the conceptual split between agent memory, chat memory and RAG, see agent memory vs chat memory vs RAG. For isolation, injection and retention risks, see how to secure AI agent memory. For memory shared across a team of agents, see best LLM memory solutions for multi-agent teams. For per-user memory in chatbots with many users, see best agent memory for multi-user chatbots.

Last verified: November 6, 2026. Hosted prices re-read on each vendor’s pricing page and licences and star counts on GitHub on November 6; benchmark figures are vendor-reported unless stated and were not re-run.

Looking for codebase knowledge rather than end-user memory? See alternatives to Dosu.

Replacing a raw FAISS index with a persistent store first? See alternatives to FAISS for AI agent memory.