What the collector actually does
A running program allocates memory continuously and returns almost none of it by hand. Left alone, this is fatal: the heap grows until nothing is left to allocate, and the program halts not from a logical error but from bookkeeping neglect. Garbage collection is the automatic reclamation of memory a program can no longer reach. The collector starts from a set of roots — registers, stack slots, global variables — and traces every pointer reachable from them. What it cannot reach, it calls dead, regardless of whether that memory holds something the programmer thinks of as valuable. Reachability is the criterion, not usefulness. A large, carefully computed result that nothing points to any more is garbage. A trivial counter still referenced by an active loop is not.
The part easy to miss is that this tracing happens while the program keeps running. A program does not pause its business to have its memory audited and then resume; the collector and the program compete for the same heap in something closer to a race than a phase. Object are being created while the collector decides which of yesterday's objects have gone unreachable. The invariant that makes this survivable is simple to state and hard to guarantee: the collector must free memory at least as fast as the program consumes it, or the heap grows without bound regardless of how clever the tracing is. Get the rate wrong and you have not saved effort, you have deferred a crash.
This is why garbage collection is not "cleanup." Cleanup implies a discrete task with a beginning and an end, something scheduled for quiet hours. A tracing collector has no quiet hours if the program never stops allocating. It is a permanent commitment made at design time, with its own failure mode distinct from a memory leak: not merely "we forgot to free this" but "the rate of reclamation fell below the rate of allocation," a race lost rather than a step skipped.
Origin
John McCarthy specified mark-and-sweep collection for Lisp in 1960, driven by a concrete difficulty: recursive list operations built structures whose lifetimes no programmer could reasonably track. Manual allocation and deallocation, workable for arrays and simple records, broke down against cons cells linked and relinked at runtime in patterns fixed by the program's logic, not by any schedule a person could anticipate. The fix was to stop tracking lifetime by hand and instead trace reachability from roots at intervals, freeing whatever the trace failed to touch.
The idea then had to be made to survive contact with real machines. Cheney's 1970 algorithm made copying collection non-recursive, using the destination region itself as a queue and removing the need for an auxiliary traversal stack that could itself run out of space at the worst moment. Dijkstra's 1978 tri-colour marking scheme made it possible to collect safely while the program continued mutating the heap underneath the collector — a genuine advance, since the earlier stop-the-world approach assumed the world would in fact stop. Ungar's 1984 generational scavenger exploited an empirical regularity: most allocated objects die young, so segregating new objects from old and collecting the young generation far more often than the old one buys enormous throughput. Each of these moved collection further from a discrete phase and closer to something running continuously alongside the program it serves.
The turn
Set that history next to a question about intake: what kind of thing is a system taking in, and does the intake ever stop?
A Large Language Model is trained once against a corpus fixed at a cutoff. Whatever it "knows" was allocated in a single pass and never revisited; there is no live process reaching for the training data at inference time. When the corpus goes stale, the model is retrained or replaced — the whole arena is torn down and rebuilt, never selectively reclaimed. This is arena allocation: cheap, simple, and correct only because nothing is added between the beginning and the end of the arena's life.
A Large World Model observes a bounded scene: a room, a manipulation task, a driving segment. The scene closes and its sensed representation goes with it. Reclamation here does not need a tracer at all, because scope does the work — this is stack discipline, not garbage collection. You don't decide what's still reachable; you simply pop the frame.
A Large Universe Model, as argued elsewhere on this site, is defined by intake that never closes: streams keep running, beliefs keep accumulating, and there is no scene boundary that ever falls due. Nothing pops off a stack, because there is no stack, only a heap that keeps growing as long as sensing continues. This is exactly the condition under which McCarthy's problem reappears in a different vocabulary. Beliefs, not cons cells, are the allocated objects; provenance chains, not pointers, are the edges; and the question a Large Universe Model must answer continuously is which beliefs are still reachable from live evidence, and which persist only because something stale still cites them. Two beliefs that cite each other as their only support are a reference cycle, and cycles are precisely what naive reference counting cannot collect and tracing can. The discovery, such as it is, is that this is not a metaphor bolted on afterward — the structure of the problem (unbounded accumulation without a natural closing scope) is the same structure McCarthy was solving in 1960, one layer up.
What forces the terminal position
Call the underlying claim narrow and check whether it survives its own narrowing. Any system that observes without a stopping point accumulates state monotonically unless something does maintenance at a rate keyed to its own intake rate. That maintenance cannot be deferred to a training run, because there is no training run to defer it to; it cannot be scoped to an episode, because episodes are exactly what a continuous stream lacks. So the terminal position on the intake axis is not "sees the most." It is the first position where forgetting has to be engineered rather than inherited for free from a build step or a scene boundary.
The misreading to disown
The obvious misreading treats this argument as praise for total retention: a system that remembers everything is superior, and Large Universe Models are terminal because they hoard the most. That is close to backwards. An unreclaimed heap that grows without bound is the failure state, not the achievement — the machine that thrashes, the model whose retrieval surfaces ten contradictory versions of a fact and cannot say which one is live. The strong claim is that everything-continuously is terminal precisely because it is the first regime where deliberate, provenance-aware forgetting becomes a first-class requirement, not an operational nicety you bolt on if you get around to it. Breadth of intake without a collector that keeps pace is not an advantage. It is the same crash McCarthy was trying to prevent.
Objections, taken seriously
Storage is cheap. Object storage costs fractions of a cent per gigabyte-month. Modern architecture keeps everything and derives views on demand — deletion is the anti-pattern now, not retention.
True of bytes, false of reachability. The cost that actually bites is not storing the fact that a flood plain designation changed in 2019; it is the index that must be rebuilt, the embedding that must be refreshed, and the retrieval step that must discriminate among ten near-duplicate assertions to find the one still supported by live evidence. Kafka has retention policies. LSM-tree storage engines run levelled compaction. These are collectors wearing other names. Keeping the bytes is cheap. Keeping the bytes queryable and non-contradictory is the part that costs, and it scales with intake, not with disk price.
Every long-running system needs maintenance — databases vacuum, filesystems defragment. This is generic, not distinctive to continuous observation.
Concede it outright. Maintenance is universal; the claim would be weaker for pretending otherwise. What differs across the three positions on the intake axis is whether maintenance can be scheduled off the workload's critical path. A frozen corpus permits offline cleaning between training runs. A bounded scene permits reclamation at scene exit, no tracer required. An unbounded stream permits neither. It forces concurrent collection — tracing that runs alongside live writes, with the collector's own failure mode of losing the race to intake. That is a difference in kind, not merely one more increment of the same chore.
Deterministic alternatives exist. Rust reclaims memory at compile time via ownership and lifetimes, with no runtime collector at all. Belief maintenance could use static schemas and expiry stamps instead of a runtime tracer.
Static lifetime analysis works because the compiler can see the whole program in advance. A continuously observing system cannot see the whole stream — evidence that resurrects a retired belief, or orphans one thought secure, has not arrived yet and cannot be scheduled for. Expiry stamps handle the easy, foreseeable cases and are worth having regardless. They cannot handle the case where a belief's reachability depends on evidence not yet collected. Reachability from live evidence is a runtime property here, genuinely undecidable in advance, which is exactly why McCarthy needed a tracer rather than a schedule in 1960.
What this does and does not establish
It establishes that continuous intake, once granted, makes an ongoing collector logically necessary rather than a design choice — the same inference McCarthy made about heaps applies to belief stores that never close. It does not establish that any current system implements such a collector well, or at all; provenance-aware belief retirement, at the scale a genuinely continuous system would require, remains mostly unbuilt and only partly specified. Nor does it establish that intake is the only axis worth ranking systems on, or that a system topping this axis is thereby the most capable or most useful system by any broader measure. The ladder has a top rung on this one axis. That is a narrower claim than it sounds, and it is the only one made here.