Six agent-memory systems publish no error rate for deduplication — and none can undo a merge

TL;DR

• Six shipping agent-memory systems, read at pinned commits, re-derived blocking windows, thresholded matching and MinHash/LSH. None publishes an error rate for the merge decision; none records which two records were fused, so none can reverse it.
• Thresholds are hardcoded — 0.95, 0.9, 0.8, 0.6 — none derived from a stipulated false-link or false-non-link rate, as Fellegi–Sunter required in 1969.
• LongMemEval's knowledge-update subset is graded end-to-end, and its grader prompt scores a response correct when it carries the superseded value alongside the new one — by design. "Store both and rank the newer one" is therefore indistinguishable from correct invalidation.

Entity resolution is the task of deciding whether two records refer to the same real-world entity despite missing, inconsistent, or differently written identifiers. Under that name, and as record linkage and deduplication, it has a continuous literature from 1946. The agent memory systems below rebuilt much of that stack without the two artifacts that made it accountable: a stated error rate at the merge threshold, and a merge record that makes a wrong one reversible.

The thesis is falsifiable. Name one agent-memory system, installable or purchasable today at a version you can pin, that publishes a false-merge or false-split rate at its threshold, or that can reconstruct from its own store which two records were fused and undo it — or one hosted platform whose public documentation states such a rate.

This is a dated source review, not an execution benchmark.[^versions] Nothing was executed; claims come from those commits, vendor docs and maintainer reports, and every negative is scoped to those six systems and those sources. The hosted platforms — Mem0 Platform, Zep Cloud, Letta Cloud — are closed, read from client types and docs only. Cognee, LangMem and most GraphRAG findings are single-reviewer and uncorroborated; every vendor benchmark delta is a self-report. Removing a conflict resolver you cannot verify is defensible engineering; the gap is that no published measurement says what it cost.

What happens when the second fact arrives

Inside the wider vendor landscape, the six take paths ranging from an LLM-arbitrated ladder to no conflict decision at all — three of them make none.

	Who decides, and when	What happens to the old item	Entity resolution?
Mem0 (OSS)	Nobody, for conflicts. At write: MD5 hash, a prompt line, entity gate cosine ≥ 0.95	Untouched — both facts stored. update()/delete() are off the add() path	Partial: exact name, else cosine ≥ 0.95. Links entities; never merges memories
Zep/Graphiti	Deterministic ladder, then LLM; for contradictions an LLM nominates, a ~30-line rule decides	Edges never deleted (invalid_at set); losing node never persisted; summary overwritten	Yes, the most developed of the six: top-15 name embedding at floor 0.6 → entropy gate → MinHash/LSH Jaccard ≥ 0.9 → LLM
Letta	The agent, via string-edit tools, plus a sleep-time agent every 5 turns by default	Overwritten in place by default; opt-in git-backed blocks keep full history, and the BlockHistory undo table has no production writer	None in the OSS path
GraphRAG	Exact uppercased string match at index time; conflicts get one prompt sentence	New LLM summary; descriptions arrive alphabetically sorted, undated	No. The paper: "exact string matching for entity matching"
Cognee	Nobody. Identity = uuid5 of a lowercased name; storage = blind Cypher SET	Destroyed. First description wins in a run; last write wins across runs	No by default. Opt-in difflib cutoff 0.8
LangMem	Nobody in the store (put = blind overwrite); an LLM runs over a top-5 window	Destroyed — LangGraph's InMemoryStore resets created_at	None. No entity model

Mem0's docs are explicit: "New facts are stored alongside old ones. Nothing is overwritten or deleted" (Mem0). DEFAULT_UPDATE_MEMORY_PROMPT survives, reachable only from tests; expiration_date is caller-supplied and never filled. A maintainer closed mem0#4896 as by-design: "Both memories being stored is intentional — the historical record has value…" Platform Temporal Reasoning is not inspectable from source.

Graphiti computes the merge record and discards it. add_episode unpacks nodes, uuid_map, _ = await resolve_extracted_nodes(...); the one helper preserving duplicates has zero callers; the bulk path keeps them in memory only, to compress UUIDs; filter_existing_duplicate_of_edges is called only from a test; nothing in graphiti_core creates an IS_DUPLICATE_OF edge. A false entity merge is neither auditable nor reversible from the graph — whether that path was removed deliberately or lost in a refactor is unverified.

GraphRAG's removal was explicit: a maintainer wrote in Discussion #778 that the setting was "left over from an entity resolution step we had in the codebase but were not happy with" — still gone at v3.1.1. Letta's OSS write path contains no contradiction check at all. The only mention of contradiction anywhere in the package is a line in one architecture's background prompt — "Remove or correct outdated or contradictory information," in the voice sleep-time agent's system prompt. Its docs give the sleep-time agent "splitting large files, merging duplicates, or restructuring the hierarchy" (Letta docs) — an LLM subagent's task (why agent memory needs sleep), not a check in the write path.

Letta is nonetheless the one exception on recoverability. BlockHistory stores "a single historical state of a Block for undo/redo functionality" — a full value snapshot with a sequence_number — and BlockManager implements checkpoint_block_async, undo_checkpoint_block and redo_checkpoint_block over it; an opt-in git-backed manager (agent tag git-memory-enabled) commits every block write with history and point-in-time reads. But nothing in letta/ calls checkpoint_block_async outside its own definition — the callers are tests — so the default undo stack stays empty. And what it recovers is overwrites, not merges: Letta matches nothing, so it has nothing to un-merge. Automation and recoverability run in opposite directions here: the system that keeps prior states is the one that never decides identity.

None of the six reports a collision as a typed event a caller can act on. Mem0 comes closest — a maintainer describes contradictions "connected via linked_memory_ids to the original memory" (mem0#4896) — but a link is not a classification: nothing says which record lost, or on what score. graphiti#934, open since 2025-09-25, asks for that surface: "we can identify such contradictions, flag them, and alert on them… Only the owner of the data can say what is the right thing to do."

Larger knowledge bases keep that record. Wikidata ranks conflicting statements — preferred, normal, deprecated — with deprecated reserved for statements known to include errors rather than merely outdated ones (Help:Ranking); read-time conflict resolution is a named, exportable filter, and what a graph server returns decides whether an agent can use it.

Deduplication is entity resolution, and entity resolution is eighty years old

Halbert L. Dunn, then Chief, National Office of Vital Statistics, U.S. Public Health Service, named record linkage in 1946, and his design deliberately did not merge:

"It is not necessary for him actually and physically to assemble the records of a particular individual and bind them into a volume… the end result will be achieved if he creates a Life Records Index indicating where all the most important records of an individual are filed."

Surfaced inconsistency was the product, not the failure: "The accuracy of vital records would be enhanced because of inconsistencies that would show up" (Dunn, AJPH 36(12), 1946; scan). Death was posted against the index rather than resolved into it — "death clearance," in Dunn's term — and records were never fused: a substrate that doesn't rewrite itself, eighty years early.

Newcombe, Kennedy, Axford and James automated the link in 1959 with the move Fellegi–Sunter later formalized: value-specific, frequency-based weighting (Science 130(3381)). Agreement on a rare surname is stronger evidence than agreement on a common one — Winkler and Thibaudeau's illustration is 'Zabrinsky' versus 'Smith'. A cosine score carries no calibrated frequency weight: agreement on either can return the same number.

Fellegi and Sunter gave the theory in 1969 (JASA 64(328)): a likelihood-ratio rule with three outcomes — link, possible link, non-link — asserting identity without deleting either source record. Where a system does consolidate, Swoosh named the condition licensing destruction: merge representativity, the property that anything matching an original still matches the merged representative (Benjelloun et al., VLDB J 18(1), 2009).

The Zep paper's 28 references contain zero entries on entity resolution, record linkage, deduplication or data fusion; the Mem0 paper's (arXiv:2504.19413) contain none either. (Enumerated during this review; independently checkable.) Not negligence — but it explains why the techniques reappear without their conventions.

Your top-k retrieval window is a blocking step

Blocking is the candidate-generation stage that decides which pairs a matcher will ever compare. A pair the blocker never proposes is never classified incorrectly; it is simply never seen. That is why blocking has been separately measured since the mid-2000s, with three named metrics (Papadakis, Skoutas, Thanos & Palpanas, ACM CSUR 53(2), 2020): Pair Completeness, the candidate set's recall against true duplicates; Pairs Quality, the precision of the comparisons made; and Reduction Ratio, against the quadratic baseline of |E|·(|E|−1)/2.

Those windows — Mem0 10, LangMem 5, Graphiti 15 at cosine floor 0.6 — are blocking steps, and none of the six reports any of the three, so a reader cannot separate "the matcher rejected the pair" from "the matcher never received the pair." The survey admits the circularity — the metrics need the true duplicate set, which is what entity resolution exists to find, so blocking "is typically treated as an engineering task that provides an approximate solution for the data at hand." Canopy clustering, in 2000, made the risk non-silent, putting each record in several overlapping candidate sets (McCallum, Nigam & Ungar, KDD 2000).

Merge thresholds are hardcoded, not derived

The gates are not all the same kind of gate, and the distinction matters. Graphiti's 0.6 floor and top-15, Mem0's top-10 and LangMem's top-5 are candidate generation — they decide which pairs get looked at. GraphRAG's uppercased string equality and Cognee's difflib 0.8 are matching — they decide whether two things are called the same. Only Graphiti's Jaccard 0.9 gates a merge that destroys something; Mem0's cosine 0.95 links entities without ever merging memories, and Letta and LangMem make no identity decision at all. What every one of them shares is that the number is a constant someone typed: none derived from a stated error budget, none published with an error rate. Mem0's gate has no type check: mem0#5438 argues that Apple the company and apple the fruit can be fused at that threshold, since entity type is stored but never consulted in the merge decision — a predicted failure mode, not an observed one.

A false merge occurs when a system combines records that refer to different entities or facts; a false split occurs when it keeps separate records that refer to the same entity or fact. The harms are asymmetric — a false split leaves redundant records, a false merge can contaminate every fact attached to the surviving entity — which is why Menestrina, Whang and Garcia-Molina priced splits and merges independently in Generalized Merge Distance (PVLDB 3(1), 2010).

Where a system treats an unrecognized duplicate as a contradiction, a false split can go further than redundancy and invalidate the earlier fact. In graphiti#1101, open since 2025-12-10 with no maintainer response, a user describes a paraphrase not recognized as a restatement and therefore classified as contradicting news — in the reporter's own words, "Duplicates are categorized as new relationships temporally replacing the older one." One unconfirmed report, not a measured rate; the mechanism it describes is what makes it worth reading.

None of the six reports a confusion matrix for the dedup decision, or μ, λ, or an abstain-region size — though Graphiti's entropy gate is a de facto abstain path, deferring low-entropy names to the LLM instead of to fuzzy similarity. The correspondence is structural, not evidence of influence.

Fellegi–Sunter begins where those constants end. The operator stipulates μ, the false-link rate, and λ, the false-non-link rate; the cutoffs are derived from them. The abstain region is the range of uncertain comparison scores for which a resolver declines to make an automatic link or non-link decision. Among rules achieving the same (μ, λ), the likelihood-ratio rule minimises how much is deferred to a clerk. On the St Louis file, Winkler and Thibaudeau's 1990 strategy — EM-estimated parameters, string-comparator weight adjustment, frequency-based weights — shrank the clerical pile from 10,138 pairs under an ad hoc guess to 146, with the automatic-match false-match rate held at 0.002 (crude and param, the weakest methods, were allowed slightly above it) (U.S. Census RR91-9, 1991, Table 6). The report is candid that the derivation does not run itself: the estimated m( ) and u( ) "are never suitable for direct estimation of the cutoffs", so "in practice, we determine UPPER and LOWER by reviewing a set of pairs" (§4.6). What failed to transfer is the discipline, not the formula: a stated error budget, priced in clerks.

Cosine is a weak instrument for the decision it is asked to make. Ethayarajh (EMNLP 2019) showed contextualized embeddings are anisotropic, occupying a narrow cone that inflates baseline cosine between unrelated items; Zhou et al. (ACL 2022) showed it underestimates similarity for high-frequency words; Steck, Ekanadham and Kallus (WWW Companion 2024) showed that for common regularized linear models it "can yield arbitrary and therefore meaningless 'similarities.'" No peer-reviewed paper reviewed for this piece reports a measured precision/recall curve for embedding-cosine deduplication at any threshold. The constants in these six systems ship without a derivation, a citation, or a published operating point.

Graphiti rebuilt MinHash and LSH from scratch

Graphiti's dedup_helpers.py runs 3-gram shingles → MinHash → LSH banding → Jaccard ≥ 0.9 → auto-merge: the same construction, same order, as the web-scale near-duplicate stack. Six magic constants, zero citations, no published operating point.

Broder (SEQUENCES 1997) defined resemblance as the Jaccard index of shingle sets, proved the MinHash estimator unbiased (Theorem 1), and published the sample-size/accuracy trade-off; his 30-million-document run over an Alta Vista crawl used Rabin fingerprints with ℓ = 40. Manku, Jain and Das Sarma (WWW 2007), using Charikar's SimHash (STOC 2002), chose their Hamming threshold in public: on 8 billion pages as 64-bit fingerprints they sampled pairs at each distance, hand-labelled true and false positives, and plotted the curve — "Choosing k = 3 is reasonable because both precision and recall are near 0.75." The contrast is not scale: those approximations shipped with an error analysis and a chosen point on a published curve.

The classical rule is that a cheap high-recall filter gates a rarer exact confirmation and never makes the final call. Graphiti's recommended cost path inverts it: a maintainer describes a "small model" classifier, gpt-4.1-nano in Zep's implementation (graphiti#467, comment posted 2025-05-22 in an issue filed 2025-05-10). A graded 5-case × 3-replicate eval on that model, 15 calls, filed 2026-07-18 (graphiti#1666), scored the stock schema 7/15, including 1/3 on a clear two-fact contradiction, against 14/15 for a reasoning-first variant. That report is small, user-run, and not a benchmark of Graphiti as a whole. Its asymmetry is still informative: duplicate detection held while contradiction detection collapsed — and contradicted_facts drives invalid_at, so stale facts can survive their own contradiction, unsurfaced. Model choice at the deciding layer is a correctness decision, not only a cost one — and none of the six ships a measurement of what its own deciding model costs in accuracy.

How would anyone know?

Bagga and Baldwin (COLING-ACL 1998) built a hard corpus: 197 New York Times documents matching /John.*?Smith/, containing 35 distinct John Smiths. They scored the degenerate baseline — declare all 35 one person — against the metrics: 83% precision and 100% recall under MUC, and 23% precision at the same 100% recall under B-CUBED. MUC counts links; B-CUBED counts, per entity, how polluted its cluster is. Over-merging is invisible to the first and catastrophic to the second. The free test they left behind: run the all-one-cluster and all-singletons baselines against your metric first, and reject it if either scores well on the behaviour it should punish.

LongMemEval's knowledge-update subset is 78 of 500 questions, all with exactly two evidence sessions — single-slot, two-point, "what is it now?" Grading is end-to-end QA by an LLM judge, GPT-4o in the reference setup; nothing inspects whether the store invalidated the earlier value (LongMemEval, ICLR 2025). A system that stores both facts and ranks the newer one higher scores identically to one that correctly expired the old fact — the degenerate baseline. On this subset the benchmark cannot separate the two, and its own grader says so.

It is not an oversight, and the benchmark does not hide it. The grader prompt for this category, alone among the graded categories, replaces the usual "if the response only contains a subset of the information required by the answer, answer no" with the opposite instruction: "If the response contains some previous information along with an updated answer, the response should be considered as correct as long as the updated answer is the required answer" (get_anscheck_prompt, src/evaluation/evaluate_qa.py, retrieved 2026-08-03). Carrying the superseded value alongside the new one is scored correct by design.

That does not make LongMemEval useless: it measures answer production, not the correctness of the merge or invalidation operation — one of the dimensions with no instrument. LoCoMo, where Mem0 reports its headline numbers, has no update or contradiction category at all. These vendor deltas are therefore unreadable on this property — and Zep's own table shows why. On LongMemEval knowledge-update it reports full-context 76.9 versus Zep 74.4 with gpt-4o-mini as the answering model, and full-context 78.2 versus Zep 83.3 with gpt-4o (arXiv:2501.13956, Table 3). The sign of the difference flips with a model that has nothing to do with how the store handled the collision; Mem0 attributes +20 on LoCoMo (71.4 → 91.6) and +26 on LongMemEval (67.8 → 93.4) not to eliminating UPDATE/DELETE alone but to a bundle that also added hybrid BM25/entity-boost retrieval and entity linking (v2→v3 migration, retrieved 2026-08-03); its currently published figures for the same algorithm are 92.5 and 94.4 (Mem0). The harness is open (memory-benchmarks); no third-party reproduction and no ablation isolating the removal was found among the sources reviewed here. Neither Mem0's gain nor Zep's loss establishes whether either handled store-level collisions correctly: the instrument cannot see that property, and the grader underneath is lenient by construction.

Where the old papers don't help

The old literature does not solve the agent-memory setting.

In agent memory, the entities a matcher must resolve are generally not in its training set — user-specific names and facts arrive after the model is fixed. On WDC Products (Peeters, Der & Bizer, EDBT 2024), fine-tuned matchers degrade sharply and unevenly once entities leave the training distribution: on the medium set at 50% corner cases, seen → unseen, Ditto 79.16 → 70.24 and R-SupCon 81.88 → 57.23. A real defence of LLM zero-shot matching.

In the OAEI 2023 Conference track, the top-scoring system beat plain string equality by about 21 F1 points. In the OAEI 2023 Conference track (rar2-M3), over conference-organisation ontologies, GraphMatcher reached F1 0.74 against a StringEquiv baseline of 0.53; two systems scored below string equality — TOMATO 0.52, PropMatch 0.15 (OAEI 2023). One year's snapshot, not a trend line — but against it, removing a resolver maintainers do not trust is defensible (graph construction has its own cost).

Truth discovery needs at least two independent sources; in all six systems here, facts arrive on a single write stream. It estimates source reliability from cross-source agreement, so one source leaves nothing to estimate and the method degenerates to "believe the latest." That is an inference from the framework in Li et al.'s 2016 survey, not a claim it makes — it in fact names selecting the up-to-date observation as "a possible approach" when a single source reports repeatedly about one object (counting agreeing sources is not counting evidence).

Granularity is not contradiction. Knowledge Vault (Dong et al., KDD 2014), after attempting mutual exclusion at 1.6B triples: "We might have a fact that Obama was born in Honolulu, and another one stating he was born in Hawaii. These are not mutually exclusive, so the naive approach does not work." Resolving contradictions before separating refinement from conflict is the wrong order.

The classical update machinery assumes a key — SCD's business key, Kafka's message key, SQL:2011's PRIMARY KEY … WITHOUT OVERLAPS. The record-linkage tradition does not; that absence is what it was built for. "Lives in Lisbon" and "moved to Berlin" share no key, and valid time is no safer: "I moved to Berlin" carries no date.

There is no clerk. Fellegi–Sunter's optimality result minimises human labour, and an agent has no review team: the abstain pile becomes latency, an interruption, or a silent default. The ceiling is low — Wikidata's Primary Sources Tool logged about 90,000 review actions against more than 14 million uploaded statements, roughly 0.6% (Pellissier Tanon et al., WWW 2016). A ~1% budget argues for recording the merge, not staffing a queue. Every system here also binds early, while the alternative that re-clusters as evidence arrives beat baseline linkage by 15–27% F-measure on the full patent data set and 11–22% on the partial one, in batch, on schema'd data (Li, Dong, Maurino & Srivastava, PVLDB 4(11), 2011) — a qualifier streaming prose fails. A wrong early merge does not just lose information; it blocks later correct merges.

---

Four questions a builder can ask any memory system:

1. What is your candidate window and its recall?
2. What is your threshold, and how was it derived?
3. What happens to the loser?
4. Can you undo a merge?

Disclosure: Mnemoverse does not answer these four either. Our documented lifecycle names a consolidate step that merges similar memories into prototypes (API overview); we publish no false-merge rate for it, and no merge record that would make a wrong merge reversible.

Bi-temporal memory answers when, provenance answers who, and the remaining question is the oldest in the file: is it the same thing — and how would anyone know?

Common questions

What is agent memory deduplication?

Agent memory deduplication is the decision, at write or index time, whether an incoming fact refers to the same entity or claim as something already stored, and what happens to the loser if it does. It is entity resolution applied to a streaming store rather than to a batch file.

What is a false merge in agent memory?

A false merge combines records that refer to different entities or facts; a false split keeps separate records that refer to the same one. The harms are asymmetric: a false split leaves redundant records, while a false merge can contaminate every fact attached to the surviving entity.

Do agent memory systems publish false-merge rates?

None of the six systems reviewed here does. Each hardcodes a threshold — cosine 0.95, Jaccard 0.9, difflib 0.8 — with no derivation from a stipulated error budget. Fellegi and Sunter required operators to stipulate the false-link and false-non-link rates first, then derive the cutoffs; that discipline has not transferred.

What is blocking in entity resolution?

Blocking is the candidate-generation stage that decides which record pairs a matcher will ever compare. A pair the blocker never proposes is never classified incorrectly; it is simply never seen. Top-k retrieval windows in agent memory are blocking steps, and none of the six systems reports Pair Completeness for its window.

Why can't LongMemEval measure knowledge-update correctness?

Its 78 knowledge-update questions are graded end-to-end by an LLM judge, and nothing inspects the store. A system that keeps both facts and ranks the newer one higher scores identically to one that correctly invalidated the old fact. It measures answer production, not the correctness of the merge operation.

Sources

Grouped by what each one was used for. Systems were read as source code at the commits pinned above, not executed; papers were read as papers; vendor documentation and issue threads were read on the dates given in the text. Five primaries could not be opened behind paywalls — Newcombe 1959, Fellegi–Sunter 1969, Swoosh 2009, Generalized Merge Distance 2010 and Charikar 2002 — and the claims resting on them were checked against Winkler & Thibaudeau's Census report, which restates the Fellegi–Sunter theorem verbatim. Those four are cited here as corroborated, not verified.

The six systems. mem0ai/mem0 · getzep/graphiti · letta-ai/letta · microsoft/graphrag · topoteretes/cognee · langchain-ai/langmem

Vendor documentation. Mem0 memory evaluation · Mem0 v2→v3 migration · Letta sleep-time architecture · Zep, arXiv:2501.13956 · Mem0, arXiv:2504.19413

Maintainer threads. mem0#4896 — accumulation is by design · mem0#5438 — the 0.95 gate ignores entity type · graphiti#467 — the small-model cost guidance · graphiti#934 — a request to surface collisions, open since 2025 · graphiti#1101 — a paraphrase expiring the fact it restates · graphiti#1666 — the 15-call contradiction eval · graphrag #778 — entity resolution removed deliberately

Benchmarks, including their grading code. LongMemEval, ICLR 2025 — the knowledge-update grader prompt was read in src/evaluation/evaluate_qa.py, not inferred from the paper · Mem0 memory-benchmarks harness

Record linkage and entity resolution. Dunn, AJPH 36(12), 1946 (scan) · Newcombe et al., Science 130(3381), 1959 · Fellegi & Sunter, JASA 64(328), 1969 · Winkler & Thibaudeau, U.S. Census RR91-9, 1991 · McCallum, Nigam & Ungar, KDD 2000 · Benjelloun et al. (Swoosh), VLDB J 18(1), 2009 · Li, Dong, Maurino & Srivastava, PVLDB 4(11), 2011 · Papadakis et al., ACM CSUR 53(2), 2020

Near-duplicate detection at scale. Broder, SEQUENCES 1997 · Charikar, STOC 2002 · Manku, Jain & Das Sarma, WWW 2007

How a merge decision gets measured. Bagga & Baldwin, COLING-ACL 1998 — B-CUBED and the degenerate baseline · Menestrina, Whang & Garcia-Molina, PVLDB 3(1), 2010 — split and merge priced separately · Dong et al., Knowledge Vault, KDD 2014 — calibration checked against outcomes

Where the classical answers stop working. Peeters, Der & Bizer, WDC Products, EDBT 2024 — matchers collapse on unseen entities · OAEI 2023 Conference track — two systems below plain string equality · Li et al., truth-discovery survey, 2016 — the apparatus needs several sources · Pellissier Tanon et al., WWW 2016 — the human review budget, measured

Why cosine is a weak instrument here. Ethayarajh, EMNLP 2019 · Zhou et al., ACL 2022 · Steck, Ekanadham & Kallus, WWW Companion 2024

A system that does keep the record. Wikidata Help:Ranking — preferred, normal, deprecated

The full assembly log for this piece — every scouting lane, the blind council rounds, and three adversarial review passes — is kept with the article's working files.

Related

• Bi-temporal memory for AI agents — the when axis
• Provenance in agent memory — the who axis
• World representation for AI agents — cluster hub
• AI memory solutions, Q3 2026 — vendor landscape
• Evaluating agent memory — measurement dimensions
• AI agent memory — hub

[^versions]: Mem0 OSS 2.0.15 (50bdaae, 2026-08-01) · Graphiti 0.29.3 (7cf0cab, 2026-08-01) · Letta 0.16.8 (ff19ffe, 2026-08-01) · GraphRAG v3.1.1 (14a00ad, 2026-07-18) · Cognee v1.4.1 (38eece5, 2026-08-01) · LangMem 0.0.30 (56d8593; last src/ commit 2025-07-28). These systems move fast; this is a reading of those commits.

Edward Izgorodin · Mnemoverse · 2026-08-03

— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started