Run a memory-backed agent long enough and it develops a specific kind of amnesia's opposite: it remembers too much, and some of what it remembers is wrong. The customer's address it learned in March. The address you corrected in June. Both are in the store. Both retrieve. When someone asks "where do we ship this," the agent has to decide which memory is current — and that decision, it turns out, is a distinct skill that almost nothing does well.

Conflict resolution is its own competency#

We spent 2025 measuring whether agents could retrieve a memory. MemoryAgentBench, the benchmark that has become standard heading into ICLR 2026, argues that retrieval is only a quarter of the job. It grades four competencies: accurate retrieval, test-time learning, long-range understanding, and conflict resolution — revising or overwriting a stored fact when contradictory evidence arrives. It even ships a dataset built for it, FactConsolidation, and tests it the way production actually stresses memory: inject a fact once, update it, then query many times and watch whether the agent tracks the change or keeps serving the stale copy.

The scores are humbling. On single-hop conflict resolution, the strongest published RAG system — HippoRAG-v2 — lands at 54.0%. Some pipelines fall into the single digits. These are not systems that can't find the memory; they're systems that find both memories and pick wrong.

The instinct that makes it worse#

Faced with that, the natural move is to lean harder on the model: retrieve every version of the fact, drop them into context, and let the LLM reason about which is freshest. Bigger model, better judgment.

A May 2026 paper with a blunt title — Don't Ask the LLM to Track Freshness — takes that instinct apart. Its finding is that the bottleneck in conflict resolution isn't storage and isn't retrieval. It's assembly: the final step where candidates get compared and one is chosen. And that step, as usually built, asks the LLM to compare timestamps and serial numbers across a pile of near-identical memories — precisely the exact-ordering-over-structured-metadata task that language models are worst at.

Freshness is a clock problem wearing a reasoning problem's clothes. The fix isn't a smarter reader. It's a reader that knows to stop reading and count.

Their fix is almost anticlimactic. Keep the LLM for what it's genuinely good at — noticing that two memories are about the same fact and extracting the candidate values. Then replace the model's "which one wins" judgment with a deterministic selector: a few lines of Python that take the candidate with the highest serial. Same backbone, same retrieval, same chunking. Single-hop accuracy climbs 10.8 points, from 67.2 to 78.0. The gain came entirely from firing the model as a judge.

The division of labor#

This is the design principle worth internalizing: narrow the LLM's job to semantic identification, and delegate every comparison over structured metadata to code. The model says "these three memories all describe the shipping address." The code says "serial 4181 beats 3902; use that one." Neither is asked to do the other's job.

Two common architectures quietly violate this.

The append-only vector store — the default for most RAG-flavored memory, and the same store-everything-raw instinct that tops LongMemEval by keeping memories verbatim — writes every new version alongside the old ones and lets retrieval sort it out. But retrieval ranks by similarity, not recency, so the March address and the June address arrive as equals and the agent serves whichever scored higher. There's no clock in the loop at all.

The self-editing-on-write pattern, popularized by systems like Mem0, is smarter: at ingest, a model decides whether an incoming fact updates an existing record or adds a new one. It's the same instinct behind the two design philosophies we compared in Memora vs Wiki Memory — the question of whether memory is a thing you edit or a log you append. That cuts duplicate sprawl. But it's still an LLM adjudicating freshness — now with less context than it would have had at read time — and when it guesses wrong, the update overwrites the correct prior value with no way back.

Give memory a clock#

The robust version attaches an ordering key at write time and lets code do the ordering. A monotonic serial is enough for most agents. Where you need to answer both "what is true now" and "what did we believe last quarter," a bitemporal store tracks two clocks per fact — valid time (when the fact was true) and transaction time (when the system learned it) — which turns "which is fresher" from a judgment into a query, and leaves an audit trail besides.

There's a harder frontier past all of this, which the STALE benchmark names directly: can an agent even notice when one of its own memories has silently gone invalid — not contradicted by new input, just quietly out of date? Nobody's solved that. But the near-term win doesn't require solving it. It requires accepting that the model is the wrong tool for the part of memory that's really just arithmetic on timestamps — and handing that part to a machine that can count.