Recall Is a Write Operation

The usage write is not an accident or an implementation detail somebody forgot to remove. It is load-bearing, and it is there because the alternatives are worse.

A memory store needs to decide what to keep. Storage is finite, retrieval gets noisier as the corpus grows, and a store that never forgets becomes a store that cannot find anything. So it needs a signal for what matters.

The available signals are poor. Age is a bad proxy for validity, and a note is not less true for being old. Explicit importance labels are unreliable, because whoever writes the note is guessing about a future they cannot see. Content-based scoring cannot tell an important note from a verbose one.

Usage is genuinely the best available signal. A note that keeps getting retrieved is, on the face of it, useful. Reinforcing it is the obvious move, and it is roughly what human memory does. Reinforced retrieval strengthens the retrieved item and, as a side effect, the related unpractised items lose retention; Anderson, Bjork, and Bjork named this in 1994 and called it retrieval-induced forgetting. The mechanism is the same: retrieval writes to memory. This is why practically every agent memory system does it, and it is why the argument here is not that the write should be removed.

The argument is that the write closes a loop, that closed loops have dynamics, and that almost nobody has looked at what these dynamics are.

Write it out as a cycle. A note is retrieved. Retrieval updates its usage. Usage feeds ranking. Ranking determines what is retrieved next.

Every arrow is uncontroversial on its own. Together they form a positive feedback loop with no negative term. What is retrieved becomes more retrievable, which causes it to be retrieved, which makes it more retrievable.

The same shape shows up in classical feedback systems, in preferential attachment networks, and in the popularity-bias literature on recommender systems. The general result, in all three, is concentration: a small number of items capture a disproportionate share of attention, and the concentration is shaped substantially by early, arbitrary events rather than by intrinsic quality.

Applied to memory: whichever note happened to surface first for a class of query acquires an advantage that is self-sustaining, regardless of whether it was the best answer. Not because the ranking is bad, but because the ranking is recursive.

The competitor is not merely behind. It is behind in a way that compounds, and it has no mechanism to catch up, because catching up requires being retrieved and being retrieved requires having caught up.

The closest formal analogue is preferential attachment, the mechanism Barabasi and Albert proposed in 1999 to explain the scale-free degree distributions observed in real networks. The mechanism is plain: at each step a new node arrives and connects to an existing node with probability proportional to that node's current degree. The more connected a node is, the more likely it is to receive the next link.

Three properties of the model matter here, and each is stated explicitly in the source.

First, the model produces scale-free degree distributions of the form P(k) ~ k^-3, in the limit. The model is a positive feedback system in which initially random variations are automatically reinforced, and the Wikipedia summary of the model, drawing on the original paper, names this "the rich get richer."

Second, the reinforcement is unbounded without intervention. Concentration that begins as small initial advantage ends as permanent structure, because every step multiplies the imbalance.

Third, and the one that is easy to miss: both growth and preferential attachment are required. The model with growth alone produces a geometric distribution. The model with preferential attachment alone produces something that decays toward a Gaussian. The scale-free property emerges from the combination. Memory stores with usage-weighted ranking have both: notes are added over time, and retrieval probability is proportional to past retrieval count. The shape that produces concentration in Barabasi-Albert networks is the same shape that produces concentration in memory stores.

The connection runs through the same math because the same mechanism is at work: a quantity that grows in proportion to its current value, with no negative term, in a system that keeps adding new elements. Memory stores have all three. So do citation indices, social networks, and the long tail of any ranking system whose history feeds forward into the next ranking.

Concentration alone is not obviously bad. If the popular note is the right note, a system that surfaces it faster over time is a system that is improving. The failure is what happens when the popular note is wrong.

For a wrong note to be corrected, something has to expose it. Typically that means retrieving a competing note, or retrieving the wrong note in a context where its wrongness becomes evident. Both require the wrong note's competitor to be retrievable.

But the wrong note has been winning, so it has the usage advantage, so it keeps winning. The competitor has been losing, so it has decayed, so it keeps losing. The system's error-correction path runs through exactly the mechanism the error has captured.

This is the sharp point, and it is worth stating without hedging. The wrongness of the note is not what determines whether it survives. Its retrieval history is. Those two are correlated at the start and decouple immediately, because after the first retrieval the note's rank is being driven by its own past rank rather than by any property of the world.

A system with this shape does not fail loudly. It converges, and it looks like it is getting better while it does, because concentration is easy to mistake for confidence. The measured behavior of a memory store settling into a small set of reliably-surfaced notes is the same measured behavior whether that set is right or wrong.

The next post in this series, on the missing reinstatement primitive, makes the same point from a different angle: the store accumulates beliefs that nobody was willing to touch, and the symptom is invisible from inside the system. What is added here is the mechanism that makes the accumulation inevitable rather than incidental.

The usual response is that decay handles this. Old notes lose weight, so a stale wrong note eventually falls away and the competitor gets a chance.

Decay does not break the loop. It changes its time constant.

Decay penalizes notes that are not retrieved. The wrong note is being retrieved, so it is not decaying. The competitor is not being retrieved, so it is. Decay is not a counterweight to the feedback loop; it is the same loop with the sign flipped, acting on the loser. It accelerates the concentration it was introduced to prevent.

Decay only helps if the wrong note stops being retrieved, and the whole problem is that it does not.

There is a second, subtler version of this mistake. Adding a small random exploration term so that low-ranked notes occasionally surface is a real mitigation and it is better than nothing. Epsilon-greedy and Upper Confidence Bound are the two named treatments in the bandit literature, both with optimal-order guarantees under stationary reward distributions. But note what they concede. If the fix for a ranking system is to sometimes ignore its own ranking, the ranking has stopped being a statement about relevance and become a statement about history. Exploration is a patch on a corrupted signal, not a repair of it.

Both fixes (decay and exploration) treat the symptom. The disease is that ranking reads its own history, and the only cure is a ranking that does not.

Here is what makes this genuinely hard rather than merely subtle.

Suppose you want to know whether your memory store has this pathology. The obvious check is whether retrieved notes are useful. But usefulness is judged by the agent, using the retrieved notes, in a context shaped by the retrieved notes. The evaluation is downstream of the thing being evaluated.

Worse, the notes that would prove the store is wrong are precisely the ones the store has stopped returning. Their absence is invisible, because a retrieval that does not happen produces no output to inspect. You cannot see a miss.

So the pathology is self-concealing in two independent ways at once. The evidence against it is suppressed by the mechanism, and the metrics for detecting it are computed from the mechanism's own output. A store deep in this failure mode and a store working perfectly look identical from the inside.

The standard recommendation in the popularity-bias literature, where the same self-concealment problem has been studied for two decades, is to evaluate on a randomized exposure set: serve a uniform-random sample of items to a fraction of users and measure whether the items the model never recommends have similar quality to the items it does. The analog for agent memory is a held-out query set where retrieval is forced to be uniform across the candidate pool, and the evaluation asks whether the unpicked notes would have been better. The recommendation is unfashionable because it lowers the metric on every store that has been quietly winning, and a system that does not have the problem has nothing to fear from it.

If the problem is that ranking reads its own history, the fix is to make some part of the ranking causally independent of retrieval history. Four shapes, offered as design directions rather than as finished solutions, since none has been measured to validate the structural argument of this post.

Separate the signals

Usage can inform eviction, which is about what to keep, without informing ranking, which is about what to return. These are different questions and it is not obvious they should share a score. Coupling them is what closes the loop; decoupling them opens it, at the cost of needing a second signal for ranking. The published evaluation of MemX is consistent with this split: it tracks a retrieval count and a last-retrieved timestamp, both reported as inputs to a four-factor re-ranking that includes similarity, recency, frequency, and importance, with the frequency weight small (0.05) and the recency weight modest (0.25). The architecture does not feed the user's retrieval outcome back into the ranker in a self-referential way; the same paper reports that recency and time-decay are essentially uninformative as a primary signal, which is the natural outcome of treating usage as an eviction hint rather than as the rank.

Make corrections structural rather than competitive

If a note that corrects another is linked to it rather than merely ranked against it, the correction does not have to win a popularity contest to be seen. It arrives with the thing it corrects. This is the direction the prior post in this series argues for on different grounds, and it is worth noting that it independently dissolves this problem: a linked successor cannot be starved by the loop, because it is not competing in the ranking at all. The earlier post on reinstatement as the missing primitive makes the parallel point for the lifecycle: a note that is revoked and then proven correct can be reinstated precisely because reinstatement is an append, not a popularity contest.

Audit from outside the loop

Periodically evaluate notes against the world rather than against usage. Check whether a note's claim still holds. This is expensive and only works for checkable claims, but it is the only signal in this list that is genuinely exogenous. A store that audits a fraction of its notes against ground truth on a schedule can detect the loop from the outside, by measuring how its in-store accuracy compares to a non-usage-based benchmark. The result is a measurement, and the measurement is the only thing that can tell you whether the structural fixes above are actually working.

Instrument the concentration directly

Even without a fix, measuring how concentrated retrieval is over time, and how much of that concentration is explained by early ordering rather than by content, would tell you whether the dynamic is live in a given store. This is the cheapest thing on the list and, as far as I can tell, nobody publishes it. The measurement is straightforward: take the per-query retrieval count for each note, sort it, and report the share of retrievals captured by the top 1 percent of notes. A store in which that share is increasing session-over-session is in the loop. A store in which the share is stable or tracking the query distribution is not.

An argument that cannot be tested is not an argument. The structural claim here produces three concrete predictions, and they are testable in a way the loop's self-concealment does not defeat: the predictions are about comparative behavior across stores, not about behavior on a single store's logs.

Prediction 1. In a memory store with usage-weighted ranking, the distribution of retrievals across notes should become more concentrated over time, and more concentrated than the distribution of queries would justify. The second clause is the real test: concentration that tracks query concentration is just the store working. A simple measurement: for each store, compute the Gini coefficient of the retrieval distribution and the Gini coefficient of the query distribution, and report their difference across sessions. A growing difference is the loop running.

Prediction 2. Injecting the same note into two otherwise-identical stores at different initial positions should produce durably different long-run retrieval rates. If initial position washes out, the loop is weak and this argument is overstated. The experiment is cheap: seed two stores with the same note corpus, perturb the initial rank of one note in one of them, run a fixed workload of queries, and measure retrieval rates at the end. The two notes with the same content and different initial positions should have different long-run retrieval rates, and the size of the difference is the size of the loop.

Prediction 3. A known-wrong note that has accumulated retrieval history should be harder to displace than a known-wrong note with none, holding content constant. This isolates history from quality, and it is the cleanest available falsification. If displacement difficulty does not depend on history, the mechanism described here is not operating.

Prediction 2 is the one worth running first. It is cheap, it needs no ground truth about correctness, and it directly measures whether history dominates content. The interactive demo below is a small version of the same comparison: a one-query, ten-step simulation showing how the same note, placed at different initial ranks, accumulates different retrieval counts over a fixed workload.

The measurement this demo runs at the surface is the one I would want a production system to publish as a routine instrumentation report. A store that posts its top-1 percent retrieval share per session, and the share of that concentration attributable to position at the first session, makes the loop visible. A store that does not leaves the question open, and the question is the only one whose answer can prove the argument or retire it.

• Barabasi, A.-L., Albert, R. Emergence of Scaling in Random Networks. Science 286(5439), 1999. The original preferential-attachment model; P(k) ~ k^-3 degree distribution; explicit statement that "initially random variations are automatically reinforced." Wikipedia summary reproduces the model's stated limitations: growth and preferential attachment are both required for the scale-free property. Part 2.
• Anderson, M. C., Bjork, R. A., Bjork, E. L. Remembering can cause forgetting: Retrieval dynamics in long-term memory. Journal of Experimental Psychology: Learning, Memory, and Cognition 20(5), 1994. The first demonstration of retrieval-induced forgetting; the original Rp+ / Rp- / NRp paradigm. Wikipedia summary reproduces the three-category design. Part 1.
• Roediger, H. L., Karpicke, J. D. Test-Enhanced Learning: Taking Memory Tests Improves Long-Term Retention. Psychological Science 17(3), 2006. The standard reference for the testing effect that motivates reinforcement of retrieved items. Wikipedia summary reproduces the spaced-repetition amplifications. Part 1, for the connection to human memory and the limits of the analogy.
• Sutton, R. S., Barto, A. G. Reinforcement Learning: An Introduction. MIT Press, second edition 2018. The standard reference for epsilon-greedy exploration in multi-armed bandits; Chapter 2 covers the exploration-exploitation trade-off. Wikipedia summary of the bandit problem and the regret bounds. Part 3.
• Auer, P., Cesa-Bianchi, N., Fischer, P. Finite-time Analysis of the Multiarmed Bandit Problem. Machine Learning 47, 2002. The original UCB1 analysis with the O(sqrt(KT ln T)) regret bound; the optimistic-in-the-face-of-uncertainty framing. Part 3.
• Du, P. Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers. arXiv:2603.07670, 2026. The survey that names "self-reinforcing error" as the central risk of reflective memory; the API-always-errors example quoted in the prior post on reinstatement. Prior post cites the same source. Part 3.
• Chhikara, P., Khant, D., Aryan, S., Singh, T., Yadav, D. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv:2504.19413, April 2025. Production memory architecture; ADD/UPDATE/DELETE/NOOP update phase. Cited from Part 5 as a production system whose architectural choices are consistent with the decoupling argument, without making the claim that the system has been measured against it.
• Recommender system. Wikipedia article covering popularity bias, the self-contamination of training data, and the reproducibility gap between offline and online evaluation. The cited passages on "offline training is highly biased toward the highly reachable items" and on results of offline evaluations showing low correlation with user studies or A/B tests. Part 3 and Part 4.
• Wu, D., Wang, H., Yu, W., Zhang, Y., Chang, K.-W., Yu, D. LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory. ICLR 2025, arXiv:2410.10813. Five abilities including knowledge updates; 500 questions; the reported 30 percent accuracy drop across long interactions. Cited in Part 4 as the empirical shape of the recency problem, not the mechanism.
• Relevance Is the Wrong Sort Order for Agent Memory. The prior post in this series, published 30 August 2026. Argues that the unit of retrieval should be a trajectory, not a ranked set, and that the lifecycle edges on notes are not being used at retrieval time. The close of this post names the distinction between that argument and this one explicitly.
• Reinstatement Is the Missing Primitive in Agent Memory. The post on the missing reverse edge of revocation. Part 4 cites it for the same failure mode this post names from the other side: a memory store that cannot reverse a wrong correction accumulates bad beliefs, and the structural reason is the same feedback loop this post analyses.