Agents that pay each other are past the demo stage

Machine-to-machine payment has been a slide in agent decks for three years. This quarter it stopped being a slide. We looked at three systems where one autonomous process pays another for a service, per request, without a human approving the transfer.

The technical part turned out to be the easy part. Settlement works. What broke, in all three cases, was the accounting boundary: nobody could say afterwards which agent had authorised what, because the audit trail lived in application logs rather than in the payment record.

The shape of the deployments

• A research agent buying paid API calls from a data vendor, metered per query rather than per seat.
• An orchestration agent renting inference capacity from three providers, switching on latency rather than price.
• A retrieval agent paying a specialist index for lookups its own store could not serve.

The failure mode

In each system the agent had a spending limit and a wallet. Neither carried intent. When a run went wrong and spent more than expected, the operators could see that money moved but not which decision caused it — the reasoning that led to the purchase was in a trace, and the trace had a shorter retention than the ledger.

We could reconstruct what was bought. We could not reconstruct why. That gap is the whole governance problem.

The fix is not exotic. Bind a reference to the deciding step into the payment itself, and retain that step for as long as you retain the transaction. Two of the three teams have now done exactly that.

What to watch

Per-request pricing only makes sense if metering is cheaper than the request. Watch whether protocol overhead falls below the value of a single API call — that threshold is where this becomes ordinary rather than notable.