Best Zep Alternatives for Agent Memory, by Why You Are Leaving (2026)

The rest of this page is the evidence behind that table, and it is organised so you can read only the row that applies to you.

There is no single best Zep alternative, because the eight reasons teams give for leaving Zep want different replacements, and the most common way to get this decision wrong is to read a ranked list instead of working out which reason applies to you. If you are leaving because you must self-host, the answer is probably Graphiti, which is Zep's own engine under Apache 2.0, and no third-party product. If you are leaving because ingestion costs too much at your volume, the answer is a vendor that meters reads instead of writes, and Zep is already the cheapest read path in the category. If you are leaving because you need documents, images or audio in memory, almost anything else will do, because Zep accepts message, text and JSON only. And if you are leaving because you need bi-temporal validity with named fields or a HIPAA business associate agreement, you should probably not leave at all.

That last point deserves to be up front rather than buried. Zep is the compliance and governance leader of this category, and the only vendor here that publishes accuracy and read-path latency with both percentiles on the same page. Any honest alternatives page has to start by saying what leaving costs, and this one does, below.

No alternative on this page matches the whole package. Here is the specific list, from Zep's own pages.

A fact's whole life, in four named fields. created_at is "the time Zep learned that the user got married", valid_at is "the time the user got married", invalid_at is "the time the user got divorced", and expired_at is "the time Zep learned that the user got divorced". Two axes, four fields, and every fact carries them, which is what makes "what did we believe in March" a query rather than a research project. Cognee has a lighter single-field version and gates the full bi-temporal model to its Enterprise engagement; nobody else on this page has it at all.

Accuracy and latency on the same page, with percentiles. Zep's performance page publishes "sub-200ms context retrieval regardless of graph size or number of graphs" along with "155ms retrieval latency on LoCoMo (94.7% accuracy) and 162ms on LongMemEval (90.2% accuracy)". Its research page goes further and publishes both percentiles: 87 ms p50 and 155 ms p95 on LoCoMo, 104 ms p50 and 162 ms p95 on LongMemEval, with reader and judge both named as gpt-5.4 (reasoning medium for the reader, chain of thought for the judge) and per-category breakdowns, a statement that it ran all 1,540 LoCoMo questions and all 500 LongMemEval questions, and 1,459 and 451 of them answered correctly. The one condition missing from that page is the run date. That is more than any other vendor in this comparison publishes, and the plain fact is that Zep publishes read-path percentiles at all, which several comparison pages, including our own earlier one, denied.

The compliance package. "Zep maintains SOC 2 Type II certification", with a live status page. Business associate agreements are available for Enterprise customers. Bring-your-own-key uses your own AWS KMS customer master key with "full control over encryption keys, including revocation". Bring-your-own-cloud is "Zep deployed inside your own VPC for a full network and compliance boundary". Access control runs to attribute-based, role-based and policy-based models with enterprise single sign-on. Retention is policy-driven, "data expires on the schedule you set", and "legal hold blocks deletion when compliance requires it". Audit logs cover "every request and policy decision", with thirty days of history in the dashboard, a year in cold storage for Enterprise customers, and seven years for Enterprise customers who have signed a HIPAA business associate agreement. API request logs are a separate schedule, running from one day on Flex through seven days on Flex Plus to a year on Enterprise.

Deletion you can reason about. Deleting an edge "never deletes the associated nodes, even if it means there will be a node with no edges". Deleting a node "will also delete all edges connected to that node", a cascading delete. Deleting an episode removes edges and nodes "only if no other episodes are associated with them". Deleting a thread removes its episodes and cascades. And a caveat worth knowing before you promise an erasure timeline: "for user graphs, the user entity node is never deleted, even if all episodes are removed."

An explanation of why the extractor decided what it decided. Debug Mode captures episode workflow logs, and Ingestion Traces "explain why selected LLM stages produced each decision during graph construction", kept 30 days. No competitor on this page documents anything equivalent. The window is 60 minutes on standard plans and 24 hours on Enterprise, traces are unavailable on Free, and per-episode debug logs do not cover batch ingestion.

If two or more of those five are load-bearing for you, the rest of this page is a cost analysis of a decision you should probably not make.

The most common real alternative to Zep Cloud is Zep's own engine, and it is missing from almost every alternatives page including the one this replaces. If your reason for leaving is that Community Edition went away and you must run memory on your own infrastructure, this is the first thing to evaluate, because it keeps the entire temporal model.

What you keep: typed entities and edges defined through Pydantic models, all four validity timestamps, incremental episode ingestion, and hybrid retrieval that combines semantic embeddings, BM25 keyword search and graph traversal. Apache 2.0, no usage meter, and you can point extraction at a local model.

What you give up is long and worth reading in full, because Zep's own comparison is candid about it. There are no built-in users, threads or message storage as primitives. There is no pre-assembled Context Block and no context templates. There is no Context Graph Engine, so in Zep's words performance "depends on your setup" rather than staying under 200 ms at scale. There is no SOC 2 Type II, no HIPAA BAA, no bring-your-own-key, no bring-your-own-cloud. There is no attribute-based or role-based access control, no UserGroups, no policy sets, no enterprise single sign-on. There is no policy-driven retention, no legal hold, no audit or API logging. There is no Debug Mode and no Ingestion Traces. There is no Batch API, no zep-ingest, no webhooks, no graph cloning, no graph directory, no document summaries, no thread summaries. There is no hosted MCP server, no dashboard and no graph visualiser. And there is no service level agreement and no support.

Infrastructure you take on: a graph database, an LLM provider for extraction, an embedding provider and a reranker. Put a number on that before you commit. A managed Neo4j AuraDB Professional instance starts around $65 per gigabyte per month, against Hindsight's embedded Postgres and Cognee's embedded Kuzu and LanceDB, which need no separate database at all; Hindsight's full container image is roughly 9 gigabytes and its local reranker wants a GPU in production. And self-hosting moves the extraction bill to your own model account rather than removing it, so the saving is the vendor's margin on credits, not the cost of the LLM calls.

One thing to be careful about, because it is the mistake self-hosters make most often: Zep's published numbers do not transfer to Graphiti. The 94.7 percent on LoCoMo, the 90.2 percent on LongMemEval and the 155 and 162 millisecond latencies are published as Zep Cloud results measured against the Context Graph Engine. Graphiti's own README says performance depends on your setup, and Graphiti's repository contains no evaluation or benchmark directory at all. If you self-host Graphiti and your latency is 600 ms, you have not misconfigured anything; you are simply not running Konig.

Graphiti is the right answer when you need the temporal model and not the governance package, when you must self-host or air-gap, when your ingestion volume makes per-episode credits worse than operating a graph, or when you already run Neo4j or Neptune for something else.

Temporal validity#

Only Zep and Graphiti have four named fields. Cognee has a single valid_to stamp you close explicitly, persisted today only on one backend, with the full bi-temporal model gated to Enterprise. Mem0 has timestamps, a Platform-only temporal boost at search time and an expiry date that hides rather than deletes. SuperMemory tracks a latest flag and an updates relation. Synap records storage time and event time and keeps a lineage from a deprecated statement to its successor. Hindsight records when events occurred and uses it for temporal search but documents no validity end date. Letta, LangMem and Evermind have nothing here. If the question your product asks is "what was true on the fifteenth of March", this axis is the whole decision and you should stay on Zep or run Graphiti.

Graph or flat, and who operates it#

The graph earns its keep on three things Zep's own authors name: validity windows, provenance back to the episode, and multi-hop relationship queries. It costs you an operational dependency if you self-host and a per-episode extraction bill either way. A flat statement store has the mirror-image trade: a fact involving four participants survives whole as a sentence, and you cannot ask which approvals a given person made for a given office, because the relationship lives inside the sentence rather than in queryable endpoints. Neither is better. The question is whether anyone on your team has ever needed the second kind of query.

Price, with one worked volume#

Compare meters, not entry prices, because the meters point in opposite directions. Take a stated month: 100,000 episodes of about 350 bytes each, which is roughly 8.8 million tokens, plus 10,000 retrievals.

On Zep that is 100,000 credits and zero for the reads, which is half of a Flex Plus month at $375, or Flex at $125 plus five overage blocks of 10,000 at $25, which is $250. On Mem0 the 100,000 adds exceed Starter's 50,000 so you are on Pro at $249, and the 10,000 reads would have exceeded Starter's 5,000 cap anyway. On Cognee Standard at $1.00 per million tokens, 8.8 million tokens is about $8.80. On SuperMemory, ingestion at $0.005 per thousand plain-text memory tokens is about $44, plus $0.05 for 10,000 searches. On Synap, ingestion at the two-credit floor is 200,000 credits plus 10,000 for fast reads, which is 210,000 credits: Pro at $249 covers 150,000, so $249 plus 60 overage blocks of 1,000 at $1.75 is about $354.

The lesson is not the ranking, which will invert with your read-to-write ratio. It is that a token-metered vendor is cheapest for bulk text, a read-metered vendor is worst for a chatty agent, and Zep's per-episode rule makes batching worth more than switching: ten turns sent singly cost ten credits and the same ten turns in one episode cost four.

Read path#

Zep publishes the tightest figures with the fewest missing conditions: sub-200 ms context retrieval regardless of graph size on its performance page, and 87 ms p50 with 155 ms p95 on LoCoMo and 104 ms p50 with 162 ms p95 on LongMemEval on its research page. Mem0's 2026 table shows 0.88 seconds p50 on LoCoMo and 1.09 on LongMemEval at a top-200 budget, with no p95. SuperMemory states under 300 ms with no percentile and about 100 ms more when reranking. Hindsight's own benchmark runs average 675 ms per retrieval. Cognee, Letta, LangMem and Evermind publish no read-path percentile. Synap publishes an asserted in-conversation P75 under 15 ms served from a pre-fetched in-process cache, and a cold-retrieval P95 of 450 ms as a target. For a voice agent, where the maintainers of Pipecat advise aiming at 800 ms median voice to voice, everything on that list except the second-scale figures fits if the read runs off the critical path.

Entity resolution#

Five vendors document it and they differ in how they decide, which matters because this is the capability that makes one person one person across channels. Graphiti runs an LLM deduplication step at ingest whose prompt returns a duplicate candidate identifier or minus one for each extracted entity, and supports developer-defined entity types. Hindsight matches on trigram similarity with a 0.15 candidate threshold and a 0.5 in-batch merge threshold reinforced by co-occurrence, and its own documentation warns that a short new name can be absorbed into an existing entity by mistake. Cognee ships an opt-in consolidation pipeline clustering entity names at 0.85 cosine similarity with a dry-run mode. Mem0 stores each entity once and embeds it so differently phrased references can match, with no threshold or review control described. Synap matches in order exact, alias, semantic and contextual, narrowest scope first, and routes ambiguous matches to a dashboard review queue rather than guessing. SuperMemory, Letta, LangMem and Evermind document nothing here, which for a support agent that meets the same customer by chat and by email is a real gap rather than a missing row.

The write path, and the gap nobody plans for#

Every vendor here writes asynchronously and the gap is bigger than the read latency everybody compares. Zep's own documentation says ingestion "can take a few minutes" and that the context string "can omit recent information during that time", with the documented mitigation being to include the last four to six session messages in every call and to pass a flag that returns context on the write to save a round trip. Mem0 returns an event identifier with a pending status you poll. SuperMemory documents a six-stage pipeline with an instant mode that costs extra. Synap's documentation says a memory written now is not retrievable a second later. Cognee, Letta and Hindsight publish no figure. Whichever you pick, a production agent reads the live buffer for the current turn and the memory layer for everything before it.

On write cost: Zep meters by episode size, which makes batching a first-order lever, because ten turns of 120 bytes cost ten credits sent singly and four credits sent as one episode. Mem0's April 2026 algorithm is a single extraction pass. Cognee's cognify makes two LLM calls per chunk. Hindsight runs one call per chunk with prompt caching on by default. Synap meters ingestion at two credits or one per 500 tokens, whichever is larger, and moves the model calls to your own provider account with bring-your-own-key from Pro. Two of those numbers are per chunk rather than per document, which is the detail that decides the bill: Cognee's two calls apply to each chunk against a 3,000-token ceiling, so a 10,000-token document is about twenty calls, and Hindsight's one call per chunk defaults to a 3,000-character chunk. Where the vendor meters instead of counting calls, the meter tells you what to expect: Cognee at $1.00 per million tokens processed, Hindsight at $10 per million tokens retained. Bringing your own model key, which Synap offers from Pro, moves that spend to your provider account rather than removing it. One widely repeated claim, that Zep's graph construction costs around 600,000 tokens per conversation against Mem0's 1,764, has no primary source: it appears in one condensed article and Zep publishes no token-per-conversation figure. We are not using it and neither should any page that cannot source it.

Who decides what gets written, and does the store improve on its own#

Two axes that no comparison table carries and that decide how the system behaves in month six.

Who writes. On Zep, Mem0, Cognee, SuperMemory and Synap the platform's extractor decides, and your steering is configuration: Zep's ignore_roles to keep whole roles out of the graph and custom entity types to constrain what extraction looks for, Mem0's project-level custom instructions and per-call include and exclude hints, Synap's per-agent memory architecture generated from a description of the agent's job and approved by a person before it applies. On Letta and LangMem the agent decides, editing memory with tools, which fails by omission and drift rather than by over-collection. No vendor here documents a human approving an individual memory before the write lands, except Letta's optional review of proposed updates during its background consolidation.

Whether the store improves. On Zep, improvement happens at write time and only at write time: the graph is reconciled as episodes arrive and nothing revisits it afterwards. Several alternatives do revisit. Cognee's Memify stage enriches after ingestion and prunes stale relationships, and improve() is a named operation. Hindsight's third verb beside retain and recall is reflect, which reasons across stored memories with a model rather than returning a ranked list. Letta runs background subagents that review recent conversations and consolidate lessons. LangMem has a background manager and, uniquely in this set, a prompt optimiser that rewrites the agent's own instructions from scored trajectories, which is procedural memory rather than factual. Evermind keeps agent cases and skills as a first-class track beside user episodes. Synap works on stored memory at three cadences, a light pass every few hours, a deeper one daily, and consolidation with conscious forgetting during your product's quiet hours. If your agent does the same job repeatedly and should get better at it, that capability is on this list and it is not on Zep's.

What stops the store filling with junk. Mem0 offers an expiry date that hides a memory and an opt-in decay re-ranker that dampens stale memories without filtering them out. Cognee has explicit pruning and Memify's stale-relationship cleanup. SuperMemory decays typed memories, with episodes dropping out and preferences strengthening. Synap prunes during the sleep cadence and compacts a conversation once it passes 3,000 tokens, ten messages or five idle minutes. Hindsight is append-only and prunes nothing. Zep invalidates rather than deleting and, on Enterprise, expires on a policy you set. Nobody in this comparison publishes a measurement of how precision degrades as a store grows, which means you will have to measure it yourself on whichever you choose.

Prompt injection through memory#

This is the axis nobody puts in a comparison table and Zep is the only vendor here with a documented position, which is worth knowing before you treat it as a reason to leave. Zep's docs devote a section to it: the context string "can contain text from end users, documents, tools, or other external sources", so it must be passed through the provider's untrusted-data channel and never in a system or developer message, with per-provider instructions for the OpenAI and Anthropic APIs, and the standing rule to "keep both forms of context out of privileged instruction channels". OWASP's Top 10 for Agentic Applications lists memory and context poisoning as ASI06 for exactly this reason. One other vendor takes the problem seriously from the other end. Vectorize publishes an ASI06 explainer, and Hindsight ships Memory Defense, a per-bank write-path policy: a 44-pattern regex screen in the open build, and a seven-stage pipeline in the cloud enterprise tier with an LLM screening step, prompt-injection detection and HMAC-signed webhooks to your security monitoring. That is a control on what gets written rather than guidance on where retrieved memory is placed in the prompt, and the two are complements rather than substitutes: you want Zep's placement rule and Hindsight's write filter. We could not find either kind of guidance in the documentation of Cognee, SuperMemory, Letta or, for that matter, our own, which is an absence of documentation rather than proof of absence, and a fair question to ask any vendor on this list including us.

Scoping#

Zep has users, threads, user graphs, standalone graphs and UserGroups carrying policy sets, with attribute-based, role-based and policy-based access control and enterprise single sign-on, and no tenant object. Mem0 has four identifier tags with app_id as the documented tenant handle and organisations and projects as an API-key construct. SuperMemory has one container tag that keys cannot cross. Hindsight has one bank per user or agent. Cognee has a real hierarchy. Synap has the client, customer, user ladder enforced at write time and extendable. If your reason for leaving is a tenant rung, Cognee and Synap are the two designs with a tenant object rather than a naming convention; if your reason is access control, nothing here matches the depth of Zep's policy models, although Cognee and Synap are the only two that enforce a tenant boundary at write time.

Several agents on one user, and who can fix a wrong memory#

Nobody in this field sells a multi-agent feature; they all do it with identifiers, and the shapes differ enough to matter if that is your reason for moving. Zep's unit is the user graph, shared by construction, plus standalone graphs as a first-class home for knowledge several agents read, with UserGroups and attribute-based access control limiting what each agent's key reaches; UserGroups are a security grouping rather than a shared write pool. Mem0 puts agent_id beside user_id, so two agents share a user by convention and there is no shared-pool primitive. Letta is the only one with an explicit shared-memory object, organisation-owned git repositories that cloud agents clone, commit to and pull, with local agents excluded. Synap's client and customer rungs are the shared tier, with agent-specific memories below and the scope chain handling isolation. The problem none of them solves is two agents writing contradictory facts about the same entity: every vendor here reconciles writes against the store, and none reconciles between agents' authority.

Fixing a wrong memory by hand is the adjacent question and the answers are thinner than anyone expects. Zep deletes edges, nodes and episodes by identifier, and never the user entity node. Mem0's history endpoint is read-only, returning the event type with the old and new text and the triggering messages, with no rollback call. SuperMemory versions an update and marks the original with a latest flag of false. Cognee has a graph visualiser and an optional provenance ledger. Letta and Evermind are files in git, so correcting a memory is an edit and a commit. Synap shows in the dashboard what a statement replaced and why, with audit logs retained 90 days, and documents no direct editing of an individual memory. If "a support lead needs to correct a wrong fact this afternoon" is a real requirement, the file-based products are the only ones that answer it cleanly.

Who is actually running this#

Named production references are thin across the whole category, which makes the specific ones worth more than they look. Cognee names Bayer for scientific research workflows, the University of Wyoming for policy-document analysis with page-level provenance, and dltHub, alongside "70+ companies" and pipeline growth from about 2,000 runs to more than a million in a year. Letta publishes a Bilt case study describing over a million agents in production. Mem0 publishes usage rather than customers: 35 million API calls in the first quarter of 2025 rising to 186 million in the third. SuperMemory claims more than 100,000 organisations, unaudited. Zep's own testimonials are unnamed. And one absence is worth stating plainly, ours included: no vendor on this page publishes a reference customer who migrated off Zep, so there is no case study to read before you become the first one.

Ingestion breadth#

Zep takes message, text and JSON, caps a single graph write at 10,000 characters, and states that it "does not process text directly from links or files". There is no image path and no audio path. JSON is the documented route for business records, so CRM rows, tickets and billing events do go in, so the accurate criticism is not that Zep is text only. It is that Zep exposes no hosted connectors to source systems, no image path and no audio path. Files do reach it, through zep-ingest, Zep's own Python package, whose loaders read documents, transcripts, email, Slack exports and CSV or JSON records from a path or a glob and submit them as episodes. Cognee and SuperMemory are the breadth leaders; Cognee lists code in 30 languages, text, CSV, images, audio, video, PDF, Office, HTML, email and EPUB. Synap accepts the common document and image formats plus audio through speech to text, with seven first-party connectors.

Deletion, and what each alternative actually reaches#

Zep's cascade is documented per object, as above. The alternatives: Mem0 deletes by filter on its identifiers, queues the work, states that this satisfies user erasure, and does not document what happens inside the entity store or the history log. Cognee's forget() reaches graph nodes, edges, vector embeddings and the session cache without spending a model call, keeps nodes another document still references, and leaves raw files unless you prune. SuperMemory's forget is a soft delete that marks a memory forgotten, with no hard-delete page found; deleting a container tag removes everything in it. Hindsight is append-only with no endpoint to permanently delete an individual memory, only invalidation that hides it, which is the wrong shape if erasure is your reason for shopping. 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, and destroys the per-account key for protected values so backups become unreadable. No vendor here issues anything like a deletion certificate; proof is an audit log plus a re-query.

Observability#

The claim worth being precise about is that nothing matches Zep's Ingestion Traces specifically, not that nothing else is observable. Mem0 gives a per-memory history endpoint returning the event type with the old and new text and the triggering messages, plus a project event feed and a dashboard on both the Platform and the self-hosted stack. Hindsight ships a Control Plane with recall traces and an audit trail on invalidation. Cognee has an optional provenance ledger, a contradiction-detection flag, a Sessions view for agent runs and a graph visualiser. SuperMemory exposes request and error logs and versions every update. Synap logs every action with a principal and a correlation identifier, retained 90 days and exportable on Enterprise, and shows what a statement replaced and why. What none of them does is explain why a particular extraction stage made a particular decision, which is the thing Zep's traces do.

Maturity and vendor risk#

The number worth acting on is not stars or funding but whether the vendor has already taken something away, because that is the behaviour that repeats. Two here have: Zep deprecated Community Edition, and Mem0 removed graph memory from its open SDK. Price that base rate into whichever you choose, keep your raw source data so you can leave, and read the rest of this paragraph as context rather than as a ranking. Mem0: Apache 2.0, roughly 63,000 stars, $24 million announced October 2025, packages shipped September 2026. Cognee: Apache 2.0, roughly 30,000 stars, $7.5 million seed announced February 2026, shipped September 2026. Graphiti: Apache 2.0, roughly 29,000 stars, package shipped September 2026; Zep itself publishes no funding round. SuperMemory: MIT repository, roughly 30,000 stars, $3 million. Letta: Apache 2.0, $10 million seed from September 2024, with its main repository now a landing page pointing to a second one. Hindsight: MIT, inside Vectorize, whose last announced round is a $3.6 million seed from October 2024. LangMem: MIT, roughly 1,700 stars, last release October 2025, which is the oldest in this set.

MCP servers and coding agents#

If part of why you are moving is that you want memory inside Claude Code or Cursor, most of the field now answers. Zep runs a hosted Memory MCP Server with twelve tools, sold by seat at one seat on Free, five on Flex and fifteen on Flex Plus, and Graphiti ships an open-source MCP server in-repo. Cognee's cognee-mcp runs locally over HTTP, server-sent events or stdio with plugins for Claude Code, Codex and Cursor, and it is included in the free tier. SuperMemory hosts one with plugins for Claude Code, Cursor, Codex and OpenCode. Hindsight has a built-in endpoint per memory bank. Mem0 hosts one with eleven tools, free with an API key. Synap's hosted endpoint exposes four tools and holds no secrets, taking the API key per request. Letta is the exception and the reason is structural: its SDK is an MCP client rather than a server, because Letta is the coding agent.

What each vendor gates behind a paid tier#

The gates are the most decision-relevant lines on a pricing page and they are rarely where comparison tables put them. Zep gates the whole compliance and governance package: the HIPAA BAA, bring-your-own-key, bring-your-own-cloud, and Ingestion Traces, which are unavailable on Free, with the debug window at 60 minutes on standard plans and 24 hours on Enterprise. Mem0 gates graph memory and entity linking, Dream's synthesis, multi-project support and analytics to Pro at $249, and audit logs, on-premise deployment and single sign-on to Enterprise. Cognee gates the managed connectors and code indexing to Standard, and gates bi-temporal memory with conflict resolution, provenance on every answer and per-user personalisation to the Enterprise engagement, which is the single most important gating fact on this page for anyone treating Cognee as the temporal-model replacement. SuperMemory gates plugins to $19, the Gmail connector to $100, and SOC 2, the HIPAA BAA and the self-hosted option to $399. Hindsight gates nothing in the open build by its own claim, except that the deeper tier of its write-path filtering is a cloud enterprise feature. Synap's tiers differ on volume and service level with every plan getting every memory capability, the exceptions being bring-your-own-key from Pro and the enterprise service items. Graphiti, Letta's harness, LangMem and EverOS gate nothing because there is nothing above them to gate.

Compliance#

The criterion here is binary rather than comparative: either a name on your contract requires an attestation or it does not, and if it does, this axis ends the conversation before the architecture starts. Ranked on what is actually held: Zep, then SuperMemory at $399, then a gap. Zep is SOC 2 Type II with a HIPAA BAA on Enterprise, bring-your-own-key, bring-your-own-cloud, policy retention, legal hold and audit retention to seven years. SuperMemory lists SOC 2 and a HIPAA business associate agreement from its $399 Scale tier, without naming the report type on that page. Vectorize is SOC 2 Type II at company level for Hindsight. Mem0 states SOC 2 Type I with HIPAA described as "ready". Cognee holds neither SOC 2 nor ISO 27001 and says so. Letta publishes no security page. Maximem Synap has SOC 2 Type II in progress with a Q3 2026 target, GDPR and CCPA compliance with a DPA, HIPAA not certified, and two regions.

Benchmarks, with conditions#

Read this as a warning about the genre. Zep publishes 94.7 percent on LoCoMo and 90.2 percent on LongMemEval. Which conditions you get depends on which Zep page you read: the performance page gives the two figures bare, while the research page names gpt-5.4 as both reader and judge, gives per-category breakdowns and states the question counts, and omits only the run date. Its January 2025 paper is the origin of the 63.8 percent figure that half the category still quotes: that is Zep's own result with gpt-4o-mini on the LongMemEval-S subset of roughly 115,000 tokens, against a full-context baseline of 55.4 percent, and the same paper's gpt-4o figure is 71.2 percent against a baseline of 60.2. Every page that labels 63.8 percent as "GPT-4o" is wrong, and every page that calls it third-party reported is also wrong, including the earlier version of this one. Zep's paper also published its notebooks: they are in the getzep/zep-papers repository under kg_architecture_agent_memory/, two of them, covering DMR and LongMemEval, which makes "Zep has no open harness" false as well.

Mem0 publishes 94.4 percent on LongMemEval and 92.5 on LoCoMo for its Platform at a top-200 budget, with harness defaults it does not restate, while the only independent run of its open-source SDK scored 49.0 percent using different models a month before its algorithm changed. Hindsight has two figures from two runs. Cognee publishes BEAM only. SuperMemory's headline is a recall metric. Evermind publishes LoCoMo 93.05 and LongMemEval 83.00 with GPT-4.1-mini. Synap publishes 92 and 93.2 with gpt-5-mini on both sides, single run, on a public harness.

It is worth knowing what each instrument measures, because the choice of benchmark is itself a claim. LongMemEval is 500 questions across five abilities, information extraction, multi-session reasoning, temporal reasoning, knowledge updates and abstention, including 30 false-premise items the system is supposed to refuse, with a gpt-4o reference judge the authors report at over 97 percent agreement with human experts. LongMemEval-S is its long-context subset at roughly 115,000 tokens per question, which is the variant Zep's paper used. LoCoMo is 1,540 questions over persona-grounded conversations once the adversarial category is excluded, and independent analysis puts a roughly 6 percent ground-truth error rate on it. BEAM is the long-horizon instrument, running from 100,000 to 10 million tokens, which is where accuracy degradation shows up and where Cognee and Mem0 both publish. HaluMem measures hallucination rather than recall. Match the instrument to your risk: if your failure is a stale fact, look at knowledge-update scores; if it is a long-running agent, look at BEAM; if it is a confidently wrong answer, no accuracy number on this page tells you anything and HaluMem is closer.

Nothing in that paragraph is comparable with anything else in it. Demand six conditions per cell before you weight any of it: benchmark and variant, question count, answer model, judge model, run date, and who ran it.

Two weeks, and the shape matters more than the length. Take fifty of your own conversations and split each so that facts established early are needed late, which is what both public benchmarks do. Run Zep and your candidate with the same answer model and the same judge, keep the judge blind to which system produced the context, and report error bars.

Then measure the write path, because it is the half that comparisons skip and the half that fails in production. The clearest statement of this in the whole category comes from one of the incumbent pages rather than from a vendor: retrieval is only half the problem, and production teams also have to ask how facts are extracted, how conflicts are resolved, how stale memories are retired, how sensitive data is deleted, and how tenant permissions are preserved. So measure: update correctness, by asking a question after a contradiction; abstention on a false premise; write-to-readable latency, which on Zep is minutes rather than milliseconds; tokens injected per turn; cost per stored turn at your actual read-to-write ratio; and cross-tenant leakage, by querying one user for another user's fact. Our eval harness is MIT-licensed and covers the accuracy half end to end with an interface for adding providers; the write-path half is a week of your own engineering and no vendor page will do it for you.