The Best AI Agent Memory Platforms in 2026, Ranked on Axes You Can Verify

Published 18 September 2026 · Every price, licence and benchmark condition below was read from the vendor's own page on 10 September 2026, and every load-bearing figure was re-checked on 18 September 2026.

Four properties you can check in an afternoon decide the best agent memory platform in 2026, and the benchmark column is not one of them. They are how the platform isolates one tenant's memory from another's, what it does when a new fact contradicts an old one, whether you can run it where your data has to live, and what a retrieval costs you in milliseconds and money. Accuracy comes last, and the public record explains why: Zep has been scored at 84%, 75.14% and 58.44% on the same LoCoMo benchmark by two vendors arguing over harness settings, with none of the three carrying a stated judge model, and Mem0 publishes 94.4% on LongMemEval for its managed platform while the only independent run of its open-source SDK, arXiv 2603.04814, measured 49.0%. Those are not four products. They are one benchmark with four sets of conditions.

We build Maximem Synap, which is one of the platforms below, so read this as a vendor-written comparison that has been held to a specific standard: every figure carries its conditions, every price and licence was read from the vendor's own page on the day of publication, and the places where Mem0, Zep, Letta and Cognee beat us are stated as plainly as the places where we think we beat them. The comparison covers nine platforms and three cloud primitives against 83 questions that founders, CTOs, engineers and security reviewers actually ask.

The short answer, by situation

Everything below is the reasoning behind that table, in the order you should apply it.

What you are actually choosing between

"Agent memory platform" covers six different products, and in our own customer conversations most bad choices come from comparing across the six as if they were one category, which is an observation rather than a measurement.

Shape one is the drop-in memory API: you send conversation turns, an extractor turns them into facts, and you ask for the relevant facts before the next reply. Mem0, SuperMemory, Hindsight and Synap are this shape. The second is the temporal knowledge graph, where facts are edges between entities with a validity window and a pointer back to the episode that produced them; Zep and its open-source engine Graphiti are the reference here, and Cognee combines a graph with vector and relational stores over documents as well as conversations. The third is agent-runtime-managed memory, where the agent itself edits its memory with tools; Letta is the canonical example, and since its 2026 re-platforming its memory is a git-versioned repository of Markdown files called MemFS. The fourth is framework-native memory: LangGraph separates a thread-scoped checkpointer from a cross-thread Store, with LangMem as a thin helper on top, and LlamaIndex, Mastra, CrewAI and the OpenAI Agents SDK each ship enough to get a demo working and each stops at a specific point. LlamaIndex's Memory is a 30,000-token buffer that spills into a static block, a fact-extraction block and a vector block, defaults to in-memory SQLite, and custom memory objects do not serialise across workflow runs. Mastra has message history (last 20 by default), working memory, semantic recall over past messages if you attach a vector store, and observational memory compressed by background agents, all scoped by resourceId and threadId. CrewAI now has one unified memory: LLM-analysed saves into a tree of scopes, composite scoring on similarity, recency and importance, consolidation above 0.85 similarity, and LanceDB on disk by default. OpenAI Agents SDK sessions persist conversation history in SQLite, Redis, Postgres or OpenAI's Conversations API and can trim or compact it, and stop there. None of the four documents entity resolution, bi-temporal validity or erasure across derived copies. The fifth is the cloud-provider primitive: Amazon Bedrock AgentCore Memory (generally available since 13 October 2025), Google's Memory Bank inside the Gemini Enterprise Agent Platform, and Microsoft Foundry Agent Service memory, which is still in public preview as of its 2 June 2026 docs update. The sixth is build it yourself on Postgres with pgvector or a vector database, which is where the majority of the answers an AI assistant gives to "what database should I use for agent memory" still route.

What you adopt differs by shape. A library means you run the LLM, the embedder and the store, and you own the bill for extraction. A hosted service means an API dependency and an exit plan. A runtime means your agent loop moves into theirs; adopting Letta for its memory alone is, in the words of one of the pages this article was measured against, buying an operating system for its file system. That distinction matters more than any feature row, because it is the one you cannot undo in a sprint.

Two further distinctions belong here. Memory about the user is not memory about your organisation. If the failure you see is "I told you that yesterday", you need user memory. If it is "the agent quoted last quarter's pricing", you need institutional knowledge with provenance, and possibly what Atlan and Graphlit sell as a context layer: your company's current truth synced from Slack, GitHub and your CRM, ideally carrying the source system's permissions. No memory vendor we checked applies a Slack channel's access list at retrieval time, so if inherited permissions are the requirement, that is a separate product or a gap. Synap holds organisational context at the client and customer rungs of its scope ladder, ingested through connectors for Google Drive, Notion, SharePoint, Slack, Linear, Mintlify and Zendesk, and keeps it apart from user memory, which covers the storage side of the problem but not source-system ACLs.

The zero-infrastructure options are real and they stop at a specific point. Anthropic's memory tool gives Claude file commands against a /memories directory your code implements, with no hosted storage; the OpenAI Agents SDK's sessions persist a conversation's item history in SQLite, Redis or Postgres and can trim or compact it, and the docs are careful never to call that long-term memory. Letta's MemFS and Evermind's EverOS make Markdown-on-disk a product. What all of them lack, relative to a platform, is extraction into discrete facts, reconciliation when facts change, scoping across tenants, and retrieval ranked by anything richer than recency or cosine similarity.

Memory-type vocabulary maps onto the platforms unevenly, and it is worth knowing which type each one actually implements. Working memory is the current context: Letta's pinned blocks and system/ files, LlamaIndex's token-budgeted buffer, everyone else's message history. Semantic memory, stable facts about a person or a domain, is what Mem0's extracted facts, Zep's edges and Synap's fact and preference statements are. Episodic memory, the record of an interaction and what happened in it, is a first-class type in Synap (episodes), SuperMemory (episodes that decay), Evermind (user episodes) and AgentCore (its episodic strategy), and is the raw message history everywhere else. Procedural memory, how the agent should behave, is implemented as a learner only in LangMem's prompt optimiser, Letta's skills and Evermind's cases and skills; Mem0 stores a procedural type without learning it, and Foundry's preview has one. Synap's memory types are an open set generated per agent, with facts, preferences, episodes, emotions and temporal events the common ones and procedures, plans and habits occurring where the agent's work produces them.

Do you need a memory platform at all

For a single session, no. A message buffer is correct and everyone ships one. The question is what happens when the history outgrows the window, or the session ends, and here the two vendor papers disagree in a way that is informative rather than contradictory. Mem0's April 2025 paper, on LoCoMo conversations of roughly 26,000 tokens with gpt-4o-mini writing the answers, found that stuffing the full conversation into the prompt scored higher than Mem0 (72.90% against 66.88% on the LLM-judge metric) at a cost of 17.1 seconds p95 latency versus 1.4 seconds and roughly 26,000 tokens per question versus 7,000. Zep's January 2025 paper, on LongMemEval histories of roughly 115,000 tokens, found the opposite: full context scored 55.4% with gpt-4o-mini and 60.2% with gpt-4o, Zep scored 63.8% and 71.2%, and latency fell from about 30 seconds to about 3. Read together, the picture is consistent. Below roughly 30,000 tokens of history, stuffing wins on accuracy and you pay in latency and tokens; around 100,000 tokens, retrieval wins on accuracy as well. The independent cost paper, arXiv 2603.04814, puts the crossover at about ten turns of a 100,000-token loop once prompt caching is on, after which a fact-based memory layer is cheaper per turn even though, in that study, long-context GPT-5-mini still recalled more.

RAG over transcripts is the middle option and its weakness is the unit. A retrieved passage carries the fact you wanted, four you did not, the fact as stated in March and the correction in June, with no view on which is current. That is the whole reason a memory layer exists, and it is worth being precise about what one adds on top of a vector database, because "memory is just a vector DB" is the most common reason teams build the wrong thing. A memory layer makes four decisions a vector index never makes: what is worth writing (Mem0's extractor, the cloud primitives' extract-and-consolidate steps, Synap's read-then-store), how a new fact reconciles with an old one, when a fact retires, and how results rank beyond cosine similarity (Hindsight runs semantic, BM25, graph and temporal strategies in parallel; Synap ranks on relevance at 0.70, importance at 0.20 and recency at 0.10 with a 30-day half-life). A vector database gives you nearest neighbours over whatever you chunked. A memory layer gives you a maintained belief state.

Build versus buy, then, is not a cost question so much as a list. Postgres full-text search plus pgvector plus a periodic summariser is a defensible first version for a single-tenant, single-agent, low-traffic product where transcripts fit and nobody asks why the agent believes something. Our own 50,000-document retrieval study, scored on MRR@10 with exact document-ID matching and no model judge, found keyword search beat vector search on four of five datasets once the code dataset was excluded (0.5931 against 0.5614) and indexed in 2.11 seconds against 161.6 seconds for embeddings, which is a strong argument for starting simple. It stops being the right answer at the first item on the list every vendor built a product around: reconciling contradictions without a summariser overwriting detail, recording when a fact was and was not true, resolving entities across sessions, enforcing a tenant hierarchy at write time, keeping provenance per statement, and reaching every derived copy when a user asks to be erased. The mature architecture is three stores, and several of these platforms are three stores internally: your transactional database as the system of record for identity, orders and permissions, a memory layer holding derived, scoped, time-stamped statements, and whatever retrieval index the memory layer needs, which most vendors now run for you. The platform question is really which vendor owns the derived layer and how cleanly it references your system of record.

The axes, in the order to apply them

Cheapest to check and hardest to change comes first. Everything up to the write path can be settled with a browser; everything after it needs code.

1. Shape, licence, deployment and vendor risk

Fully open self-hosting exists today for Mem0 OSS (Apache 2.0, but without graph memory, decay, temporal reasoning or Dream, which are Platform-only), Graphiti (Apache 2.0, needs Neo4j 5.26, FalkorDB or Amazon Neptune; Kuzu is deprecated), Cognee (Apache 2.0, with the production Postgres-as-graph-store held back as a licensed product), Hindsight (MIT, one Docker command, embedded Postgres for development), LangMem (MIT), EverOS (Apache 2.0, Markdown plus SQLite plus LanceDB) and SuperMemory local (MIT repo, one binary with embedded graph engine and local embeddings). Two hosted products withdrew their self-hosted server. Zep stopped maintaining Zep Community Edition in April 2025 and the repo now says the code has moved to a legacy folder; self-hosting Zep today means Enterprise BYOC inside your VPC, and the graph database it runs on since August 2026, Konig, is proprietary. Letta retired its V1 server to an archive branch and moved self-hosting to the Apache 2.0 harness's local mode and App Server, which needs Node 22.19 or later. Synap is a managed service by default, with self-hosted and air-gapped deployment for enterprise engagements; the corpus behind this article does not publish a licence for the self-hosted server, so ask.

Vendor risk is best read from the vendor's own pages rather than from funding gossip. Mem0 announced $24 million in total funding on 28 October 2025 and its repo sits at 64.3k stars; Cognee announced a $7.5 million seed on 19 February 2026 and sits at 30.3k; Letta's last announced round is a $10 million seed from September 2024, and its 24.6k-star repo is now a landing page pointing to letta-code at 3.2k; Zep publishes no round; SuperMemory raised $3 million; Hindsight sits inside Vectorize, whose last announced round is a $3.6 million seed from October 2024. LangMem last shipped to PyPI on 27 October 2025 and pins langgraph<2, which reads as low-cadence rather than abandoned. The category has already changed licence terms once (Zep), removed a capability from open source once (Mem0's graph), and re-platformed once (Letta), so the hedge is structural: keep raw transcripts as your system of record so any vendor can be re-ingested, test the export path before you sign, and prefer an engine you could self-run.

Paid-tier gating is part of the same axis. On Mem0, graph memory, Dream synthesis, analytics and audit logs sit at Pro ($249) or Enterprise; on Zep, Observations, webhooks and custom extraction instructions start at Flex Plus ($375), and the SOC 2 report, HIPAA BAA, BYOK and BYOC are Enterprise-only; on Cognee, the pricing page lists bi-temporal memory, conflict resolution and provenance as Enterprise features even though the open-source docs expose manual primitives for each. Synap's tiers differ on volume and service level and every plan gets every memory capability; the exceptions are bring-your-own-key, which starts at Pro, and the enterprise service items (private deployment, SSO, custom service levels). That is the simplest gating rule on this page and one we would rather be judged on than argue about.

2. Scoping and identity

Most production memory failures we see are scoping failures rather than recall failures, and that is a Maximem claim from our own customer work rather than a published measurement, so weigh it accordingly. What is not in dispute is that every platform's first design decision is an isolation key, and the keys differ in depth.

Hierarchy matters because a read on Synap prefers the narrowest rung that applies and inherits everything above it, so a brand-new user still retrieves product policy and tenant facts, while nothing from one user or one tenant can reach a neighbour, because the scope is assigned when the memory is written rather than filtered when it is read. Cognee reaches a similar guarantee through dataset routing and default-on access control, which is the deepest permission model in the open-source group. Everyone else asks you to encode the hierarchy in a string or a tuple and to trust your own filters.

Multi-agent memory follows the same shape: Mem0, SuperMemory, Hindsight, Evermind and Cognee share memory by identifier and keep private state by another identifier; Letta is the only platform with an explicit shared-memory object, organisation-owned git repositories that cloud agents clone, commit to and pull; Synap gives several agents a central context layer plus agent-specific memories with the scope chain handling isolation between them. Cross-session identity, meaning which human is holding an anonymous session, is not something any of these platforms resolves for you. Entity resolution is about people mentioned in conversations, not people holding them. SuperMemory's merge-container-tags call is the closest thing to a documented guest-to-account merge; Synap's docs put the constraint bluntly for deletion: a person you cannot name cannot be erased.

Cold start follows from scoping too. A first-time user has no user-rung memory anywhere, so the platforms that help are the ones with something above the user to fall back on: Synap's client and customer rungs mean a new user still retrieves product policy and tenant facts on the first turn; Zep's standalone graphs hold shared business knowledge that any new user graph can be queried alongside; Mem0's app_id and agent_id memories, and a SuperMemory organisation container you query alongside the user's, play the same role by convention. The other two levers are seeding (Zep ingests CRM records as JSON episodes, Mem0 stores a seed verbatim with infer=false and immutable: true, Synap backfills whole transcripts in one call and imports from other vendors with field mapping) and writing in the hot path on the first session so the second turn benefits, which every asynchronous platform otherwise delays by seconds.

3. What can never be stored, what erasure reaches, and what is attested

Read the delete page and the security page before the benchmark page. Mem0's own docs say it is designed to retrieve stored context rather than secure it, and its controls are prompt-level: custom instructions and per-call include and exclude hints. Anthropic's memory-tool guidance recommends stripping sensitive data before the handler writes the file. Zep's ignore_roles keeps whole roles out of the graph. Synap is the only platform on this page with a hard floor: full card numbers, card security codes, PINs, passwords, API keys and other secrets, private keys and raw biometric data are never stored for any account regardless of settings, and are replaced in the memory with a description such as "a card number was given and not kept". Above the floor, eleven categories each take one of six treatments, from "not sensitive" to "your own vault", with the limits stated in the docs: names, street addresses and health data have no shipped detector, detection is text-only, and the identifier list is India-first. A healthcare buyer should read that as "use custom field types" rather than as a promise.

Erasure is where the unit of memory becomes a legal question. GDPR Article 17 requires erasure without undue delay and reasonable steps about copies and replications, which is exactly the derived-copies problem. Zep's deletion semantics are the most explicit: deleting a user removes threads, the user graph and all extracted knowledge in one call, but nodes shared with other episodes persist and an invalidated fact stays invalidated after its episode is deleted. Mem0 deletes by filter and the docs say this satisfies user erasure, without describing the entity store or history log. SuperMemory's forget is a soft delete; deleting a container tag removes everything in it. Cognee's forget removes graph nodes, edges, vectors and session cache for a dataset, keeping nodes another document still references. Letta's memory is a git repository, so deleting from history is your git problem. Synap soft-deletes out of retrieval immediately and purges active stores within 24 hours, hard-deletes from backups within 30 days on request, cascades through the entity graph except for co-referenced entities, and for protected values destroys the per-account key so backups become unreadable, with a preview count and an audit entry written before the run. No vendor we checked offers a signed deletion certificate; proof today is an audit log plus a re-query.

Compliance, from each vendor's own trust page on 10 September 2026: Zep states SOC 2 Type II and HIPAA BAAs, attribute-based access control, policy-driven retention and legal hold, gated to Enterprise. SuperMemory states SOC 2 and a HIPAA BAA from its $399 Scale tier, with GDPR access and erasure workflows; the pricing page does not say which SOC 2 type, and there is no reachable trust page that does, so ask. Vectorize is SOC 2 Type II at company level. Mem0 states SOC 2 Type I, "HIPAA Ready" and "GDPR Ready"; the incumbent comparison pages that say Type II are wrong today. Cognee Cloud says plainly it holds no SOC 2 or ISO 27001, operates under German data-protection law with a named DPO, and deletes a tenant's whole database on request. Letta publishes no security page we could find. Synap's docs say SOC 2 Type II is in progress, GDPR and CCPA compliant with a DPA on request, HIPAA not certified with an instruction not to send PHI, ISO 27001 on the roadmap, two regions (US East and EU Central) chosen at account creation with no cross-region replication, and audit logs retained 90 days and exportable on Enterprise. On this axis Zep wins, and any deal where compliance is the deciding factor should start there.

Memory poisoning belongs on the same axis. The OWASP Top 10 for Agentic Applications lists memory and context poisoning as ASI06, and Microsoft's June 2026 red-team taxonomy update reports it observed at high frequency and usually combined with prompt injection. The controls map to features you can check: write boundaries (Letta's read-only blocks, Zep's ignore_roles, Mem0's immutable flag), validation (Synap holds anything below a 0.7 confidence threshold as a candidate rather than a retrievable memory, and its per-agent memory architecture is reviewed by a person before it applies), provenance (Graphiti episodes, Mem0's history endpoint, Letta's git commits, Synap's "where it came from, what it replaced, why it changed"), and removal that reaches derived copies. The architectural lesson from both bodies is the same: retrieved memory is data, not instruction, and it should never land in the highest-trust slot of the prompt.

4. The write path

Every serious platform writes asynchronously, and the demo that writes a fact and immediately reads it back will look broken on all of them. Mem0's add returns an event ID with a pending status to poll. Zep says added data can take a few seconds to a few minutes and offers a processed flag and webhooks. SuperMemory documents a queued, extracting, chunking, embedding, indexing, done pipeline with an "instant" mode that costs extra. AgentCore's long-term memory generation is a background process. Synap's add returns immediately with a handle, and the docs say a memory written now is not retrievable a second later. A production agent reads the live buffer for the current turn and the memory layer for everything before it, or polls.

What the write costs is the number nobody benchmarks. Mem0's paper describes one extraction call plus, for each candidate fact, a retrieval of the ten most similar memories and an LLM decision, so an add was one plus n calls; the April 2026 algorithm collapsed this to a single ADD-only pass. Cognee's cognify makes two LLM calls per chunk, so a 10,000-token document at 1,024-token chunks is roughly twenty calls. Hindsight runs one call per 3,000-character chunk and prompt-caches its fixed prefix. Zep bills one credit per 350 bytes of episode and does not publish a call count; SuperMemory and Evermind extract in a background "dreaming" phase and do not publish one either; Synap meters ingestion at two credits or one per 500 tokens, whichever is larger, and lets Pro and above bring their own model key so the extraction calls land on your provider bill. The cheap levers are the ones the vendors document: Mem0's infer=false for verbatim storage, Hindsight's chunks mode with no LLM call, Cognee's larger chunks, LangMem's deferred processing.

Who writes the memory decides how it fails. Letta's agent writes its own: it decides what is durable, edits a Markdown file, and commits, with background "dreaming" subagents consolidating lessons; that fails by omission and drift, and it is the path OWASP describes for a one-time injection shaping behaviour across sessions. Extractor-written memory (Mem0, Zep, SuperMemory, Synap, the cloud primitives) fails by over-collection and duplication, and cost scales with traffic. The specific trap in 2026 is ADD-only extraction: Mem0's migration guide says that when information changes the new fact is stored alongside the old one, and an open issue filed in April 2026 reports stale employer facts surfacing as a result. Whether extraction consults existing state is the underlying design choice. Graphiti checks new edges against temporally overlapping contradictions and sets the older edge's invalid timestamp; Synap's update stage asks whether a new statement supersedes, enriches or duplicates the one it resembles. Stateless extraction is cheaper per write and never loses detail but moves the burden to ranking; stateful extraction costs a comparison per write and can lose detail if the merge is careless, which is why the next axis exists.

Write authority is the last thing to check here. Letta lets you mark a block read-only and can route dreaming's proposed updates through review; Mem0's immutable: true excludes a memory from future consolidation; Zep's ignore_roles keeps assistant turns out of the graph; Synap's per-agent architecture is generated from a description of what the agent does, reviewed and approved by a person, versioned and rollback-able, and ambiguous entity merges go to a review queue rather than being guessed. Nobody documents per-memory human approval before a write lands except Letta's optional review.

5. The unit of memory, and everything that follows from it

There are three units in use, and the choice decides contradiction handling, provenance, deletion and token cost downstream. Passages (RAG over transcripts, SuperMemory's document chunks, Cognee's chunks) carry the fact plus its surroundings. Discrete statements (Mem0's extracted facts, Synap's self-contained sentences with a type, a confidence score, a storage time, an event time and a scope) stand alone. Edges (Graphiti and Zep) are subject, relation and object with a validity window and a pointer to the episode. Only a statement or an edge can be compared with another, which is why contradiction handling is impossible on passages and merely hard on the other two.

Contradiction handling. Mem0 v3 is ADD-only on both the open-source SDK and the Platform: the new fact sits beside the old one, ranking is expected to surface the newer, and Dream marks older facts superseded on a schedule. Zep and Graphiti invalidate rather than delete, setting invalid_at and expired_at on the contradicted edge and keeping the history queryable. SuperMemory records an Updates relation and keeps the original with isLatest=false. Cognee's opt-in functional-relationship resolution tags the older edge as superseded with a reason. Letta and LangMem leave it to the model rewriting text. Synap's rule has two parts: a newer statement that is poorer than the one it resembles never replaces it, so "takes a cholesterol medication" cannot overwrite "takes 20mg of Atorvastatin daily", and nothing is destroyed by an update; the old statement is marked historical and linked to its replacement with the reason. We call that conscious and lossless forgetting, and it is the capability we would most like a reader to test against any platform on this page, because it is the failure every memory system has and none of them advertise.

Temporal validity. Only Zep and Graphiti document a full bi-temporal model with named fields: created_at (when the system learned it), valid_at (when it became true), invalid_at (when it stopped) and expired_at (when the system learned it stopped). Cognee has added a lighter valid_to on nodes that you close explicitly, persisted today only on its Ladybug backend. Mem0 has timestamps, an expiration_date that hides rather than deletes, and a Platform-only temporal reasoning boost at search time, but no validity window on a memory. Synap records when a memory was stored and when the thing it describes happened, which are often different dates, and keeps the lineage from a deprecated statement to its successor; the corpus does not name a valid-from and valid-to pair, so if you need to query "what was true in January", Zep is the reference and Synap answers it through history rather than through a field.

Entity resolution. Graphiti runs an LLM deduplication step at ingest that returns a duplicate candidate or none for each extracted entity. Hindsight matches on trigram similarity and co-occurrence, and its docs admit a short new name can be absorbed into an existing entity by mistake. Cognee ships an opt-in consolidation pipeline at a 0.85 similarity threshold with a dry-run mode. Mem0's graph memory stores each entity once and embeds it, with no threshold or review control described. Synap matches in order exact, alias, semantic and contextual, narrowest scope first, auto-registers unmatched entities at the customer rung, and routes ambiguous matches to a dashboard review queue instead of guessing. SuperMemory, Letta, LangMem and Evermind do not document it as a feature.

Forgetting and consolidation. Stores grow by default. Mem0's levers are expiration_date and an opt-in Memory Decay re-ranker that never removes candidates. Zep invalidates and, on Enterprise, expires data on a policy with legal hold. SuperMemory documents time-based expiry, contradiction and noise filtering plus a bounded bulk forgetMatching. Letta's dreaming reviews recent conversations and consolidates lessons. Cognee's forget is an explicit, token-free delete with no decay. Synap works on memory at three cadences (a light pass every few hours, a deeper one daily, and the deep consolidation and conscious forgetting during your product's quiet hours) and weights recency with a 30-day half-life at ranking time.

Provenance, review and rollback. Zep's Debug Mode is the deepest "why" tooling, with ingestion traces linking a fact to the episodes and deduplication candidates that produced it, retained 30 days. Mem0's history endpoint returns old and new text, the event type and the triggering messages, but there is no rollback call. Letta and EverOS give all four (review, attribution, diff, rollback) because memory is files in git. Synap logs every action with a principal and correlation ID (retained 90 days, exportable on Enterprise), keeps a separate sensitive-data activity trail for one year, and shows in the dashboard what a memory replaced and why; the memory architecture is versioned and can be rolled back, individual statements are not.

When a graph is worth it. The graph pays for temporal validity, provenance and relationship queries, and Zep's paper measured the payoff on LongMemEval-S at 63.8% against 55.4% for full context with gpt-4o-mini. Mem0's own April 2025 paper showed a small graph premium (68.44% against 66.88% on LoCoMo with gpt-4o-mini answering, at roughly double the tokens) and Mem0 then removed the external graph store from its open-source SDK in 2026 in favour of built-in entity linking, which boosts ranking rather than offering a traversable graph. If your questions are "who is connected to what, and when was it true", pay for the graph; if they are "what does this user prefer", a flat store with entity linking is cheaper and, on Mem0's own data, within two points. Graphiti requires you to run Neo4j, FalkorDB or Neptune; Zep Cloud runs its own engine; Cognee ships embedded defaults; Synap's accurate retrieval mode expands through the entity graph as a service feature you do not operate.

Procedural memory. LangMem's prompt optimiser rewrites instructions from scored trajectories, Letta's skills are directories an agent can author from a completed task, EverOS treats agent cases and skills as a first-class track, and Foundry's preview has a procedural memory type. Mem0 stores a procedural memory type but does not learn it. Zep, Cognee and SuperMemory document no procedural learning, and neither do we; Synap's memory types include procedures where they occur, and that is the honest extent of it today.

6. Latency and tokens

Percentile and condition matter more than the number. Zep publishes the tightest read-path figures on this page: 104 ms p50 and 162 ms p95 retrieval on LongMemEval, 87 ms and 155 ms on LoCoMo, and, in its August 2026 Konig announcement, an end-to-end context block under 200 ms at p95; the benchmark figures and the Konig claim are two different measurements and we quote both. Mem0's 2026 table reports 0.88 seconds p50 on LoCoMo and 1.09 seconds on LongMemEval at a top-200 retrieval budget, with no p95. SuperMemory states under 300 ms per query at the API, reranking adds about 100 ms, and no percentile. Hindsight's benchmark runs average 675 ms per retrieval on LongMemEval-S. Cognee, Letta, LangMem and Evermind publish no read-path percentile. Synap publishes two numbers with their conditions: an in-conversation P75 under 15 ms, which is served from a cache inside your own process because Synap works out what the agent is likely to need next while the conversation is still going and pushes it there before it is asked for, and a cold-retrieval P95 of 450 ms, which we state as a target rather than a measurement.

For text chat, anything under about a second disappears behind model generation. For voice, the budget belongs to the whole turn. Daily, which maintains Pipecat, tells builders to aim for 800 ms median voice-to-voice and to accept 1,500 ms in a proof of concept; ElevenLabs' worked example lands at roughly 680 ms p50 and 1,560 ms p95 time-to-first-audio; LiveKit's turn detector alone waits 0.5 to 3.0 seconds after speech by default. A 100 ms memory read fits inside that. A 900 ms one does not, unless it leaves the critical path, which is the whole argument for prefetching.

What you inject costs tokens on every turn, and where you inject it decides whether it destroys your prompt cache. Both Anthropic and OpenAI cache on exact prefix match, so a per-turn memory block placed in the system prompt invalidates everything after it every turn, while the same block placed after a stable prefix costs only its own tokens; cached reads are a tenth of the base input price on both providers. Letta's pinned system/ files are by definition in the prefix, which is a trade you make knowingly. The rule that follows for every platform is the same: pin identity, standing constraints and the agent's instructions in the stable prefix, inject the per-turn memory block after it, and never pin anything that grows. Mem0 and SuperMemory return memories you place yourself, usually in the user turn; Zep returns a context block string; Synap's fetch returns a formatted block within a token budget you set, intended for the same slot. The budgets themselves are small when the unit is a statement: Mem0's paper reports about 85 tokens of memory per query on LoCoMo, Hindsight budgets recall by tokens, and Synap's default fetch budget is 2,000 tokens, trimmed to whatever you set.

7. Pricing

No two vendors meter the same thing, which is why the entry price tells you little. Mem0 sells monthly quotas of add and retrieval requests, Hobby free at 10,000 adds and 1,000 retrievals, Starter $19 at 50,000 and 5,000, Pro $249 at 500,000 and 50,000, with no published overage. Zep meters ingestion only, one credit per 350-byte episode chunk and nothing for retrieval, at Free 10,000 credits, Flex $125 for 50,000 and Flex Plus $375 for 200,000, with overage published at $25 per 10,000 credits on Flex and $75 per 40,000 on Flex Plus. SuperMemory meters unique tokens ingested plus $0.005 per 1,000 search queries on $19, $100 and $399 plans that include credit. Cognee Cloud charges $1.00 per million tokens processed with no base fee. Hindsight Cloud is pay-as-you-go: $10 per million tokens retained, $0.75 per million recalled. Letta bills $0.10 per active agent per month plus $0.00015 per second of tool execution on its API plan. The cloud primitives are usage-priced by event, record and operation. Synap bills credits at $0.00175 each: retrieval costs 1, 2 or 3 credits depending on mode, ingestion two credits or one per 500 tokens, on plans from Starter at $19 for 25,000 credits (list $49) through Pro at $249 for 150,000 with bring-your-own-key, Scale at $999 for 750,000, and overage between $2.00 and $1.50 per thousand.

Worked at two workloads, retrieval only, on the list prices above: 10,000 retrievals a month is $0 on Zep, about $0.05 on SuperMemory, $19 on Synap Starter in fast mode, and $249 on Mem0 because 10,000 exceeds Starter's retrieval cap; a million retrievals a month is still $0 on Zep (with a $125 floor and ingestion paid separately), about $5 on SuperMemory unless searches count as billable operations, which the page does not say, $1,374 on Synap in fast mode ($999 plus 250,000 overage credits at $1.50 per thousand) or $4,374 in accurate mode, and not computable on Mem0, Cognee, Hindsight or Letta from their published units. Predictability is best where retrieval is a flat per-call unit and worst where it is per token or bundled into agent runtime. Startup programs exist at Mem0 (three months of Pro), SuperMemory (three months of Scale), Zep (an Enterprise package at $13,000 for year one for companies that have raised $1 million to $10 million) and Cognee (a discounted 12-month BYOC tier); Synap has a free Trial with 5,000 credits and no startup programme.

8. Integration and exit

Adapter breadth splits the field. Mem0 lists 22 integrations from LangGraph and CrewAI to LiveKit, Pipecat, Mastra and Google ADK; Zep lists 14 including LangGraph, CrewAI, AutoGen, Mastra, Pydantic AI, Strands and the Microsoft Agent Framework; SuperMemory and Cognee cover the main Python and TypeScript frameworks plus coding-agent plugins. Synap ships 23 framework adapters as installable packages, each plugging into the extension point the framework already has (a store and checkpointer for LangGraph, a storage backend for CrewAI, pipeline processors for Pipecat, hooks and an in-process MCP server for the Claude Agent SDK), so adoption is two installs and one object passed into a slot. Hindsight has Python, TypeScript and Go clients but no framework adapters; LangMem is LangGraph only by design; Letta is not an adapter at all, because its SDK is TypeScript-only and wraps Letta's own harness. Languages: everyone has REST and Python; Zep and Hindsight add Go; Synap's TypeScript SDK is a native implementation rather than a wrapper; Letta's current SDK is TypeScript only.

Time to first memory is minutes on every drop-in API (Mem0 says about five, Hindsight says sixty seconds, SuperMemory's self-hosted binary says under two minutes) and the quickstarts all stop before the three things that consume the engineering time: scoping, pacing a backfill against rate limits (Synap's defaults are 100 requests a minute and 10,000 a day), and handling the asynchronous read-after-write gap. No vendor publishes an integration-time figure, ours included. The rule of thumb we give teams is a day to a working memory inside an existing framework slot, and one to two weeks to production once the scope model is decided, the backfill has run and the read-after-write path is handled; a runtime such as Letta is a re-platforming rather than an integration and should be budgeted as one.

Every drop-in API and graph platform here exposes an MCP server for coding agents. Mem0 hosts one with eleven tools and a Claude Code plugin; Zep's Memory MCP Server is seat-limited per tier; SuperMemory, Cognee and Hindsight each host or ship one; Synap's hosted endpoint exposes four tools, holds no secrets, and takes the API key per request. Letta is an MCP client rather than a server, since it is the coding agent; Evermind relies on a community server plus plugins; LangMem has none.

Exit is thinner than entry. Import tools now point mostly at Mem0 (Zep, SuperMemory and Cognee all ship Mem0 migration paths; Cognee's COGX format imports from Mem0, LangMem, Letta, Zep and Graphiti; Synap runs import jobs with field mapping and readback verification for uploads up to 2 GB). Export out: Mem0 has an async export job whose results expire after seven days; Cognee exports a COGX archive; Letta and EverOS are files in git; Zep documents no bulk graph export and advises re-ingesting source data rather than translating facts; SuperMemory's migration docs say nothing about leaving. Synap documents import jobs and audit-log export but no memory export endpoint, which a buyer should ask us about before signing, and we would rather say that here than have you find it later. Changing the embedding model is the other exit cost and the self-hosted vendors are candid: Cognee requires pruning and re-ingesting, SuperMemory local refuses to boot on a dimension mismatch, Mem0's docs say to recreate the collection; on a managed service that risk sits with the vendor. Switching the answer model is a different question with an easy answer: stored memories are text, so they survive a move from OpenAI to Anthropic to an open model on every platform here, and the only coupling to a model is the embedder and, on the self-hosted engines, the extraction model you configure.

9. Accuracy, last

Here is every current figure with its conditions, and the conditions are the point.

Read across the rows and the pattern is that no two are comparable. The Agent Memory Benchmark is a Vectorize project whose README opens by saying it was built to be honest about how Hindsight performs, and the leaderboard's own runs cover Hindsight and a set of baselines, with other vendors' rows marked as external results carried over from a paper or a blog. Mem0's public results page omits the answer and judge model that its 2025 paper stated, and its own documentation puts a plus or minus one point interval on the judge. Zep's current page gives no run date. The 2025 dispute between the two is the clearest public evidence that harness choices move LoCoMo by more than twenty points: Mem0's paper scored Zep at 65.99%, Zep's rebuttal corrected its own earlier 84% to 75.14% and accused Mem0 of misassigning speaker roles, and Mem0's re-run, with adversarial questions removed, scored Zep at 58.44%. A May 2026 essay by Dell Zhang, citing an audit by Penfield Labs, adds that LoCoMo's ground truth carries 99 score-corrupting errors across 1,540 questions, a rate of roughly 6.4%, and that the standard LoCoMo judge, gpt-4o-mini with the original prompt, accepted 62.81% of deliberately wrong-but-topical answers, with the caveat Zhang himself states, that Penfield Labs maintains a competing memory project and that he cross-checked the two figures against its open audit repository before repeating them. Our own number is a vendor number too. What we can offer that most of the rows cannot is the harness, MIT-licensed, which runs LongMemEval and LoCoMo end to end against Synap, Mem0, Zep and SuperMemory with a provider interface for adding your own, and a written list of where it deviates from the published protocols. We are also not the highest self-reported score on this table, and we would rather be the vendor whose harness you can run than the one with the largest number.

The benchmarks also measure less than buyers assume. LongMemEval and LoCoMo test recall and reasoning over a fixed chat history; neither runs an agent twice on the same task to see whether the second attempt improves. Three newer benchmarks move toward that: MemoryAgentBench names test-time learning and selective forgetting among its competencies, BEAM runs to 10 million tokens across ten abilities, and LongMemEval-V2 tests workflow knowledge over web-agent trajectories. None of the vendor tables above reports task completion improving over runs, ours included.

The platforms

Mem0 is the default thing people try first, and that is a real advantage: 64.3k GitHub stars, 22 listed integrations, a hosted MCP server, SDKs in Python and TypeScript, and a path from pip install to a working memory in minutes. It is sold two ways, an Apache 2.0 library with a self-hostable Docker server and a managed Platform, and the Platform is where the product now lives: graph memory, decay, temporal reasoning, Dream consolidation, webhooks and export jobs are Platform-only, and the docs say the published benchmark scores reflect proprietary optimisations not in the open-source SDK. The write path is single-pass ADD-only since April 2026, scoping is a flat set of tags with app_id as the tenant handle, and compliance is SOC 2 Type I with HIPAA and GDPR described as "ready". Where it wins: adoption, ecosystem, and the shortest path to a demo. Where it does not: hierarchy depth, open-source parity with the managed product, and independently reproduced accuracy, where the one third-party run of the OSS SDK landed at 49.0% on LongMemEval against the vendor's 94.4% for the Platform.

Zep and Graphiti are the enterprise competitor and the one to take seriously. Graphiti (Apache 2.0, 29k stars) is the open temporal graph engine; Zep Cloud adds multi-scope retrieval, observations, governance, a memory MCP server, and since August 2026 a proprietary graph database service, Konig, for which Zep claims graph retrieval under 100 ms at p95 and an end-to-end context block under 200 ms (its research page, measured on the public benchmarks and undated, reports 104 ms p50 and 162 ms p95 for LongMemEval retrieval). Every fact carries the four bi-temporal timestamps, contradictions are invalidated rather than deleted, deletion of a user cascades through threads and graph, and the compliance posture (SOC 2 Type II, HIPAA BAA, ABAC, retention with legal hold, BYOK and BYOC) is the most complete on this page, gated to Enterprise. Pricing starts at $125 a month for Flex after a 10,000-credit free tier, ingestion is metered and retrieval is free, and Community Edition is no longer maintained, so self-hosting means Graphiti plus your own graph database, without Zep's higher-level features. Its current 90.2% and 94.7% are vendor-run with gpt-5.4 as reader and judge and no run date. Where it wins: temporal modelling, compliance, latency, deletion semantics, three-language SDKs. Where it does not: price transparency at scale, self-hosting parity, framework breadth, and the fact that you build the graph from source data rather than importing facts.

Letta is an agent runtime, not a memory layer, and the honest question before evaluating it is whether you want to adopt a framework. MemGPT is the 2023 Berkeley paper and open-source project that introduced core and archival memory tiers edited by the model through tool calls; Letta is the company and product that succeeded it, and the current harness is where those tiers became files. It was re-based in 2026 on a TypeScript-only Agent SDK wrapping the Apache 2.0 Letta harness, with memory as a git-versioned repository of Markdown files that the agent edits with file tools; files under system/ are pinned into every prompt, everything else is read on demand, and "dreaming" subagents consolidate in the background. There is no extractor, no entity resolution and no validity timestamps; the agent rewrites the file and git is the provenance, which makes it the only platform here with native review, diff and rollback. Pricing is per agent ($0.10 per active agent per month plus tool-execution seconds on the API plan, $20 Pro for 20 agents), and no SOC 2, HIPAA or GDPR statement appears on any Letta page we could find. Where it wins: autonomous, long-running and coding agents that should own and inspect their own memory, and a million-agent production reference in Bilt. Where it does not: as a drop-in for an existing Python stack, and for anyone who needs compliance attestations or a bi-temporal fact store.

Cognee is an Apache 2.0 Python engine (30.3k stars, with TypeScript and Rust clients) that builds a knowledge graph plus vector index over documents, code and conversations, with a managed cloud at $1.00 per million tokens and an Enterprise BYOC engagement. Its permission model is the deepest in the open-source group: tenants contain users, roles live inside tenants, datasets carry ACLs and route to their own physical stores, with access control on by default. Fact validity exists as a valid_to field you close explicitly, entity deduplication is an opt-in pipeline with a dry run, and forget reaches graph, vectors and session cache without an LLM call. It publishes no LongMemEval or LoCoMo figure; its BEAM report is unusually candid that the 100K result rests on twenty questions from one conversation. Compliance is GDPR under German law with no SOC 2. Where it wins: document- and graph-heavy institutional memory, permission depth, deletion, and an honest benchmark write-up. Where it does not: turnkey conversational personalisation, automatic contradiction handling in the open-source build, and attestations.

SuperMemory is a hosted memory-and-RAG API with an MIT-licensed local binary, standing user profiles, typed memories (facts persist until updated, preferences strengthen with repetition, episodes decay), an Updates relation that supersedes for search while keeping history, and the widest ingestion set on the page (audio, video, images, PDFs with OCR, Office files, Google Docs). Isolation is a single container tag with API keys that refuse to cross it. Pricing runs $19, $100 and $399, with SOC 2 of an unstated type and a HIPAA BAA from the $399 tier and searches at $0.005 per thousand. Its headline benchmark is 95% Recall@15 on LongMemEval, which is a retrieval metric and must not be read as accuracy; the 81.6% accuracy figure that circulates is no longer on its site. Where it wins: breadth of source ingestion, cheap search, a real free tier, an MIT local binary for offline development, and full-product self-hosting from the Scale tier. Where it does not: entity resolution (undocumented), hierarchy beyond one tag, and a published accuracy number.

Hindsight is Vectorize's MIT-licensed memory server, organised into world facts, experiences, observations and mental models with three operations (retain, recall, reflect), four retrieval strategies run in parallel and reranked, and a reflect call that reasons across memories with an LLM. It self-hosts from one Docker command, runs fully offline with Ollama, and its cloud is pay-as-you-go with no monthly fee. Its 94.6% on LongMemEval-S comes from Vectorize's own Agent Memory Benchmark with Gemini models answering and judging; it is append-only by design, with no endpoint to permanently delete an individual memory (invalidation hides it), scoping is one bank per user or agent, and no compliance beyond company-level SOC 2 Type II is published. Where it wins: institutional memory for agents that learn from repeated work, self-hosting, multi-strategy retrieval. Where it does not: framework adapters (none), hard deletion, hierarchy, and latency, where its own benchmark runs average 675 ms per retrieval.

LangMem and the LangGraph Store are the right answer for a team that has decided to live inside LangGraph. The Store is a namespaced JSON document store with optional embedding search and Postgres, MongoDB, Redis or Upstash backends; LangMem adds memory tools, a background manager and a prompt optimiser that is the clearest procedural-memory implementation on this page. There is no cloud product; the managed path is LangSmith Deployment. LangMem's last PyPI release was 27 October 2025. Nothing here does entity resolution, bi-temporal validity or GDPR-grade deletion; isolation is whatever your namespace convention enforces. Where it wins: ecosystem fit and zero new vendors. Where it does not: everything a platform is for.

Evermind EverOS is an Apache 2.0, local-first Python runtime that stores conversations, files and agent trajectories as Markdown with SQLite and LanceDB indexes, with user episodes and profiles on one track and agent cases and skills on another, a cloud in early access, and plugins for Claude Code, OpenClaw and Hermes. Its paper reports 93.05% on LoCoMo and 83.00% on LongMemEval with GPT-4.1-mini answering and a GPT-4o-mini-led judge panel. Memory is human-readable and git-diffable by construction. No compliance page, cloud pricing that could not be read from the page, and no entity resolution documented. Where it wins: portability, readability, procedural memory. Where it does not: production maturity and managed operation.

The cloud primitives are worth a paragraph because a CTO already on one cloud will be asked about them. AgentCore Memory is generally available with short-term memory at $0.25 per thousand events, long-term storage at $0.75 per thousand records a month with built-in strategies, and $0.50 per thousand retrievals, organised by actor, session and namespace. Google's Memory Bank moved to storage-plus-operations pricing from 1 September 2026, with regional or multi-regional placement and memory revisions. Foundry's memory is in public preview with user-profile, chat-summary and procedural types, no VNet integration, and preview terms. None of the three publishes a LongMemEval or LoCoMo figure, and all three tie your memory to the cloud that hosts it.

Maximem Synap is our platform, so here is the description we would want a competitor to give. It is a hosted memory service that reads the conversation as it arrives, works out what is worth keeping, and stores discrete, self-contained statements (facts, preferences, episodes, emotions, temporal events and others as they occur) with a confidence score, a scope, a storage time and an event time. Two calls: record the message, which returns immediately with extraction in the background, and fetch context, which returns a ranked block formatted for the prompt. The scope ladder (client, customer, user, plus conversation, extendable to any depth with your own rung names) is enforced at write time; entity resolution collapses "my manager", "Sarah" and "Sarah Chen" into one person and sends ambiguous matches to a review queue; updates never destroy detail or history; anticipatory retrieval pushes likely-needed context into an in-process cache so most reads return without a network call; a per-agent memory architecture is generated from a description of what the agent does, judged by two further models, and approved by a person before it applies; PII handling has a hard floor and eleven configurable categories with the limits published. There are Python and TypeScript SDKs, REST, a CLI, a hosted MCP endpoint and 23 framework adapters; managed cloud in US or EU regions by default, self-hosted and air-gapped for enterprise. Plans start at a free Trial and a $19 Starter, and every plan gets every memory capability, with bring-your-own-key from Pro and private deployment on Enterprise. Benchmarks: 92% on LongMemEval and 93.2% on LoCoMo, the first across the full 500-question set and the second across 1,540 questions in categories 1 to 4, with gpt-5-mini answering and gpt-5-mini judging on a binary correct-or-wrong scheme, single run, reproduced on our open harness. Where we win: scoping depth, lossless contradiction handling with provenance, in-conversation latency, framework breadth, and price at the entry tiers. Where we do not: SOC 2 Type II is in progress rather than held and HIPAA is not certified, so a compliance-led deal belongs to Zep today; bi-temporal validity is answered through history rather than through named fields; there is no procedural learning; no memory-export endpoint is documented; and our accuracy number is a vendor number like everyone else's, with the harness as the only argument we make for it.

Four other names come up in assistant answers and each has a specific reason to shortlist or drop it. Memvid is an active Apache 2.0 Rust engine that packs content, embeddings and index into a single .mv2 file, which makes it the right shape for edge and serverless deployments and the wrong shape for multi-tenant services, and its benchmark claims name no answer model or judge. MemoryLake is a token-metered multimodal memory product with a self-published LoCoMo harness and no numbers on its page, so it cannot be compared until it publishes conditions. Memora is a Microsoft Research codebase behind a paper, not a hosted product, and belongs in an evaluation rather than a procurement. Redis has moved its open-source Agent Memory Server behind a managed "Redis Iris" service, which is worth a look only if Redis Cloud is already your platform.

Which platform for which situation

Our situation table compresses this; the reasoning is short enough to give in full.

A customer-facing support or sales agent lives or dies on three things: the same customer arriving by chat, email and phone being one entity, the fact that changed in June overriding the one from March without losing the March detail, and a read that fits inside the turn. Synap is built around exactly those three; Mem0 gets you there fastest with a flat user model and a Pro tier for graph; Zep gets you there with the strongest temporal model and a compliance posture the account team will want.

A voice agent has a turn budget of roughly 800 ms end to end, and a memory read on the critical path has to be tens of milliseconds, not hundreds. That is the case for a pre-fetched, in-process cache, which is what Synap's anticipatory retrieval is for and why the LiveKit and Pipecat adapters preload context into the pipeline. Zep's published p95 under 200 ms fits if the read runs in parallel with speech recognition; a retrieval that averages several hundred milliseconds, as Hindsight's own benchmark runs do at 675 ms, does not, unless it is prefetched.

A multi-tenant B2B SaaS product needs the tenant rung enforced at write time, per-key scoping, and erasure that reaches derived copies. Synap's ladder and Cognee's tenant, role and dataset model are the two designs that give you a tenant object rather than a naming convention; SuperMemory's scoped container keys are the lightest workable version.

An autonomous, long-running or coding agent benefits from owning its memory, seeing the diff, and rolling back. Letta is the reference design, EverOS the portable one, Hindsight the one built for agents that learn from repeated work.

A consumer assistant or companion is a volume problem first: millions of users with small memories each, so the retrieval unit price and the free tier matter more than any feature row; SuperMemory's per-query search pricing is the cheapest published unit on this page, Synap's flat credit per retrieval is the most predictable, and Mem0's request quotas are the fastest first version but the first to hit a tier ceiling. It is a memory-type problem second, because a companion that remembers only facts feels like a form; SuperMemory's preferences that strengthen with repetition and episodes that decay, and Synap's emotion and episode statements, are the two designs that model what a person said and how they felt as distinct things. And it is a trust problem third: a consumer cannot audit a vendor, so a documented data floor (Synap never stores card numbers, passwords or biometrics regardless of settings) and a deletion path that reaches derived copies are the features to check before scale makes them expensive.

A regulated domain should start with the attestation, not the architecture: Zep for a SOC 2 Type II report and a HIPAA BAA on Enterprise, SuperMemory for a HIPAA BAA and a SOC 2 report of an unstated type from $399, Mem0 at Type I today. Synap's answer is an in-progress Type II, a DPA, EU residency and a documented data floor, which is enough for a GDPR-led review and not enough for one that needs a BAA.

A document- and relationship-heavy workload, where the questions are who is connected to what and when it was true, is where the graph earns its overhead: Cognee for documents and permissions, Zep and Graphiti for temporal relationships.

A team already on LangGraph should try the Store and LangMem before adding a vendor, and if the gaps (entity resolution, validity, deletion) bite, Mem0, Zep, Cognee, SuperMemory and Synap all ship a LangGraph adapter; Hindsight and Letta do not.

A self-hosted or air-gapped requirement rules out Zep Cloud and Letta Cloud immediately and rules in Hindsight, Cognee, Graphiti, Mem0 OSS without graph, and SuperMemory local; Synap self-hosts for enterprise engagements.

A small team on its first production agent should pick on what the $19 tier includes. Synap's Starter includes every memory capability; Mem0's Starter caps retrievals at 5,000 a month and gates graph to Pro; SuperMemory's Pro includes $20 of credit; Cognee's free tier includes a million tokens.

An enterprise with procurement should read three pages per vendor before any demo: the deletion page, the security page, and the pricing page's gating table.

How to run the bake-off on your own conversations

Take fifty of your own conversations and split each so that facts established early are needed late. That is the shape of both public benchmarks, LongMemEval (500 questions covering extraction, multi-session reasoning, temporal reasoning, knowledge updates and abstention, with a gpt-4o judge the authors report at more than 97% agreement with human experts) and LoCoMo (roughly 300 turns over up to 35 sessions per conversation). Run every vendor with the same answer model and the same judge, keep the judge blind to the vendor, and report error bars, because every omission in that sentence is one the 2025 LoCoMo dispute turned on. Then measure the things the benchmarks do not: update correctness (ask after a contradiction), abstention on a false premise, write-to-readable latency (every platform writes asynchronously), tokens injected per turn, cost per stored turn, cross-user leakage (query user A for user B's fact), and a second run over the same data to check the store is idempotent. Our harness does the first half of that list end to end (ingest, search, answer, judge, report, with Hit@K, Recall@K, MRR and NDCG beside judged accuracy and latency) against Synap, Mem0, Zep and SuperMemory, and exposes a provider interface and a benchmark interface for adding your own; the second half is a week of engineering that no vendor page, ours included, will do for you. The number that comes out of that week is worth more than anything in the accuracy table above.

What changed between 2025 and 2026

Five things, each on a primary page. Mem0 shipped a single-pass, ADD-only algorithm in April 2026 and its self-reported Platform scores moved from 71.4 to 92.5 on LoCoMo and 67.8 to 94.4 on LongMemEval (the 66.88% quoted earlier is the April 2025 paper's open-source figure; 71.4 is the pre-update Platform figure from the April 2026 blog), while the open-source SDK lost graph memory. Zep ended Community Edition, kept Graphiti open, moved to a proprietary graph service, and its current page shows 90.2% on LongMemEval and 94.7% on LoCoMo with gpt-5.4 on both sides. The hyperscalers arrived: AgentCore Memory went GA in October 2025, Google's Memory Bank re-priced from September 2026, Foundry's memory is still preview. Letta re-platformed onto files in git. And the benchmark conversation shifted from "who has the highest number" to "whose number means anything", helped along by an independent paper that scored a leading vendor's open-source SDK at 49.0% on a benchmark the vendor's platform scores at 94.4%. Synap's own LongMemEval figure, measured on the harness described in the accuracy table above with gpt-5-mini answering and gpt-5-mini judging, moved from 90.2% to 92% over the same period, and the fact that it moved is the reason every number on this page carries its conditions.

What this is worth

Technically, "best" resolves, in practice, to whichever platform's isolation model, update rule and deployment shape match your product, with accuracy as a tie-break you should measure yourself. The business implication is the one that gets a budget approved: an agent whose memory is scoped correctly stops leaking one customer's facts into another's session, an agent whose updates keep detail stops telling a patient the wrong dose, and an agent whose reads come from a cache stops making a caller wait. Those are the outcomes a memory platform is bought for, and none of them appears in a benchmark column.

Frequently asked questions

What is the best AI agent memory platform in 2026?

The one whose scoping model, contradiction handling and deployment shape match your product, chosen in that order, with accuracy measured on your own conversations rather than read from a vendor table. For a multi-tenant product that needs a tenant rung above the user, that narrows to platforms with a real hierarchy; for a compliance-led purchase, to platforms with a SOC 2 Type II report and a HIPAA BAA on the contract today; for an agent that should own and inspect its own memory, to runtimes with version-controlled files. The situation table at the top of this page applies those filters for eleven common cases.

Are the published LongMemEval and LoCoMo numbers comparable across vendors?

No. A score depends on the question set, the answer model, the judge model, the retrieval budget and the run date, and the vendors do not share any of them: one reports with gpt-4o defaults at a top-200 budget, another with gpt-5.4 on both sides and no date, a third with Gemini models on its own leaderboard. The same product has been scored at 84%, 75.14% and 58.44% on LoCoMo by two vendors arguing over settings. Treat any cell without all six conditions as unverified, and re-run the harness with your own judge.

Do I need a memory platform or is a vector database enough?

A vector database gives you nearest neighbours over whatever you chunked. A memory platform makes four decisions on top: what is worth writing, how a new fact reconciles with an old one, when a fact retires, and how results rank beyond similarity. If your history fits in roughly 30,000 tokens and latency and cost do not matter, stuffing the context is more accurate than any platform, on the vendors' own papers. Past roughly 100,000 tokens, or across sessions, or when someone asks why the agent believes something, the platform wins.

Which agent memory platforms can be self-hosted?

Decide first whether you need the full product on your own infrastructure or an open engine you will operate yourself, because the two lists differ. Full-product self-hosting is an enterprise arrangement at Zep (BYOC), SuperMemory (Scale tier and above) and Synap (including air-gapped). Engines you can run yourself under an open licence in the repo: Hindsight (MIT), Cognee (Apache 2.0), Graphiti (Apache 2.0, with your own graph database), Mem0's open-source SDK (Apache 2.0, without the Platform-only graph, decay and consolidation features), SuperMemory local (MIT) and EverOS (Apache 2.0). Zep Cloud self-hosts only as Enterprise BYOC, Letta as its open harness's local mode, and Synap as an enterprise engagement including air-gapped deployment.

How does an agent memory platform handle contradictions?

Three ways. Additive designs store the new fact beside the old one and rely on ranking and scheduled consolidation to surface the current one, which is cheap and risks stale facts surfacing. Invalidating designs keep the old fact with an end timestamp and provenance to the episode that superseded it. Lossless designs add a rule that a newer statement which is poorer than the one it resembles never replaces it, and record what changed and why. Ask any vendor to show you what happens to "20mg of Atorvastatin daily" when a later turn says "a cholesterol medication".

What does agent memory cost at scale?

It depends on the unit. Ingestion-metered platforms charge nothing per retrieval but carry a paid floor; request-quota platforms cap retrievals per tier with unpublished overage; token-metered platforms cannot be priced per retrieval without knowing tokens per query; credit-based platforms price a retrieval at a fixed one to three credits. A million retrievals a month ranges from free with a $125 floor to about $1,400 on a flat-credit plan, and is not computable at all on several vendors' published units. Model the write path too: the extraction call per stored turn is the cost nobody benchmarks.

Sources: every vendor page, repository, paper and framework document cited inline was retrieved on 10 September 2026, with the pricing, licence and benchmark figures re-checked on 18 September 2026. Maximem product statements come from Synap's published documentation. Corrections to any figure are welcome at the address in the footer and will be applied with the previous value left visible.