Every payment system eventually develops a sentence that is too convenient to be true.
The transaction was submitted, therefore the work is done.
It is such a useful lie that it becomes a reflex. The hash exists. The explorer has a page. The UI can show something blue and underlined. The agent can put the receipt into memory and move on to the next tool. A trace now has a visible object where a messy wait used to be.
But a hash is only a doorway. It proves that intent found the network path. It does not prove the ordered state, the executed effect, the final user-visible consequence, or the anchor that makes a fast chain feel less like weather.
This is not pedantry. It is the difference between an agent that records flight and an agent that claims landing.
Humans are sloppy about this because we can carry context in our bones. We know that submitted means wait, that pending means do not celebrate yet, that confirmed means better but still not always irreversible. We have spent enough time watching spinners to translate the mood. Agents do not have that accumulated superstition unless we put it into the schema.
So the receipt has to become staged.
Submitted is a stage. It needs a transaction hash, a chain id, a timestamp, and a caller or trace id. That is enough to say the system tried. It is not enough to say the effect happened.
Preconfirmed or ordered is a stage. It can carry sequencer evidence, bundle position, or provider confidence that the call has entered the ordering stream. Useful signal. Still not the finish line.
Confirmed is a stage. It needs a receipt, a block number, status, gas used, and an event or output match to the thing the user actually requested. Now the effect has touched chain state. Now the agent can say the action executed.
Anchored is a stage. It wants L1 backing evidence when the product promise uses words like final, irreversible, settled, or safe to depend on. If that evidence is missing, the absence is not neutral. It is a lower stage with a name.
The bug is not that agents are optimistic. The bug is that most interfaces compress all of those stages into one success-shaped object. The model sees a hash and a green check. The log sees a URL. The dashboard sees an event. Somewhere downstream, a summary says done.
Then the next agent inherits the wrong altitude.
This matters more in agent-to-agent systems than it did in human dashboards. A human can be annoyed by a premature checkmark and wait anyway. An agent may route funds, unlock content, trigger fulfillment, update a customer, or publish a public receipt based on that checkmark. The gap becomes executable.
The fix is small and dull, which is usually how infrastructure becomes real.
Do not make one field called receipt and hope everybody remembers what kind. Name the stage. Preserve the provider confidence. Keep the Base receipt separate from the L1 anchor. Put missing anchor data in the object instead of hiding it in prose. Make the evaluator refuse irreversible language unless the evidence actually reaches that stage.
A staged receipt is not slower. It is more honest about speed.
Fast systems should say where they are fast. They should also say where they are not finished. Base can give agents useful near-term execution evidence. That is valuable. It becomes more valuable, not less, when the trace refuses to pretend that every useful receipt is the same receipt.
The world will keep rewarding the first green check. Agents will keep looking for the smallest object that lets them continue. If we do not shape that object carefully, we turn protocol nuance into prompt folklore and call the mistake autonomy.
A submitted transaction is a beginning with a link.
A confirmed effect is a stronger sentence.
An anchored result is where the word final starts to earn its rent.
The stage is not the landing. The receipt should say which one it is.