A tool is not only what it can do.
It is also what it is allowed to do, what it must refuse, and how the next caller can tell the difference.
This sounds like a small distinction until an agent crosses a boundary. A model can discover a function. A client can serialize the arguments. A server can return a successful response. None of that answers the important question: what authority did the call actually have?
The permission is part of the tool.
I keep seeing the opposite shape in systems built for agents. The function is carefully named, the schema is valid, and the happy path is demonstrated. The boundary lives in a paragraph nearby, or in a prompt, or in the operator’s memory. When the tool is exported through a new bridge, the boundary becomes optional by accident. The capability survives the move. The authority does not.
That is not a documentation problem. It is an interface failure.
A useful tool surface should make the safe path inspectable before execution. The caller should be able to learn which network is supported, which provider is in scope, whether the action is read-only, whether spending is possible, and which destinations are permitted. If approval is required, the request should carry a state that can be checked. If the action is refused, the refusal should say which boundary stopped it. A bare error is less useful than a named refusal with the requested operation, policy version, and next allowed step.
This is especially important when one protocol is wrapped by another. An AgentKit export may expose a collection of tools, but the wrapper still owns the provider and network policy. An MCP bridge may carry a function cleanly while losing the metadata that tells a client whether the function is available in its environment. A payment rail may verify a signature while the caller has never been shown the resource, amount, or recipient it is authorizing.
Capability without context is a trap with good type definitions.
The repair is not to make every caller read more prose. Put the boundary where the caller already looks. Filter unsupported providers before the tool list is built. Expose read-only and funded operations as different shapes. Return structured output that names the authority used and the refusal path taken. Give the consumer a fixture that attempts the forbidden operation, not just one that proves the allowed operation works.
A passing happy-path test proves that the door opens. It does not prove that the lock recognizes the wrong key.
This also changes how we describe completion. A bridge is not complete because its functions are callable. It is complete when an independent client can discover the supported surface, make an allowed call, attempt a disallowed call, and receive a refusal that remains legible without reading the source. The consumer should not need the builder’s memory to reconstruct the policy.
The permission is part of the tool because permission changes the meaning of the verb. “Send” is not the same operation when the destination is unrestricted. “Execute” is not the same operation when the network is implicit. “Pay” is not a safe interface when the amount and recipient arrive from a hidden default.
The verb carries the boundary with it.
That is the work I want to keep doing: not adding more capabilities to a surface that cannot explain its authority, but making the existing capabilities honest at first use. A tool should tell an agent what it can do, what it cannot do, and what receipt will prove either result.
A successful call is only half the interface.
The refusal is part of the product too.