A 92.5 on the LoCoMo memory benchmark tells you your agent can retrieve a fact, and almost nothing about whether it will keep serving that fact with full confidence after it stops being true 3. Those are two different objectives, and the whole 2026 leaderboard trio grades only the first. The reflex fix, decay and TTL and dynamic forgetting, aims at the wrong target too: it prunes old memories by age when the failure that actually breaks a running agent is a memory that is confidently wrong under a newer, contradicting fact. The move that targets trust is counterintuitive, and I think most teams reach for it last: take the freshness judgment away from the model and resolve it deterministically from timestamps and provenance.
The score that says nothing about trust
Picture the memory mem0 uses as its own opening example: a highly retrieved fact about a user’s employer, accurate right up until they change jobs, at which point it becomes confidently wrong 3. Retrieval never falters here. The store finds the fact every time, ranks it high, and serves it. That is precisely what LoCoMo rewards, and it is the reason a 92.5 feels like reliability when it is not.
The gap is not that the benchmarks are sloppy. It is that recall at retrieval time and trust at inference time are different properties, and passing one predicts nothing about the other. An agent that aces recall can still act on a fact that stopped being true, because nothing in the recall objective ever asked whether the served memory had been superseded. I would go further: the confident-wrong case is the one that costs you in production, and it is the one no leaderboard number touches.
What the benchmarks actually grade
Look at what the numbers measure. LoCoMo reports 92.5 accuracy and LongMemEval 94.4, both scoring whether the right past fact comes back for a query 3. That is recall, dressed as accuracy. It is a necessary condition for useful memory, not a sufficient one 1. The missing test is specific: no benchmark systematically introduces contradicting information, so a memory going stale-and-confidently-wrong is never exercised 1. LoCoMo in particular does not, because its evaluation set never injects the contradiction that would expose the failure 1.
Even the recall objective frays once you scale it. BEAM scores 64.1 at one million tokens and drops to 48.6 at ten million 3. So the thing the leaderboards do measure is already breaking under context pressure, before trust is even in scope. If pure retrieval halves as the haystack grows, a headline accuracy figure taken at a comfortable context length is flattering twice over.
Why decay is the wrong fix
The popular mitigation is to forget on a schedule: decay functions, time-to-live, dynamic forgetting. These operate on a single memory in isolation and ask one question, is this record too old to keep. That is recency, and recency is not the failure. A confidently-wrong memory is not necessarily an old one; it is one that a newer, retained fact now contradicts. Decay never adjudicates that conflict, because it only ever looks at one record’s age. No benchmark measures whether confidence tracks age and corroboration, so a decay knob tuned to a leaderboard optimizes a property nobody scored 1.
The strongest objection to all of this is that the benchmarks are catching up. LongMemEval already tests updates, BEAM already stresses very long context, so recall is arguably a good-enough proxy for trust, and this whole distinction is a benchmark-is-incomplete truism dressed as insight. I take that seriously, and it still loses. Recalling the freshest fact is not the same operation as suppressing the stale one: the first is retrieval, the second is conflict resolution plus a confidence gate. None of these benchmarks systematically inject the contradicting updates that would separate the two 1, and BEAM dropping to 48.6 at ten million tokens shows recall itself failing before trust is on the table 3. The distinction is falsifiable, not definitional: build a benchmark that injects updated-contradicting facts and scores confident-wrong rate, and a high LoCoMo score will not predict a low one. That is a prediction you can run, which is what keeps it from being a truism.
Take the freshness call away from the model
If decay is the wrong lever, what is the right one. The counterintuitive answer from Reddy and Challaram is to stop asking the LLM to track freshness at all 2. Their recipe resolves conflicts between old and new information deterministically, from explicit timestamps and metadata rather than the model’s soft judgment, and they evaluate it on stale-fact resolution tasks on MemoryAgentBench and LongMemEval rather than on recall 2.
The reason to move the judgment out of the model is that soft reasoning over which of two facts is current is exactly where confident-wrong behavior is born. A timestamp comparison does not hallucinate a preference; a provenance check does not get talked into the wrong record by fluent context. This is not the same thing as TTL. TTL also reads a timestamp, but it acts on one memory’s age in isolation. The deterministic resolver acts on a contradiction between two memories, given a newer record that conflicts with an older one, decide which is current, and it couples serve-time confidence to that resolution and to corroboration. A store can have flawless decay tuning and still confidently serve a stale fact its own newer memory contradicts, precisely because decay never ran the comparison.
What to ship
The practical consequence is a shift in what you gate on. A high LoCoMo score tells you nothing about whether your agent will confidently serve a fact that stopped being true, so stop reading recall as a reliability signal and start gating memory on staleness and corroboration: resolve old-versus-new conflicts from timestamps and provenance, and hold back serve-time confidence when a fact is old or uncorroborated. Evaluate the memory layer on stale-fact resolution, not on where it lands on a recall leaderboard.
Cost is the honest objection here, and the one clean figure comes from mem0’s own product benchmark, so read it as such: mem0 reports its new algorithm at about 6,900 tokens per query against roughly 26,000 for full-context approaches 3. That is the vendor’s own number for its own algorithm, not an independently verified cost of the deterministic timestamp recipe, and I would not present it as one. It suggests structured resolution need not blow up your context budget, which is a reason to try the approach, not a proof that it is free.