The problem underneath every copy
A cache is a fast copy of something slow to fetch. That is the whole idea, and it is almost too simple to be worth stating. The interesting part is not making the copy. Any system can do that: read the value once, keep it somewhere quick to reach, hand it out on request. The interesting part is knowing when the copy has stopped being true.
This is a currency problem, not a storage problem. Storage is solved the moment you allocate the memory. Currency is never solved, only managed, because the source keeps changing after the copy is taken and the copy has no way of knowing that on its own. Two disciplines exist to manage it. The first is expiry: attach a lifetime to the copy and throw it away when the clock runs out, whether or not anything actually changed. The second is invalidation: have the source tell every holder of a copy, at the moment of change, that the copy is now wrong. Expiry is cheap and imprecise — it discards good copies along with bad ones, on a schedule that has nothing to do with when the underlying value actually moved. Invalidation is precise and expensive — it requires the source to know, at all times, who is holding a copy, and to reach them.
Phil Karlton's joke that there are only two hard problems in computer science, naming things and cache invalidation, is funny because it understates by omission: it does not even mention the third hard problem, off-by-one errors, and everyone laughs anyway because the first two are the ones that actually cost money. The joke encodes a real asymmetry. Writing a value into a cache is a local, one-line act. Retracting it — finding every place that value went, and correcting each one before it is acted on — is a coordination problem that scales with the number of holders and the speed at which they act on stale information.
Where the discipline came from
Caching as an engineering concept enters computing with Maurice Wilkes's 1965 paper on slave memories, implemented three years later in the IBM System/360 Model 85, which sat a small fast store in front of a slow main store and made the whole thing look, to software, like one memory that happened to run quick. The idea worked immediately. The trouble started as soon as more than one processor held a copy of the same line, because now two fast stores could each believe they held the current value while disagreeing with each other. That coordination problem produced, through the 1980s, the MESI family of cache-coherence protocols — Modified, Exclusive, Shared, Invalid — which is really just a labelled state machine for answering one question continuously: is this copy still good, and who needs to know if it isn't. Karlton's remark comes later, out of Netscape in the 1990s, but it names a problem that was already twenty-five years old and reappearing everywhere copies were held remotely from their source: DNS records with a time-to-live, HTTP responses with conditional-request headers, database materialised views that lag their base tables. The invariant is constant across all of them. Filling a cache is a local act. Invalidating one is a coordination problem, and the difficulty scales with how many copies exist and how far they are from the source.
The turn
Put a training cutoff next to a cache-control header and the resemblance stops looking like a metaphor.
A Large Language Model is trained once, on a corpus fixed at some date, and its weights are a compressed copy of what that corpus said. After training, nothing links the weights back to the sources they were compressed from. There is no notification channel — no purge call, no advisory feed, nothing analogous to a source telling a cache that a line just changed. So the model behaves exactly like a cache with an expiry set to infinity: it does not become invalid, in the sense the system itself can detect, because it was never given a mechanism for detecting invalidity in the first place. Staleness accumulates silently, in exact proportion to how much of the world has moved since the cutoff, and the model has no internal signal marking which of its beliefs are the ones that moved.
The Large World Model narrows this in one specific way. By reading a live sensor stream — a camera, a scene, a present moment — it gets invalidation for free within that scene, because the next frame simply overwrites the last. Perception is its own invalidation mechanism: you cannot hold a stale belief about what is directly in front of you, because the sensor keeps refreshing it. But this only covers what is currently in view. Everything outside the frame is not being refreshed and not being marked stale either. It is simply absent. A world model that has walked out of a room holds nothing about that room any more — not a stale belief, just no belief. Coverage, not currency, is what it is missing, but the missing coverage matters because most of what anyone needs to reason about is not in front of them right now.
The Large Universe Model is the position where invalidation stops being an accident of the sensing setup and becomes the organising obligation. It requires two things a corpus and a scene do not: streams kept open rather than sampled once, and beliefs annotated with the observations they rest on — provenance, in the operational sense, meaning an edge from a belief to whatever upstream fact it depends on. When a stream reports something that contradicts a held belief, the system can walk backward along that edge, find everything that depended on the old value, and revise it. That is a dependency graph over knowledge, doing for beliefs what MESI does for cache lines: tracking who holds what, so that a change at the source can be propagated rather than discovered by accident later.
The claim, stated exactly
Any system that holds knowledge about a world that keeps changing is holding a cache, whether or not anyone built it as one. Caches have exactly two disciplines available to them: expire on a timer, or be told. A training cutoff is the first discipline with the timer set to infinity, which is really no discipline at all — staleness grows without bound and without any internal signal that it is growing. Scene-bound perception adds the second discipline, but only for the narrow slice of the world currently being sensed. The remaining move — open streams, provenance on every belief, propagation of contradiction along the provenance graph — is not an improvement in degree. It is the only discipline left once you have already committed to being told rather than timing out. There is no third option to discover later. That is the sense in which this rung is terminal on the intake axis: not that nothing better than a Large Universe Model can be built, but that "notified by everything, always, with a record of what depended on what" exhausts the space of invalidation strategies. Beyond it lies only doing the same thing faster and trusting the result more.
The misreading to disown
The common misreading says the fix for a stale model is a fresher one: retrain monthly instead of yearly, and the problem shrinks. It does shrink, in exactly the way a shorter time-to-live shrinks staleness on a CDN edge node — as a matter of degree, not of kind. A model retrained monthly still cannot say, of any single belief it holds, whether that belief was superseded three weeks ago, or what upstream fact it would need to check to find out. Retraining is wholesale replacement. It has no targeted revision, because targeted revision requires provenance, and provenance is precisely the thing retraining does not add. Shortening the expiry window is real engineering and worth doing. It is not the same move as building an invalidation channel, and mistaking one for the other is the error this page exists to correct.
Three objections, taken seriously
Universal-scope invalidation is computationally hopeless. Tracking dependents for billions of continuously updating beliefs would consume more capacity than it saves.
This is a real constraint on architecture, not a refutation of the category. Retrieval-augmented fetching — don't cache, ask the source directly — looks like an escape, but it is itself a caching discipline: read-through with zero retention, paid for in latency and in silence about anything the query did not think to ask. Real systems, like real CPUs and real CDNs, will be hybrids — hot beliefs invalidated eagerly, cold ones lazily, most left on a timer — and that hybridity is a genuine narrowing of the claim: universal intake does not mean uniform intake.
Most of what a model knows is invariant — arithmetic, grammar, plot structure — and calling that a stale cache mistakes a small volatile fringe for the substance.
Correct, and worth conceding without qualification: intake generations differ least on invariants. But the volatile fringe is exactly where consequential decisions sit — prices, doses, jurisdictions, who currently holds an office — and the deeper cost of missing invalidation is not that some facts rot. It is that a system without provenance cannot tell you which of its outputs are invariant and which are dated. It says both in the same voice.
Provenance is not truth. Knowing where a belief came from says nothing about whether the source was right, and correlated or spoofed sources can make a well-provenanced system confidently wrong.
This is the strongest objection on the page, and it is granted in full. Provenance is a precondition for correction, not a guarantee of correctness. What it changes is diagnosability: an unprovenanced wrong belief is wrong forever, because nothing records what it rested on; a provenanced wrong belief can be traced, audited, and corrected once the bad source is found. That leaves the hard problem — corroboration, spoofing, correlated failure — as a live engineering fight, the one certificate transparency and clinical adjudication are already fighting, rather than an invisible one baked into the architecture.
What this does and does not establish
It establishes that intake generations differ along a real and previously named axis, and that the axis has a top: expiry, then partial invalidation, then provenance-tracked invalidation, and nothing structurally beyond that. It does not establish that building the third position is easy, cheap, or safe from being wrong at scale. It does not establish that a Large Universe Model, as a working system, exists. It is an argued category, reached by taking a fifty-year-old discipline from systems engineering and asking where it runs out of road. What it settles is narrower than it sounds: not that the ladder ends in a good place, only that it ends.