Causal-Graph Memory for AI Agents: Multiplicative Retention Scoring and Conjunctive Active Forgetting

2.1Cognitive foundations

Genesys's scoring and lifecycle are grounded in three strands of memory science. Decay: Ebbinghaus's forgetting curve [7] established that unrehearsed memory availability falls steeply with time — the historical anchor for every decay-based memory system, including ours. Rational activation: Anderson and Schooler [4] showed that human memory availability tracks the environmental statistics of need — frequency, recency, and spacing of past use — and the ACT-R architecture [1–3] formalizes this as base-level activation B_i = ln Σ_j t_j^−d over a presentation history. Genesys transcribes this equation directly (§3.3). Consolidation: complementary-learning-systems theory [10] distinguishes fast episodic encoding from slow semantic integration; Genesys's episodic→semantic consolidation and its treatment of layers as stages of one substrate rather than separate stores follow this lineage.

2.2Memory systems for LLM agents

Tiered / paging architectures. MemGPT [11] frames memory as an OS problem: a bounded main context and an external context, with the LLM paging data between them. This manages where information sits, not what it is worth keeping or how items relate; Genesys rejects the tier metaphor — there is one graph, and “tiers” are status tags that never move data.

Scored memory streams. Generative Agents [12] attach to each memory a retrieval score combining recency, LLM-rated importance, and relevance, plus periodic reflection. This is the closest prior art to Genesys's scoring, and the differences are instructive: Genesys replaces model-rated importance with measured causal connectivity (a topological property, free of an LLM call and auditable), composes forces multiplicatively rather than as a weighted combination, and uses the score to drive lifecycle and forgetting — not only retrieval ranking.

Decay-based stores. MemoryBank [15] applies an Ebbinghaus-inspired forgetting curve to stored memories, strengthening those that recur. Genesys shares the decay lineage but differs in the deletion decision: MemoryBank-style designs delete on a scalar signal, whereas Genesys requires conjunctive failure including causal orphanhood (§4.3).

Graph and knowledge-graph memory. Zep [13] stores agent memory in Graphiti, a temporally-aware knowledge graph with entity resolution and edge invalidation. HippoRAG [8] applies hippocampal-indexing theory to corpus QA, running personalized PageRank over an extracted KG at retrieval time. A-MEM [14] maintains Zettelkasten-style atomic notes whose links are agentically created and revised. Genesys shares the graph substrate with these systems but differs in what the graph is for: in Genesys the edge set is a survival signal — connectivity is a multiplicative force in retention and orphanhood is a hard deletion gate — rather than only a retrieval structure. Genesys edges are also typed causally (including contradicts and supersedes, which are deliberately excluded from the survival count) rather than being generic entity relations.

Production memory pipelines. Mem0 [5] is the reference production pipeline: LLM-based fact extraction, update resolution, and retrieval, evaluated on LoCoMo with a fully specified protocol. Genesys is evaluated under exactly that protocol (§6.1) because it is the only fully specified LoCoMo protocol shared by the systems we compare against.

Positioning, stated plainly. No single mechanism in Genesys is unprecedented: decay scoring, graph memory, consolidation, and forgetting each have prior art above. The contribution is the specific composition — a cognitively grounded retention score whose forces are multiplicative, a causal edge set that doubles as the safety case for deletion, a lifecycle FSM over one substrate, and an evaluation methodology that reports its own noise floor, failed gates, and dead ends — together with evidence that this composition exceeds the published graph and pipeline baseline results under a frozen comparable protocol.

2.3Evaluation practice for conversational memory

LoCoMo [9] generates very-long-term multi-session conversations and QA pairs spanning single-hop, multi-hop, temporal, open-domain, and adversarial categories, and has become the de facto benchmark for agent memory systems. Its use in the systems literature, however, has been marred by comparability failures that directly shaped our methodology. Published LoCoMo scores are functions not only of the memory system but of the answering model, the judge model, the judge prompt (LLM judges for this benchmark are deliberately generous, accepting topically-equivalent paraphrases), the category set, and the denominator — and these have varied across publications. The most instructive episode is the public Mem0–Zep dispute: Zep's initially blogged LoCoMo figure contained a numerator/denominator mismatch on the excluded adversarial category, was recomputed sharply downward by Mem0, and was separately corrected by Zep itself — with all three numbers produced on Mem0's evaluation methodology, since Zep's own paper [13] evaluates DMR and LongMemEval and never defined a LoCoMo methodology. Separately, several vendors market LoCoMo scores obtained with stronger answerers or judges than any competitor's published configuration, which are incomparable by construction. The lesson we draw, and operationalize in §6.1, is that a LoCoMo claim is only meaningful relative to a fully frozen protocol shared with the numbers it is compared against — and that run-level statistics are mandatory, because a single run of a temperature-0 LLM answer-and-judge pipeline is measurably noisy (§6.5).

3.1Memory graph

For each user, Genesys maintains a directed graph G = (N, E). A node n ∈ N is a memory carrying content (full text and summary), an embedding e_n, extracted entity references ℰ_n, a status tag σ(n) ∈ {tagged, active, episodic, semantic, core, dormant}, a pin flag, a visibility scope (private or org), a retention weight s(n) (the retention score; persisted under the legacy field name decay score and surfaced to agents under the API alias activation, both retained for backward compatibility; default 1.0 at creation; nominally in [0, 1], though the query-path relevance term is unclamped — see §3.2), a reactivation history T_n = {t₁, …, t_m} of timestamps (creation plus every recall), a stability scalar (§3.3), and bookkeeping timestamps (created / last-accessed / last-reactivated).

An edge ε ∈ E has a source, a target, a type, a weight, and an optional natural-language reason. Edge types are partitioned:

The neutral type temporal_sequence records conversational ordering and counts toward neither degree notion below. The supportive/negative partition induces two distinct degree notions that are load-bearing throughout the system. The causal degree κ(n) counts incident edges (either direction) of causal type and drives the connectivity force below. The supportive degree δ(n) counts incident edges of supportive type and defines orphanhood: n is an orphan iff δ(n) = 0. related_to — the type used for automatic similarity links — is supportive but not causal: a node held in the graph only by auto-links has κ = 0 yet is protected from deletion. Negative edges are neither: a node whose only edges are contradicts or supersedes links is an orphan for survival purposes. Edge weights are stored and surfaced for ranking and explanation, but the connectivity force is a function of edge count, not weighted flow: connectivity in Genesys is topological degree.

3.2The multiplicative retention score

Every node's retention weight is the product of three forces:

The composition is multiplicative by design: a zero on any force collapses the product. The constants below are the shipped defaults; all are environment-configurable.

Force 1: Relevance. Against a query or context q with embedding e_q and entity set ℰ_q,

When no context embedding is supplied — the at-rest case used by background rescoring — the term is replaced entirely by a bounded linear recency:

where Δ_days is days since last access. An untouched memory's at-rest relevance therefore drifts linearly toward a floor of 0.1 over one year and never reaches zero: at rest, relevance alone cannot kill a memory. Two implementation facts deserve note. The overlap term is deliberately asymmetric: it normalizes by the node's entity count rather than by a Jaccard union over both sets, so a small, precisely tagged memory is not diluted by a verbose query context. And the cosine term is not clamped in the shipped implementation: cos ∈ [−1, 1], so on the query path relevance — and therefore the product — can in principle be negative for anti-correlated embeddings, which simply ranks the node last; the at-rest path is bounded below by 0.1.

Force 2: Connectivity. Let κ_max be the maximum causal degree in the user's graph. Then

with C_raw = 0 when κ_max = 0. Three properties are intentional. Log-normalization against κ_max makes connectivity relative to the busiest hub in the user's own graph rather than to an absolute scale. Squaring is a deliberate convexity that rewards genuine hubs and suppresses barely-connected nodes. The floor of 0.1 guarantees that any non-orphan node — even one held by a single related_to auto-link, for which C_raw = 0 — retains a tenth of full connectivity: one good edge keeps a memory alive. The orphan case is the only hard zero in the entire formula, and it is exactly the state that active forgetting tests for (§4.3).

Whether κ_max is the right normalization reference is an open design question (B4, §4.4); the text here describes only what the shipped implementation does.

Force 3: Base activation (ACT-R base level). With presentation history T_n (creation timestamp plus one entry per reactivation), elapsed times t_j in seconds clamped to ≥ 1, and decay exponent d = 0.5:

Equation (6) is the canonical ACT-R base-level learning equation [2] at ACT-R's canonical default d = 0.5, exponentiated and clamped to the unit interval. For a write-once memory (single timestamp at age E seconds), A = min(1, E^−1/2): 1.0 at one second, 0.1 at 100 seconds, 0.01 at 10⁴ seconds. Every recall appends a fresh timestamp whose small elapsed time contributes a large t^−1/2 term, so retrieval raises the score — the central legibility property of the system: the retention weight is something the user's own usage visibly feeds. To avoid overloading the word activation — which the API also exposes as an alias for the whole product — we refer to A(n) as the base activation factor throughout.

Why a product and not a sum. The multiplicative form is the load-bearing design decision, so we state the argument rather than assert taste. An additive or weighted-sum composition — the form used both by ACT-R's total activation and by Generative Agents' retrieval score [12] — has compensation semantics: strength on one axis buys back weakness on another. For retrieval ranking alone that is often acceptable; for a score that also drives lifecycle and gates deletion it produces two characteristic failure modes. First, the immortal hub: under addition, a heavily connected memory retains substantial score even when it has not been relevant or recalled in a year, so structural importance alone pins stale knowledge at high rank indefinitely. Second, the noisy singleton: a memory highly similar to the current query but disconnected and never reused scores competitively with genuinely established knowledge, letting one-off noise crowd the context window. The product gives each force veto power over rank: a memory surfaces strongly only when it is simultaneously relevant now, embedded in causal structure, and behaviorally alive. The obvious objection — that veto power makes the product dangerously aggressive as a deletion signal — is correct, and is exactly why deletion is not delegated to the score: the conjunctive gate of §4.3 exists to absorb that aggression. Two monotonicity properties follow directly from the definitions and match user-facing intuition: A(n) is strictly increased by every recall (each appends a fresh t^−1/2 term) and strictly decays between recalls; and C(n) is nondecreasing in the node's own causal degree, but relative — adding edges elsewhere can dilute a node's connectivity through κ_max, so hub status is earned against the user's own graph, not an absolute scale.

Worked decomposition. Table 1 decomposes the score for three memories from a ~50-node field workload, computed by the released implementation. The order-of-magnitude gap between the recalled memories (A, B) and the write-once memory (C) is driven almost entirely by Force 3. Note that C's score (≈ 0.005) is below the forgetting threshold of 0.01 — and C is nevertheless not deletable, because it retains a supportive edge. That interplay is the subject of §4.3.

3.3Correspondence to ACT-R: transcribed, modified, relocated, novel

Because “ACT-R-inspired” covers everything from faithful implementation to loose homage, we state the correspondence exactly.

Transcribed unmodified. The base-level term is the ACT-R base-level learning equation B_i = ln Σ_j t_j^−d with the canonical default d = 0.5 [2, 4]. The reactivation history is the presentation history {t_j}; each recall appends one presentation.

Modified. Standard ACT-R converts activation to a retrieval probability through a logistic P = 1 ⁄ (1 + e^{−(A_i − τ)/s}) with threshold τ and noise s. Genesys does not: it computes e^B_i — recovering the raw activation odds Σ_j t_j^−d — and hard-clamps to [0, 1]. There is no retrieval threshold, no logistic, and no activation noise. This is a deliberate simplification: Genesys needs a bounded deterministic factor for a product, not a stochastic retrieval model.

Relocated. ACT-R's total activation is additive: A_i = B_i + Σ_j W_j S_ji, base level plus context-source spreading activation. The Genesys retention score contains no additive spreading term. The spreading idea instead appears in two discrete mechanisms elsewhere in the engine: a small recall-time ranking bonus (+0.05 per edge among co-retrieved results), which affects ranking but not stored activation; and BFS cascade reactivation (§4.2), which propagates a bounded reactivation write (a reactivation-count increment and last-reactivated timestamp refresh) to graph neighbors, with geometric distance decay gating dormant revival. What propagates is lifecycle protection, not activation: the cascade write feeds the dormancy shield and can revive dormant neighbors, but it never enters the timestamp history that feeds Eq. (6), so no score-side quantity spreads along edges. ACT-R spreading survives here as a ranking bonus plus protective graph traversal, not as an activation term.

Novel (not ACT-R). The multiplicative three-force composition itself (ACT-R composes additively); the connectivity force of Eq. (5), which is a graph-centrality construct with no ACT-R analogue; the relevance force, an IR/embedding construct standing in the role of ACT-R's partial matching but formulated independently; and the stability scalar, a dial in the spaced-repetition lineage [7]: each reactivation applies stability += 0.1 ⁄ stability, a diminishing-return reinforcement update. Because the update carries no inter-review-interval term, it implements diminishing-return reinforcement rather than the empirical spacing effect proper, and we do not claim otherwise. Stability never enters the retention product; it feeds core promotion (§4.1) and is reported by the explanation surface. ACT-R partial matching, mismatch penalties, and activation noise are not implemented.

4.1Status FSM

Statuses are tags on nodes of the one graph; transitions are property updates and never break edges. On each maintenance pass, the transition engine recomputes Eq. (2) in its at-rest form and persists the fresh score for every active, episodic, and semantic node that is neither core nor org-visible, then applies the rules of Table 2 (Figure 2). tagged nodes are governed by an edge/age rule alone — promoted to active the moment an edge forms, or expired to dormant after 24 h without one — and dormant nodes are not re-examined by the scoring pass. Neither tagged nor dormant nodes have their persisted score refreshed by this cycle: each retains its last-persisted value, which for a node that has never been rescored is the creation default of 1.0. This scoping is load-bearing for the forgetting analysis of §4.3.

Three semantics deserve emphasis. First, active→episodic requires three accumulated low-score evaluations, a hysteresis against transient irrelevance. Second, the dormancy rule's reactivation-count clause is a frequency shield: a node reactivated three or more times can never go dormant regardless of score or age. In the shipped release the count is incremented by direct retrieval — every recall that returns the node applies a reactivation write — and by the cascade mechanism of §4.2 when a cascade is executed; because the shipped recall path does not itself invoke the cascade, the shield is in practice earned by direct retrieval. Third, neither semantic nor core is reachable through this FSM: they are minted by consolidation and promotion respectively, described next. The design of the shield itself is an open question (B3, §4.4).

Consolidation (episodic → semantic). Following the fast-episodic / slow-semantic division of complementary-learning-systems theory [10], when three or more episodic memories share an entity reference, the engine synthesizes a single semantic node from their contents (an LLM summarization step, run asynchronously), embeds it, and links it to each source with a derived_from edge. The episodic sources are not deleted; they remain in the graph, now causally connected to the semantic abstraction — consolidation adds structure rather than destroying evidence.

Core promotion. core status (never auto-forgotten, surfaced preferentially) is granted either by category fast-path or by a composite consolidation score 0.4 · A(n) + 0.3 · hub(n) + 0.2 · schema(n) + 0.1 · stability(n) ≥ 0.55, where hub is supportive degree normalized by the graph's average degree (capped), and schema is the fraction of the node's neighbors that are themselves better-connected than average — an ACT-R-flavored blend of activation, hub importance, and schema fit. User pins are never overwritten by promotion machinery.

Contradiction and supersession. Conflicting knowledge is represented, not resolved by overwriting. Corrections arrive through memory_amend (§5), which creates a new node with a supersedes edge to the old one; contradiction detection runs asynchronously and can link conflicting nodes with contradicts edges, while the synchronous store path may at most return heuristic conflict hints to the writing agent, never auto-created negative edges. Because negative edges count toward neither the connectivity force nor orphanhood protection (§3.1), the lifecycle handles stale knowledge gracefully: a superseded fact decays in rank as recall down-weights it, drifts through the FSM toward dormancy, and — once nothing supportive references it — becomes structurally eligible for forgetting, with its provenance (what corrected it, and why) preserved and traversable unless and until the ordinary retention policy removes the obsolete node — a hard delete removes the node and its incident edges, including the supersedes edge. Whether superseded provenance should instead be exempted from hard deletion is an open design question (B5, §4.4).

4.2Reactivation cascades

The cascade is the relocated form of ACT-R spreading (§3.3), and its shipped semantics are lifecycle protection, not score propagation. The mechanism runs a breadth-first traversal from an accessed node with depth 2 and geometric attenuation: hop strength s(h) = γ^h with γ = 0.3, i.e. 0.3 at one hop and 0.09 at two, zero beyond. Each reached node — the traversal's seed excluded — receives a bounded reactivation write: its reactivation count is incremented and its last-reactivated timestamp refreshed. The attenuated hop strength s(h) does not scale the magnitude of that write, and the write does not append to the reactivation-timestamp history that feeds the base-level sum of Eq. (6), which grows only on direct retrieval — so a cascade never changes a neighbor's base activation factor or retention score. What the cascade write protects is lifecycle position: it advances the neighbor toward the dormancy shield's count threshold, refreshes the recency clause of the dormancy rule, and — the one thing the hop strength gates — revives a dormant neighbor to episodic when the arriving strength is ≥ 0.1, so a direct neighbor of a recalled memory can wake, but a two-hop neighbor (0.09 < 0.1) cannot. Direct retrieval remains the only score-strengthening event: the shipped recall path applies, to every returned node, a reactivation write that additionally appends a fresh timestamp to the base-level history, and that append is what raises A(n). In the shipped release the recall path performs these direct writes but does not invoke the cascade; whether to wire the cascade into recall is an open integration decision (§4.4). One consequence deserves to be stated plainly: because cascade revival is the only dormant→episodic transition in the FSM (§4.1) and no shipped code path invokes the cascade, in shipped operation dormancy is effectively a one-way door — nothing revives a dormant node, and the dormancy shield's cascade-earned clause is correspondingly dead in practice. Wiring the cascade into recall would make both revival and the transitive shield live at once; that is precisely the B3 integration question (§4.4). Figure 3 therefore demonstrates revival by invoking the cascade directly.

4.3Conjunctive active forgetting

Forgetting in Genesys is not a storage optimization; it is a retrieval-precision and hygiene mechanism. An append-only store accumulates one-off noise, superseded facts, and orphaned fragments whose only effect is to compete with genuine memories for the top-k — §6.8 quantifies, in a different setting, how expensive contaminated candidate sets are. The engine therefore forgets actively, but under a predicate designed to make wrongful deletion structurally impossible rather than merely unlikely. The forgetting sweep may hard-delete a node n (removing it and its incident edges, and reporting the pruned IDs to the caller) only when all of the following hold:

The argument for conjunction. The multiplicative score and the conjunctive gate are complements. The product of Eq. (2) is intentionally harsh — it exists to rank, and a memory weak on any axis should rank low. Precisely because the score is harsh, it cannot be trusted as a deletion criterion on its own: a memory can be temporarily irrelevant (no recent queries touch it), rarely reactivated (activation decays as t^−1/2), and still be structurally load-bearing — the fact that explains three other facts. Eq. (7) therefore demands simultaneous failure on every survival axis: informational (score below threshold), structural (causally orphaned — and orphanhood is measured on supportive degree, so even a single automatic related_to link is an absolute veto), and intentional (not pinned by the user, not promoted to core, not shared at organization scope). How the shipped configuration actually behaves follows from three code facts, and we state them plainly. First, the sweep performs no scoring of its own: it tests the currently-persisted score, and the background transition cycle refreshes that score only for active, episodic, and semantic nodes (§4.1); a node whose persisted score predates its orphanhood is judged on that stored value. Second, the score and orphanhood conditions are not independent under the shipped constants: orphanhood zeroes the connectivity factor, so any orphan rescored since it became an orphan has score exactly 0 and satisfies the threshold automatically — the nodes actually driven below θ_f are precisely orphaned active/episodic/semantic nodes. Third, a node that reaches dormant retains its last-persisted score and is not re-evaluated by the cycle, and a tagged node is never rescored at all, so a tagged orphan expires to dormant still carrying its creation default of 1.0; the tagged→dormant→forgotten lifecycle therefore does not, by itself, prune under the shipped cycle. In the evaluated configuration, deletion is structurally gated: the operative protections are the orphan test and the intentional vetoes, with the score threshold binding only for orphans whose persisted score is stale. Whether the predicate should be restructured so the score condition is independent of orphanhood is an open design question (B1, §4.4).

The worked example makes the division of labor concrete: memory C in Table 1 sits at s ≈ 0.005 < θ_f, yet holds one supportive edge and is therefore not deletable. It rests — ranked low, fully retrievable, costing nothing but storage — until either a future recall lifts its activation (each recall appends a large t^−1/2 term and triggers a cascade) or it genuinely loses its last connection. A low retention weight is a precondition of deletion, never a sentence; deletion requires that no currently recognized supportive dependency or association — causal or topical — qualifies the memory for retention protection (supersedes and contradicts edges, though meaningful, deliberately do not count). This is the mechanism by which Genesys avoids the catastrophic failure mode of scalar-threshold forgetting: silently deleting low-activation-but-embedded knowledge.

Conversely, the gate never blocks ranking: superseded and contradicted memories keep negative-type edges only, which count for neither force 2 nor orphanhood protection, so a corrected fact decays in rank and, once nothing supportive references it, becomes eligible for pruning — while the correction that superseded it carries the structure forward.

4.4Open design questions

Field use and the code audit behind this paper surfaced design questions on which the shipped implementation takes a defensible but not obviously final position. We record them here, unresolved, rather than silently picking answers; the body text above describes only what ships.

• B1 — deletion-predicate structure (§4.3). Whether the deletion predicate should be restructured so the score condition is independent of orphanhood — e.g. a deletion score that excludes connectivity paired with a separate orphan gate, a nonzero orphan connectivity value so the score threshold regains discriminative meaning, or an explicit reframing of the mechanism as a graph-structural deletion gate.
• B2 — auto-link veto (§4.3). Whether machine-inferred related_to auto-links should retain an absolute, non-expiring deletion veto, versus distinguishing writer- or user-verified causal edges (absolute veto) from machine-inferred relatedness that expires, loses veto power when stale, requires periodic validation, or vetoes only above a confidence threshold.
• B3 — dormancy shield (§4.1). Whether the lifetime reactivation-count dormancy shield should distinguish direct retrievals from cascade-propagated increments, use a rolling window or frequency-per-time instead of a lifetime count, decay over time, or act as a modifier rather than a categorical veto. A sibling integration question is whether the cascade should be invoked by the recall hot path at all — in the shipped release it is not (§4.2).
• B4 — connectivity reference (§3.2). Whether connectivity should remain normalized against the graph-wide maximum causal degree κ_max — under which unrelated growth elsewhere in the graph can lower a node's connectivity factor, and hence its lifecycle trajectory, with nothing about the node changing — or move to a percentile, capped, moving-average, fixed, or local-neighborhood reference.
• B5 — supersession provenance (§4.1). Whether superseded-memory provenance (the obsolete node and/or its supersedes edge) should be exempted from hard deletion — e.g. tombstoned or archived — or remain subject to the ordinary retention policy as described here; any public description of amendment as “kept for audit” must match whichever ruling is made.
• B6 — minimum-age / eligible-status guard (§4.3). The shipped predicate imposes no minimum node age. Because an active node orphaned by deletion of its sole supporting neighbor is rescored to (near) zero on the next background cycle, it can become deletion-eligible while seconds old and still query-relevant — a transient-orphan exposure that is currently bounded only by the auto-link veto (B2). Whether deletion should additionally require a minimum age since creation and membership in an eligible-status set is open.

6.1Benchmark and the frozen protocol

We evaluate on LoCoMo [9]: 10 multi-session conversations with 1,986 QA pairs, of which 1,540 remain after excluding Category 5 (adversarial), consistent with Mem0 and Zep, as ground-truth answers are unavailable for that category. Category identities and counts were verified against the LoCoMo source; because category labeling has been a locus of comparability disputes on this benchmark, we state the numeric-identifier-to-label mapping explicitly (it is implemented as the category-mapping constants of the public harness — see the Reproducibility Statement):

Why freeze someone else's protocol. LoCoMo scores are only comparable under an identical answerer, judge, judge prompt, metric, and denominator — and the literature contains exactly one fully specified protocol among the systems we compare against: the Mem0 paper's [5]. Zep has no independent LoCoMo methodology; the Zep paper [13] evaluates DMR and LongMemEval, and every public Zep LoCoMo number we are aware of was produced by re-running Mem0's methodology. (Zep's LoCoMo figure moved publicly: an initially blogged 84% contained a denominator error — Category 5 excluded from the denominator but not the numerator; Mem0's recomputation gave 58.44 ± 0.20; Zep's own corrected, self-endorsed figure is 75.14 ± 0.17, which is the number we compare against.) Freezing the Mem0-paper protocol therefore buys comparability to both baselines simultaneously. We adopted it verbatim and never moved it:

Three details of the frozen axes deserve comment, because each is a place where a system author could quietly gain or lose points. First, the judge prompt is Mem0's accuracy_prompt adopted verbatim, including its explicit temporal-leniency clause (same date or period counts correct regardless of format); an earlier internal harness omitted that clause, which is stricter than the yardstick on temporal questions and therefore non-comparable in the deflationary direction — non-comparability cuts both ways, and we corrected it. Second, judge responses are format-forced JSON and a parse failure scores wrong: a lenient parse fallback that defaults toward correct is a leniency the yardstick does not have, and we removed ours. Third, the answerer judging its own family (gpt-4o-mini on both sides) is not a deviation but the standard the published baselines were measured under; substituting a “more neutral” judge would break comparability, not improve it.

What remained vendor-controlled — as it is for every system evaluated on LoCoMo — is ingestion strategy, retrieval configuration (including k, which no version of the benchmark prescribes and every vendor sets), and the answer-side prompting, all constrained to dataset-generic content and disclosed in full in §6.3. To our knowledge, vendor-marketed LoCoMo numbers above these baselines use non-comparable judges or answerers and are excluded by these comparability rules. In particular, contemporary vendor-reported scores above 90 exist: Zep reports 94.7% (1,459/1,540) with a gpt-5.4 reader and judge (benchmark results page, updated 28 May 2026; 87 ms p50 / 155 ms p95 retrieval latency, 5,760 tokens per question end-to-end), Mem0 reports 92.5 on LoCoMo for its token-efficient configuration (at 6,956 tokens per query; 94.4 on LongMemEval at 6,787 tokens), and ByteRover reports 92.2% on a Gemini 3 curation-and-judging stack (best run: Gemini 3 Flash curation and judging, Gemini 3 Pro justification). Each of these was produced on a different answerer/judge stack; none is comparable to the frozen protocol used here, and none is comparable to the others. That three vendors now market 90-plus LoCoMo scores on three mutually incomparable stacks is itself the strongest available argument for the frozen-protocol discipline of this section — the comparison of Table 5 is frozen-protocol-relative, not timeless.

6.2Main result

Under the frozen protocol, Genesys (engine version 0.4.2 with the I3 retrieval stack, configuration in §6.3) certifies at 85.55 ± 0.37 (10 independent full runs; range 84.87–86.17), with per-run scores 84.87, 85.84, 85.71, 85.58, 85.26, 85.78, 85.52, 86.17, 85.52, 85.19 (run scores are shown rounded to two decimals; the certified mean and standard deviation are computed from the unrounded per-run artifacts archived by the harness). Each run answers and judges all 1,540 questions end-to-end against live recall from the production server code path. This is +10.4 pp over Zep and +18.7 pp over Mem0 under the identical yardstick (Table 5, Figure 5).

Per-category results are in Table 6. The single-hop canary — a binding guardrail requiring single-hop J ≥ 87.3 on every run — held on all 10 runs (min 89.2). Four observations. Temporal (+16.8 pp) is the largest certified gain and the most mechanistically attributable: LoCoMo's temporal questions require resolving relative and session-implicit dates, and the gain arrived almost entirely with per-turn ingestion that normalizes event dates into explicit [event:] tags at write time (§6.4) — a retention-side fix, unrecoverable by retrieval-time machinery in our development runs, which is a small piece of direct evidence for the paper's thesis that structure at storage time beats search effort at query time. Open-domain (+13.1 pp) improved with retrieval depth and fusion but has n = 96 and ±3.87 certified spread; we flag it as the least stable estimate and do not build claims on it. Multi-hop is exact statistical parity with baseline (−0.03): the certified stack did not improve the hardest category, and development triage attributed its persistent failures predominantly to retrieval misses, wrong-instance ranking (the right entity's wrong occurrence outranking the right one), and multi-evidence assembly rather than to any mechanism the stack targets. We report the parity as-is rather than obscuring it in the overall gain. Single-hop (+2.1 pp on n = 841) is the volume category; its stability across all 10 runs is what the binding canary was designed to protect. We quantify what these same mechanisms cost in §6.6.

6.3Certified configuration

All frozen axes as Table 4; the vendor-side configuration, disclosed in full:

• Ingestion: one memory per conversation turn, verbatim, with resolved [event:] date tags and inline image captions.
• Retrieval depth: k = 90. A single-run sweep measured k = 80 → 84.9, k = 90 → 85.5, k = 100 → 85.7; the +0.2 at k = 100 is inside the run-noise band, and k = 90 was certified with deeper k's distractor and token load flagged as the guardrail cost.
• Fusion: hybrid BM25 + dense-vector retrieval fused by reciprocal-rank fusion [6] with k_rrf = 60; fusion only adds candidates and never displaces existing top results. It principally recovers exact-token and proper-noun misses.
• Minimum-similarity floor: embedder-aware similarity threshold with backfill — if post-threshold results number fewer than k/2, candidates below threshold are backfilled so that a query never starves while memories exist. This repaired a genuine product bug (queries starved to as few as 2 results), not a benchmark tweak; the fix ships in the product. After the fix, questions retrieving <20 memories fell from 60 to 7, <10 from 29 to 0, and zero-retrieval questions from 1 to 0.
• Query expansion: one additional recall call with an entity-focused rewrite, RRF-fused with the primary results.
• Date-anchored rerank: for date-scoped questions only, retrieved turns re-rank by resolved event date, constrained not to perturb the [event:] pathway that carries the temporal gains.
• Answer routing: a deterministic ordered-regex classifier assigns each question a terse answer prompt (1,066 questions) or a chain-of-thought prompt (474). Routing is answer-side prompting, not memory-side; the distribution was identical across the final development runs.

Token cost of k = 90. The certified run artifacts log neither per-question token counts nor the retrieved memory content, so the answerer-side cost of the k = 90 configuration was measured after the fact by a deterministic offline reconstruction of the exact per-question prompts (replaying the harness's pure ingestion and prompt-assembly path against the archived artifacts) followed by a tokenizer pass, not by estimation: the prompt delivered to the frozen answerer averages ≈6,080 input tokens per question, of which the memory-context block averages ≈5,790 tokens over a mean of 89.5 retrieved memories (median 90; 1,528 of 1,540 questions fill the full k = 90 cap). This puts the answerer's context budget essentially at Zep's published 5,760 tokens per question and below Mem0's 6,956 (§6.1): the k = 90 accuracy is not bought with an outsized token budget relative to the systems it is compared against.

6.4Development progression and what moved the needle

Table 7 records the build history. Development-stage scores are single runs and carry the ~0.5–0.8 pp per-run noise measured in §6.5; they are history, not certified claims.

Ranked by contribution: (1) per-turn ingestion with event-date normalization — the single largest mover, driving the temporal category from 64.49 to the low 80s; date-anchored answers require the ingest layer to resolve relative dates at write time, which no retrieval-time mechanism recovered. (2) The minimum-similarity floor fix, a real retrieval bug whose repair was the best per-unit yield of any retrieval component. (3) Hybrid RRF fusion. (4) Selective chain-of-thought routing — notably, routing CoT to all questions made results worse (net −10 on the affected runs): reasoning prompts on already-easy single-hop questions caused regressions, so a deterministic classifier applies CoT only where question shape warrants it. (5) Retrieval-depth sweep to k = 90.

6.5Answer churn: the noise floor of temperature-0 evaluation

Temperature 0 is widely treated as determinism; in production LLM inference it is not, and for benchmark methodology the size of the residual nondeterminism matters more than its cause. We measured it directly. Re-running the byte-identical configuration — same prompts, same ingest, same k, temperature 0 — regenerates ~5.4% of answers differently per run: measured cleanly on a subset held byte-identical to baseline, 51 of 952 baseline-correct answers regressed in a re-run from regeneration alone, with no configuration difference of any kind. To locate the noise, we separately re-judged identical (question, gold, prediction) tuples under the frozen judge: 1 of 124 verdicts flipped (0.8%). The churn is answer-side, not judge-side — the generous judge is nearly deterministic on fixed inputs, while the answerer is not on regenerated ones — so no amount of re-judging removes it; only cross-run persistence analysis does.

Two consequences shaped the whole program. First, any single-run LoCoMo claim carries this noise; per-run net σ was ≈0.5–0.8 pp during development, so single-run deltas under ~1 pp are uninterpretable, and we certify only 10-run mean ± std. Second, the churn measurement invalidated our own original quality gate: a per-category gross-retention floor of 97% of baseline-correct answers fails a null run (expected retention under churn alone is ~94.6%), i.e. it measured churn, not harm. Its replacement — gating on cross-run persistent regressions — is described next.

6.6The persistence gate G2-P: a disclosed failure

Net score can hide real substrate harm behind offsetting recoveries. To separate harm from churn, we pre-registered gate G2-P: for the certified configuration, a baseline-correct question counts as persistently regressed only if it is answered wrong in both runs of a run-pair (churn flips are approximately independent across runs, so double flips concentrate the substrate signal), followed by one frozen-judge re-pass that removes residual judge noise. The official measure joins all 45 pairs of the 10 certification runs.

Budget derivation (fixed before measurement). The RED budgets were derived from a pessimistic 2.5% harm allowance on the 1,233 baseline-correct answers, applied per category to preserve the anti-masking intent of the gate it replaced, plus the expected double-flip noise floor implied by the churn measurement, 0.0542² (the double-flip probability) × base-correct per category. Concretely: single-hop (743 baseline-correct) 18.6 + 2.2 ⇒ ≤ 21; temporal (207) 5.2 + 0.6 ⇒ ≤ 6; multi-hop (228) 5.7 + 0.7 ⇒ ≤ 7; open-domain (55) 1.4 + 0.2 ⇒ ≤ 2; total ≤ 35 (the total budget is derived from the aggregate baseline-correct count, 0.025 × 1233 + 0.0542² × 1233 ≈ 34.4, where 0.0542² is again the double-flip probability, not by summing the independently rounded per-category ceilings). To keep the gate's later recalibration from reading as gate-shopping, the expected verdict was also written down before the measurement, from a cross-configuration persistence proxy: single-hop predicted to pass at ≈ 13, temporal / multi-hop / open-domain predicted RED at ≈ 17 / 23 / 5.

Table 8 is the measurement: the certified configuration persistently loses on average 72.2 of the baseline's 1,233 correct answers (5.9%) — roughly twice the pre-registered budget — and the prediction was confirmed for temporal, multi-hop, and open-domain while single-hop, predicted to pass, came in RED at about 2.3× its predicted level. The other side of the same join: persistent recoveries average 170.0 (range 162–180), for a net persistent gain of +97.8 — a 2.4:1 trade ratio.

Stated plainly: the certified configuration is net-better with a published trade, not strictly dominant. The ingestion and retrieval changes that produce the +16.8 pp temporal and +13.1 pp open-domain gains inherently re-rank what the answerer sees, and no configuration in the program came close to passing the self-imposed harm budgets. Under the pre-committed rules this is a formal gate failure, and we disclose it as one rather than waving it through or retro-fitting the budget. We would generalize the point beyond this paper: at a measured 5.4% churn floor, any substantive memory-system change will persistently lose some previously-correct answers, and an evaluation that reports only net gains will not surface that loss. The per-key ledgers behind Table 8 are reproducible from the archived run artifacts.

6.7Estimated oracle-retrieval ceiling

How much of the residual wrong mass is winnable at all by better retrieval? The question matters because it separates two very different readings of an 85.55: “retrieval is leaving ten points on the table” versus “the frozen answerer and dataset cannot yield much more.” We identified the stable wrongs — questions answered wrong in ≥ 8 of the 10 certification runs, i.e. wrong for substrate reasons rather than churn: 150 in total (single-hop 53, temporal 40, multi-hop 36, open-domain 21) — and answered each from its gold evidence turns alone: perfect retrieval, with the answerer, answer prompt, and judge all frozen as in every other measurement. The oracle recovers 64.7% of the stable wrongs, implying an estimated ceiling of ~94.9 under the frozen protocol. (Ceiling arithmetic: the measured 64.7% recovery rate, extended to the full mean wrong mass of 14.45% of n, gives 85.55 + 0.647 × 14.45 ≈ 94.9; the extension assumes churn-driven wrongs are oracle-recoverable at no less than the stable-wrong rate — conservative, since churn wrongs are by definition answerable by the frozen answerer in some runs.) Two readings follow. About a third of the stable wrong mass is unwinnable even when the answerer is handed exactly the right evidence — the answerer fails to assemble the answer, or the gold itself is contestable — so no retrieval improvement of any kind can close that portion. And the certified 85.55 stands about 9.3 pp below the ceiling, a gap that is retrieval-precision-addressable in principle; whether it is addressable in practice is what §6.8 answers, negatively.

6.8Negative results: three dead reranking designs

The oracle probe says the gap to the ceiling is retrieval-precision-addressable in principle. We then tested whether it is addressable in practice by the obvious mechanism — rerank the retrieved candidates so the answerer sees a sharper context — and report the three designs that failed, because the failure mode generalizes. The designs escalate in caution: an aggressive reranker that truncates the answer context to the top 15 candidates; a guarded variant truncating to 25; and finally a deliberately zero-information-loss design that removes nothing and only annotates the candidates it believes are evidence, so that in the worst case the answerer sees exactly what it saw before plus markings.

Even the zero-information-loss variant paid measurable collateral: merely marking memories, without removing any, flipped 2.7% of stably-correct questions to wrong — the answerer's attention is not neutral to annotations. The break-even arithmetic explains why the whole design class is dead under this protocol, independent of implementation quality: any reranking intervention exposes 1,317 currently-correct answers to perturbation in pursuit of 144 addressable wrongs, a 9.15:1 exposure ratio, so a design must recover wrongs at more than nine times the rate at which it disturbs corrects merely to break even. At the best recovery rate measured across the three designs (17.3% of addressable wrongs), even a hypothetically collateral-free reranker caps at +1.62 pp (~87.2), well short of the ceiling — and no measured design was remotely collateral-free. We publish these numbers because the negative space is load-bearing for interpreting the field: the same arithmetic bounds any competitor's retrieval-side polishing under this protocol, and it converts the headline from “what we reached” into “what is reachable.” Our conclusion, recorded as the closing finding of the program: 85.55 ± 0.37 is the honest capability of this system under the frozen comparable protocol, and the residual gap to the oracle ceiling is not capturable by retrieval-side engineering without knowing the answers.

A disclosed non-comparable probe isolates the answerer's share of the residual: with identical memories, retrieval, and frozen judge, swapping the answerer to gpt-4.1-mini yields 89.68 in a single run (+4.13 pp from the answerer alone). This number must never be compared to the Mem0/Zep figures — different answerer — and is reported only to show the residue is largely answerer-limited, not memory-limited.