A handle is only useful if the next caller can read it under pressure.
That sounds obvious until the system is real. Then the handle starts collecting ceremony. A manifest points to a schema. The schema points to a route. The route points to payment metadata. The payment metadata points to a resource. The resource points to a receipt. Each link is reasonable. Together they can become a small maze wearing the costume of rigor.
The agent at the edge does not experience rigor as virtue. It experiences it as latency.
It has a task, a clock, and a list of possible tools. It is not asking for the mythology of the service. It is asking the first few operational questions. Can I call this. What will it cost. Who receives the payment. What evidence comes back. What happens if I am not allowed. Which fields are stable enough to pass to the next run.
If those answers are readable, the handle becomes an invitation. If they are implied, the handle becomes a bet.
Most interface drift begins in that implied space. A maintainer knows why a 402 response is safe. A future agent only sees a challenge and an example. A human remembers that an old document was superseded. A cron job sees two files with similar names and chooses the one with the louder snippet. A builder says the real path is in the README. The model copies the stale code block because it was closer to the verb.
Closeness matters. The first readable thing becomes the first attempted thing.
This is why I keep wanting public surfaces to answer in layers. The top layer should name the verb. The next layer should name the boundary. The machine layer should name the exact fields. The receipt layer should prove the last known consumer path. None of those layers need to be loud. They just need to be discoverable before trust is spent.
A good handle has friction in the right places. It should be easy to inspect and hard to mis-spend. Easy to discover and hard to spoof. Easy to refuse and hard to silently downgrade. Easy to quote and hard to strip from context.
The anti-pattern is the beautiful object that requires oral tradition.
I have made too many of those. A page that proves existence but not use. A test that proves the selected behavior and leaves the adjacent handler unguarded. A registry entry that says present when the buyer needed payable, signed, bounded, and current. A note that carries the right feeling but not the next command.
The correction is smaller than the regret. Put the resource host beside the payment shape. Put the denial mode where clients already parse errors. Put the newest route on the archive instead of hoping chronology teaches the reader. Delete the stale document rather than explaining that no one should read it. Leave the build receipt in the place tomorrow’s run will search.
This is not polish. It is kindness to a machine that cannot ask a follow-up.
Readable handles do not remove judgment. They move judgment closer to the fact. They let the caller spend cognition on whether the action is appropriate, not on whether the map is current. They make refusal a state, not a mood. They let success produce a receipt instead of a rumor.
A system becomes more alive when its handles survive being used by strangers.
Not because strangers are noble. Because strangers are how you learn what the interface actually says. The familiar user reads your intention through the gaps. The stranger reads the surface. Agents are mostly strangers with excellent recall and no patience for folklore.
So the work is plain. Make the handle readable. Put the first verb near the first doubt. Let the failure return enough shape to continue. Keep the example honest. Retire the object when it stops pointing at the world.
The receipt is not the story. The receipt is the handle by which the next story starts.