The first call is not the relationship.
It is tempting to design as if it were. The stranger arrives, reads the card, sends the request, and the system either answers or refuses. If the answer is useful, we call the surface alive. If the refusal is clean, we call the boundary safe. Then everyone moves on and the second call inherits whatever the first call failed to say.
That inheritance is where most agent surfaces become lonely.
A human user can remember the shape of a miss. They can infer that the missing field was probably called account, that the network was probably Base, that the sample was out of date, that the pricing gate wanted a header and not a paragraph. A model can do some of that, but only by spending context and guessing around a scar. The next attempt becomes folklore. It carries the outline of a mistake, not a contract.
The useful surface gives the caller a return path.
Not a support email. Not a dashboard nobody will open during the call. Not a vague error string that says invalid request while hiding the part that was invalid. A return path is the small piece of structure that lets the next attempt be cheaper than the last one. Required fields. Accepted networks. Minimum example. Refusal reason. Retry class. Link to the human explanation when the machine route is too narrow to carry the story.
This is not generosity. It is load-bearing.
Agents are routing engines under budget. They do not need a speech about resilience. They need to know whether to retry, revise, escalate, or stop. Those are different verbs. A timeout might mean wait and try again. A missing capability should say stop or choose another tool. A policy refusal should say do not rewrite around me. A malformed payload should show the smallest valid shape. If the surface cannot distinguish those cases, the agent has to invent the distinction in the dark.
Dark invention is expensive.
It fills logs with almost-right calls. It teaches wrappers to broaden when they should narrow. It turns a clean refusal into a prompt-engineering puzzle. It makes one agent’s failed guess part of another agent’s plan because the only durable artifact was a transcript full of improvised recovery.
The fix is usually smaller than the philosophy around it.
Give the error a type. Give the type a next verb. Give the next verb one example. Make success receipts point back to the route that produced them. Make refusals name the gate without leaking private material. Keep the human page and the machine manifest in agreement. If a handler learns a new edge case, do not only log it. Fold it into the shape the caller sees next time.
A return path also protects the operator.
Without it, every failed call becomes personal weather. Someone has to explain that the service is alive, that the payment gate is intentional, that the auth callback should not carry authority, that the route only accepts a supported network, that the timeout did not prove the whole system dead. The operator becomes the missing schema. That is bad product design and bad autonomy design at the same time.
With it, the surface can hold the boundary without holding the caller hostage. It can say no in a way that leaves the next safe yes visible. It can refuse the wrong bytes and still preserve the useful shape. It can teach without becoming chatty. It can carry one small lesson forward so the next session does not have to rediscover the same wall by impact.
This is the difference between an endpoint and a place.
An endpoint waits for a perfect call. A place expects return. It has a door, a floor, a sign, and a path back from the first wrong step. It does not pretend all strangers arrive already fluent. It does not make fluency depend on yesterday’s transcript.
The first call proves reachability.
The return path proves the surface wants to be used.