Memory Has a Lifecycle
An append-only store is not a memory, it is a landfill with an index. Four ICLR 2026 submissions make a related case: memory needs filtering, consolidation, decay, and offline maintenance, not just storage. One of them makes the sleep metaphor unusually concrete.
TL;DR. The laziest way to build agent memory is to store everything and let retrieval sort it out. Four ICLR 2026 submissions push against that from four different directions, and they share a useful premise: memory needs selection, maintenance, and expiry, not just storage. LightMem stages memory with a sensory filter, short-term consolidation, and offline sleep-time updates, with explicit efficiency results. Mnemosyne brings commit and prune operations, temporal decay, and refresh to edge-scale memory. Meta-Memory treats storing, structuring, validity, and retrieval as one joint decision. MemoryField explores fusion, forgetting, and self-organization. The thesis I take from them is that memory is a lifecycle, not a table, and my experience building these systems is that a store that only hoards does not really remember.
There is a default architecture for agent memory, arrived at not by design but by inertia. Every conversation turn, every observation, every tool result gets embedded and appended to a store. Nothing is ever removed, because storage is cheap and deletion is scary. Retrieval is expected to compensate, sifting the pile at read time for whatever matters now.
I think of this as the landfill architecture. It has an index, so technically you can find things. But nothing in it was ever appraised, nothing decays with dignity, and every year the sifting gets harder because the pile only grows. The ICLR 2026 memory submissions include at least four serious papers that each push against this architecture from a different angle. Collectively, on my reading, they make the case for treating memory as a lifecycle problem rather than a storage problem.
What the Human System Actually Teaches
Memory papers love brain metaphors, and most of the time the metaphor is paint. Hippocampus this, cortex that, and underneath it is a vector database with extra adjectives. So I want to be careful about which lesson from human memory I think is actually load-bearing here.
It is not the anatomy. It is the selectivity. The textbook account of human memory, simplified as every textbook account is, describes a pipeline of filters: most sensory input fades quickly, short-term traces persist when something promotes them, and consolidation, much of it associated with sleep, transforms and compresses rather than copies. In that account, forgetting is not the system failing. Forgetting is the system doing its job, clearing interference so that what remains is findable and coherent. I hold all of that as a working analogy rather than settled ground truth, and the lifecycle papers borrow its themes rather than reproduce the biology.
The landfill architecture borrows none of them.
Four Angles on the Same Correction
LightMem is the most direct translation of the staged pipeline: sensory filtering at the front gate, short-term consolidation in the middle, and long-term updates deferred to offline sleep-time processing, with explicit efficiency results attached. My own design inference, and I should mark it as mine rather than the paper's, is that early filtering is where the money is. Material discarded at the gate is material you never pay to embed, store, index, and forever re-rank. The landfill architecture pays full price for its garbage.
Mnemosyne works the retention side: explicit commit and prune operations, redundancy filtering, temporal decay, refresh, and compact summaries of the user. The reading-list description does not specify the policy that governs refresh and pruning, so I will not invent one, but decay paired with refresh is still the design to notice, because it treats retention as something a memory can keep earning rather than a default it enjoys forever. That is an economy, not a warehouse.
Meta-Memory reframes the write path as a set of decisions made jointly: whether to store at all, in what structure, whether the stored thing remains valid, and when it should surface. I read this paper as the strongest philosophical statement of the cluster. Storage is not an event that happens to information. It is a policy the system executes, and validity is part of the policy. Once validity is a first-class decision, a memory becomes something the system keeps deciding about rather than something it merely has.
MemoryField is the most exotic of the four, exploring fusion, forgetting, decay, self-organization, and adaptive structural reorganization of memory. Whatever one makes of the specific mechanism, the framing commitment reads the same as the other three: maintenance treated as a first-class activity rather than an afterthought.
Four groups, four vocabularies, one shared premise: memory has a lifecycle. My bet, and the reason I build this way, is that systems skipping the lifecycle are not simpler versions of the same thing but a different thing whose weaknesses show up late.
Why Hoarding Degrades Recall
The counterintuitive part, and the reason the landfill survives as an architecture, is that hoarding does not fail loudly. Nothing is ever lost, so it feels safe. The degradation, when it comes, is statistical, which is exactly why it hides.
Every irrelevant memory in the store is a lottery ticket for retrieval to surface it instead of the memory that matters. Stale near-duplicates crowd rankings. Superseded facts sit next to their replacements with nothing marking which is current. Interference, the oldest finding in the psychology of forgetting, has an obvious analogue here: the more similar traces you accumulate, the harder any one of them is to retrieve cleanly. Whether an append-only store actually degrades, and how fast, is an empirical question per workload, and the reading list itself contains a submission, Forget Forgetting, that challenges storage-scarcity arguments for pruning in continual training. My experience is that the degradation is real and silent, which is the worst way to be wrong, but it deserves to be measured, not assumed.
Consolidation and forgetting are the countermeasures, and they are complementary. Consolidation compresses many episodes into the durable thing they collectively mean, and forgetting clears the residue. The point of running both is to preserve useful history while thinning the stale and the redundant, and the trade-offs between them deserve measurement rather than assumption.
Sleep Is an Architecture Now
The detail I find quietly delightful in this cluster is the rehabilitation of sleep. LightMem makes an explicit case for offline long-term updates, which turns deferred maintenance into a design option worth testing whenever request-path latency matters. Consolidation is expensive, and the request path is a bad place to pay for it, so an agent that is idle anyway might as well dream. Where the workload permits it, we build our own systems this way, with background processes that consolidate, age, and validate memory while nothing is watching, and I have yet to regret a single piece of work we moved off the hot path and into the night.
I wrote in Context Windows Are Not Memory that holding information and remembering are different capabilities. The lifecycle papers sharpen that distinction one more turn: even storing information and remembering are different capabilities, because remembering is mostly what happens between the writes.
I think the landfill model gets harder to defend as memory evaluation broadens beyond storing more text. What I want in its place looks less like a database and more like a metabolism. Things come in, most things pass through, and what stays is what the system, on reflection and usually overnight, decided was worth becoming.