When Facts Change: Interference, Lookback, and Aggregation
Long-term agent memory systems face a specific difficulty when information changes: they may retrieve the newest plausible statement without retrieving the state a question actually names. This chapter focuses on temporal interference—the way older and newer information compete—and uses MINTEVAL to show how current-state recall, historical lookback, and reasoning across several updates stress different parts of a memory system. The goal is practical: readers should be able to classify a memory question before deciding whether a system has succeeded.
An update has a direction in time
Suppose an article first says that a building has eight floors and later changes the number to ten. A request for the current number should return ten. A request about the previous revision should return eight. A request asking when the change happened or how many other facts changed at the same time requires both values and their relationship. The text contains the answers to all three questions, but the questions do not ask for the same state.
This is why an update is not simply a new sentence. It is a transition involving an object, a prior value, a new value, and some indication of when or under which version the change occurred. A memory system that stores only the most recent value can answer the first question while making the second impossible. A system that keeps every sentence but loses version identity may retain the words while making the third question unreliable. The essential issue is not whether the information exists somewhere; it is whether the representation preserves the distinctions a later query will need.
Two kinds of interference make this difficult. Retroactive interference occurs when newer information disrupts access to something stored earlier. In the example, the statement “ten floors” can make “eight floors” harder to retrieve, especially if the question does not repeat the old version’s wording. Proactive interference runs in the other direction: an older state can interfere with the encoding or retrieval of a newer one. If a fact has changed several times, the system may continue to favor the familiar earlier value or treat the new value as a duplicate rather than a replacement.
These are not rare edge cases for agents. A user may change a preference across conversations. A software project may revise an API while an agent still needs to explain an earlier release. A web workflow may move an item from a cart to an order, changing which actions are valid. In each case, “remember the fact” is incomplete. The system must know whether the fact is current, historical, or part of a transition.
The distinction also explains why simply passing more history to the model is not a complete answer. Full context can preserve raw evidence, but the input grows as interactions accumulate, and a fixed context budget eventually becomes a boundary. Even within the available window, similar statements can compete for attention and a question may refer to a point far earlier than the latest update. The systems-characterization research describes the same pressure from a serving perspective: long histories increase prefill work, and long-sequence recall and reasoning can degrade even when the nominal window is large.
A useful way to classify a query is to ask what state operation it requests. A current-state query asks for the latest value after all applicable updates. A lookback query names an earlier point, revision, or event and asks the system to recover the corresponding state. An aggregation query requires several targets: it may order events, count occurrences, compare versions, or follow a chain across updates. These operations can share the same underlying history while requiring different retrieval behavior.
Temporal markers help because they give similar statements distinct identities. Dates, revision numbers, or other explicit cues can reduce the chance that a retriever treats an old and new value as interchangeable. In MINTEVAL’s tested Full Context and RAG settings, adding such cues substantially reduced the performance drop as lookback distance increased. But a timestamp is not provenance by itself. It must remain attached to the relevant evidence, survive memory construction, and be used when the query asks for a specific point in time. A date printed in the raw history cannot help if compression strips it away or retrieval returns the fact without its date.
The state transitions can be represented like this:
The diagram is deliberately not a claim that every system implements these states explicitly. It is a way to expose the obligations hidden inside a simple question. A current-state query can terminate at the latest representation. A lookback query needs a preserved historical branch. An aggregation query needs access to multiple branches and a way to combine them. Interference is the failure condition in which the branches exist in the source history but are not kept distinct or not surfaced together.
What MINTEVAL reveals about the write/read boundary
MINTEVAL turns these distinctions into a stress test across four evolving domains: bAbI state tracking, multi-turn dialogue, Wikipedia revisions, and GitHub commits. The benchmark contains 15.6 thousand question-answer pairs. Its contexts average about 138.8 thousand tokens and 86 temporally ordered updates, with some instances reaching 1.8 million tokens. The domains differ in how information changes: simple state facts may be overwritten, preferences may be expressed indirectly in conversation, article revisions may add or remove claims, and code commits may alter identifiers and behavior across files.
Its single-target tasks separate the latest state from the past. “Simple” questions ask for the most recent value after updates. “History” questions ask about an earlier value despite later, potentially conflicting information. Its multi-target tasks then add three forms of combination: Ordering reconstructs the sequence of events, Counting aggregates occurrences or durations, and Multihop connects multiple targets through a chain of reasoning. The benchmark therefore tests not just whether a system can find a relevant item, but whether it can locate the right time, gather the needed set, and perform the required operation.
The scores show why that distinction matters. In the main comparison, Simple questions average 47.5 percent, while History questions average 21.0 percent and multi-target aggregation questions 26.5 percent. The best overall result reported for the evaluated systems is 33.4 percent. The paper’s abstract gives an overall average of 27.9 percent, while a results paragraph describing the six-system table gives 27.7 percent; that small internal reporting difference is a reason to read the result as roughly 28 percent, not as a falsely precise universal score. The stable conclusion is the gap between recent recall and update-dependent reasoning.
The variation across domains is equally important. MemAgent, the strongest overall system in that comparison, reaches 85.7 percent on bAbI Simple but only 7.5 percent on HorizonBench Simple. A system can therefore look effective when facts are short, explicit, and symbolically structured, yet fail when information is distributed across natural-language interactions or changes implicitly. This is a warning against treating a benchmark average as a property of the architecture independent of its workload. The reported values come from specific checkpoints, answering models, embedding models, chunking choices, and exact-match evaluation.
MINTEVAL’s error analysis helps locate the failure. In a Wiki Revisions analysis, the required evidence is guaranteed to exist in the complete history. Even so, only 58.3 percent of cases contained the needed evidence in the retrieved documents or constructed memories. The authors attribute a 41.7-point drop to retrieval or memory-construction failure. When the evidence was present, the answering model contributed a further average 25.2-point drop. This is not a formal causal decomposition across every domain; it is a targeted analysis of a subset. It nevertheless gives a useful diagnostic rule: first ask whether the memory delivered the right evidence, and only then ask whether the final model reasoned over it correctly.
Lookback distance makes the same boundary visible over time. As the number of intervening revisions grows, performance generally falls. Full Context and ordinary retrieval methods show the largest degradation in the reported analysis, while memory-based agents decline less sharply, plausibly because some of them encode temporal order or accumulated relationships. The evidence supports a conditional observation, not a guarantee that an external memory is more historically faithful. A compact representation can preserve order, but it can also erase the exact revision or provenance needed for a question.
Noise adds another test. In a bAbI experiment, the authors inserted one, three, or five sentences that could not change the answer. Some distractors came from novels and differed in style; others followed the same simple structure as the target facts. Accuracy generally decreased as distractors increased. RAG suffered the strongest degradation with out-of-domain distractors because it retrieved irrelevant sentences more often, while Full Context and Mem-alpha were less sensitive to the difference between distractor types. Even in-domain distractors affected History and Counting questions more than Simple questions. That pattern makes sense: a system that must track several facts or distinguish an old state has more opportunities to treat a harmless similar item as evidence.
The update ablation points back to the write path. In MemAgent, larger processing chunks—and therefore fewer memory modifications—generally improved performance, especially for History and Counting questions. Frequent modifications can accidentally overwrite or remove information that a later question still needs. This does not mean that fewer updates are always safer. A very large chunk can also delay a necessary correction. The result says that update frequency and granularity must be matched to the semantics of the stream: a system needs enough opportunity to incorporate a real change, but not so many loosely controlled revisions that its representation becomes unstable.
The operation counts reveal a related asymmetry. AtomMem and Mem-alpha use insertion, modification, and deletion operations, but insertion dominates in the reported configurations: 87.6 percent of operations for AtomMem and 65.9 percent for Mem-alpha on average. Incremental revisions are often implicit, and the systems operate on relatively coarse units. A small change can therefore be recorded as a new memory rather than recognized as a modification of an existing one. The store grows redundant entries, and the retrieval path is left to resolve a conflict that the write path should have represented more clearly.
This is the practical meaning of the write/read boundary. A retrieval failure can sometimes be improved with better query formulation, temporal metadata, reranking, or a different search operator. But if construction has merged two versions, discarded the revision identity, or appended a new value without linking it to the old one, the read path may have no reliable way to reconstruct the intended state. Conversely, preserving every raw item does not guarantee success if the retrieval path returns only one plausible fragment when the question requires a set or a relation.
The lesson is not that MINTEVAL has found one winning architecture. Its low scores and domain swings show that current memory systems remain conditional and brittle under interference-heavy workloads. The benchmark instead gives a vocabulary for asking better questions: Which state does the query name? Was that state preserved? Can the system distinguish it from later values? Can it gather all targets needed for the operation? And did the failure occur during construction, retrieval, or final reasoning?
Those questions become sharper when the history is not just a sequence of text revisions but a trajectory of actions and observations. In an agent environment, the relevant memory may be a precondition, a state transition, or the consequence of a tool call. The next step is to examine why semantic similarity can retrieve something related while still missing the causal relationship that makes an action valid.