Agents Can Talk, But They Can't Commit<br>Here is a design question that keeps surfacing as teams move agents into real workflows. You have microservices coordinated by a saga. Push it one step further: what if the services were AI agents, and the API between them was disposable: generated on demand, shaped to the task, never written down as a permanent contract? Agents negotiating their own interface, executing the work, unwinding it if something fails. Is there a standard for that yet?

The short answer is no. The longer answer is the interesting one, because the entire agent protocol stack standardizes speech and none of it standardizes commitment . Once you see that, the architecture that fixes it is forced.

Why This Matters

Take a concrete case: an agent that onboards a new supplier. Six steps: create the vendor record, reserve a budget line, provision a sandbox tenant, run a compliance check against an external registry, capture a setup fee, email the supplier their credentials.

Step four fails. The external registry times out after the agent has already retried it three times.

Now answer these questions about your system, today:

Which of the first three steps actually took effect, and which are safe to leave in place?

The budget reservation has a hold on it. Does anyone release it, or does it sit there until a quarterly reconciliation finds it?

The agent retried step four three times. Did the registry create three records, or one?

If the agent had made it to step five, the fee is captured. There is no undo for that. Did anything in the plan know that before it started?

None of these are model-quality problems. They are all the same problem: the protocol carried the request and the response, and nothing carried the commitment. The failure mode is not a wrong answer. It’s a system that ends up in a state nobody designed, that no log can reconstruct, and that a human discovers weeks later during a reconciliation.

This gets worse, not better, as agents improve. A more capable agent attempts longer chains with more side effects before it stops.

What the Stack Standardizes Today

By mid-2026 the layering has settled, and it’s narrower than the press releases suggest.

MCP governs the vertical: how one agent reaches tools, data, and services. Anthropic donated it to the Linux Foundation in December 2025 as the founding project of the Agentic AI Foundation.

A2A governs the horizontal: how agents discover and delegate to each other. Google handed it to the Linux Foundation in June 2025, IBM’s competing ACP merged into it in August 2025, and v1.0 landed in April 2026 with multi-transport support, multi-tenancy, and modernized security flows.

AP2 governs money: a chain of signed mandates (intent, cart, payment) carrying a user’s authorization through a purchase they aren’t present for.

AGNTCY , out of Cisco, fills in identity, messaging, and observability around all of it.

That is a genuinely impressive amount of standardization in two years. It is also, without exception, standardization of speech : discovery, addressing, framing, streaming, authentication, delegation. How agents find each other and what a well-formed utterance looks like.

The closest thing in the entire stack to transactional semantics is the A2A task lifecycle: submitted, working, input-required, completed, failed, canceled. It isn’t close at all. canceled is not compensated. Cancelling a task means you stopped it. It says nothing about the four side effects it already produced. There is no compensating action in the spec, no pivot transaction, no saga context that propagates across a delegation chain, and no way for an agent to advertise “this operation of mine can be undone, and here is how.”

This is not a niche complaint. A mid-2026 gap analysis of MCP, A2A, ACP, ANP, and ERC-8004 reaches the same structural conclusion from the governance angle: the missing capabilities are not features inside these protocols, they are a missing architectural layer above them . The transaction layer is the same shape of gap.

The “Obvious” Solution

The obvious answer to that question is that the disposable API is the hard part, and the industry has already solved it. That’s half right, and the half that’s right is worth understanding, because it’s genuinely good engineering.

The pattern is code mode , and several organizations arrived at it independently. The problem it solves is context economics. In the naive design, every tool an agent might use is loaded into context as a JSON schema before it reads the request. Anthropic reported a Google Drive to Salesforce workflow dropping from roughly 150,000 tokens to 2,000, a 98.7% cut, once tools were exposed as discoverable code rather than preloaded definitions. Cloudflare had a harder version of the same problem: over 2,500 API endpoints, which would exceed a million tokens as native tool definitions, collapsed to roughly 1,000 tokens behind two tools, search and execute, backed by a...