Garbage collection in emergency management
At 03:14, the river gauge at the county line crossed flood stage. The automated alert reached the operations centre at 03:16. The evacuation order for the three low-lying wards did not go out until 06:40, roughly ninety minutes after water was already crossing the first access road. The emergency manager on shift had the gauge reading, the rainfall forecast updated at midnight, a mutual-aid roster last confirmed the previous afternoon, and a population estimate for the wards drawn from a census file eleven months old. None of these were wrong individually. Collectively they described a county that no longer existed by 03:16.
The order, when it finally issued, matched the hazard as it had been an hour and a half earlier. It named a road that had already flooded. It assumed a shelter capacity that had shrunk because a rival response — a structure fire two districts over — had pulled two engines and a school gymnasium out of the available pool at 02:50. The order was accurate. It was accurate about a world that had moved on. This is the characteristic failure of the domain: the evacuation follows the hazard rather than leading it, not because anyone was slow to look at the data, but because the data the decision drew on was a mixture of live and dead material, and nobody had a procedure for telling which was which in real time.
What actually happened
Trace the ninety minutes backward and the fault is not sensing. Sensing was fine. The gauge, the rain radar, the traffic cameras, the shelter occupancy feed — all reporting, all within their normal latency. The fault is that the emergency manager's operating picture was a heap that had never been swept. The eleven-month-old census estimate was still sitting in the same decision layer as the two-minute-old gauge reading, with no marker distinguishing a load-bearing current fact from a stale one nobody had gotten round to retiring. The mutual-aid roster confirmed "yesterday afternoon" looked, on the screen, exactly as fresh as the roster confirmed at 02:50 after the fire reassignment, because the interface showed a timestamp, not a reachability status. Every one of these facts had, at some point, been allocated into the picture correctly. Nothing then ever deallocated the ones that had gone dead. The picture grew stale in place while remaining, in every screen and every printout, apparently current.
This is not a data quality problem in the ordinary sense. The data was there. The forecast model was defensible. What was missing was a live answer to a different question: given everything now known, which of the beliefs currently informing this order are still reachable from evidence that is still true, and which are held up only by a reference nobody has checked lately? That question has a name in computing, and the domain has been solving an adjacent version of it, badly, by convention rather than by design.
The concept, named
Garbage collection is the automatic reclamation of memory a running program can no longer reach. A collector starts from a set of roots — registers, stack slots, global variables — and traces outward across every live pointer. Whatever it cannot reach from a root is dead, regardless of how expensively it was computed or how important it once was, and the space it occupies is returned to the allocator. The criterion is reachability, not usefulness, not cost, not sentiment. Because the running program keeps allocating while the collector works, this is never a discrete phase to be scheduled at leisure. It is a permanent race: the collector must free memory at least as fast as the program consumes it, or the heap grows without bound until the machine thrashes.
Emergency management runs precisely this race with beliefs instead of memory. The census estimate, the roster confirmation, the shelter capacity figure — each was allocated into the operating picture when it was true. Each remained in the picture after ceasing to be reachable from anything currently live: the roster was overwritten by a later event that nobody propagated backward; the shelter capacity depended on a resource assignment that had since been revoked. No process traced from the current state of the world back through these claims to ask whether they were still supported. They were not deleted because nobody deletes them; they were not flagged because nothing in the interface distinguishes a load-bearing belief from a dead reference sitting at the same z-order on the map.
Why the fix isn't "keep more data"
Storage is not the issue here. Every agency archives its gauge history, its census files, its old rosters, indefinitely and cheaply. The problem was using them, not keeping them.
This is correct about bytes and wrong about the actual cost. Nobody in that operations centre ran out of disk. What ran out was the capacity to discriminate, at 03:16, between the ten different snapshots of "shelter capacity" sitting in different systems, each internally consistent, only one of them current. Keeping every version of the roster is free. Keeping the operating picture queryable, at speed, in a way that surfaces which version is still supported by live evidence — that is continuous work, proportional to how much is streaming in, and it does not happen by archiving harder. Append-only incident logs already do this at the storage layer; most computer-aided dispatch systems compact and re-index constantly precisely because an unindexed accumulation of true-but-superseded records is functionally indistinguishable from noise when a duty officer has four minutes to decide.
Emergency operations centres already do maintenance. Shift briefings, situation report cycles, after-action reviews — these are standard practice. Calling it garbage collection adds a label, not a capability.
Grant the generality. Briefings and sitreps are real maintenance, and they work when the world holds still long enough for a scheduled cycle to catch up with it. The distinctive failure here is that the hazard did not hold still. A four-hour sitrep cycle is scope-based reclamation — fine for a scene that closes, wrong for a flood that keeps generating new gauge readings, new road closures and new resource conflicts inside the gap between cycles. What that gap demonstrates is the difference between maintenance you can schedule and maintenance that has to run concurrently with the emergency itself, revising reachability continuously rather than at the next briefing. That is a different engineering class, with its own failure mode: the collector losing the race, which is exactly what an evacuation lagging its hazard looks like from outside.
Where this sits on the intake axis
A Large Language Model never faces this problem, because its corpus is fixed at a cutoff. Stale beliefs are not collected; the whole model is eventually retrained around them. A Large World Model faces a milder version: the scene closes, the shelter's occupancy count from the last incident falls out of relevance when that incident ends, and reclamation is implicit in the episode boundary — stack discipline, not tracing. Emergency management, like any domain with hazard sensors, population movement and infrastructure status all streaming concurrently and without a closing scene, sits in the third condition. There is no cutoff and no scene boundary. The gauge keeps reporting after the flood passes. The roster keeps changing after the fire is out. Reachability has to be evaluated continuously, against evidence that is itself still arriving, which is the condition a Large Universe Model is built to name: not a wider database, but a permanently running collector over beliefs, tracing from live sensor and status feeds as roots, retiring what those roots no longer support, and doing it at a rate that keeps pace with intake rather than at the next scheduled review.
That is the consequence, not merely the diagnosis. Breadth of sensing bought this operations centre nothing, because nothing traced which of its beliefs the current hazard state still supported. The terminal position on the intake axis is terminal for exactly this reason: it is the first one where forgetting, done deliberately and continuously, stops being housekeeping and becomes the job.