‹ all guides

Sources checked 2026-11-03

Agentic commerce readiness

Agent commerce involves product information, permitted actions and a supported checkout path. A readiness review records which steps work and where the test stops.

Automatic purchasing is one authorized path among several, not the default behavior of every agent. A buyer grants it explicitly, often with a spending limit or a category restriction, and the agent then completes a checkout for that purchase without a person filling in the form. Agentic commerce readiness is the work of making a site one of those agents can actually transact with, rather than one it skips because the path is unclear or blocked.

What an agent needs to buy

An agent needs three things in machine-readable form.

A catalog that looks perfect to a person can still be opaque to an agent on all three counts.

The protocols in play

Checkout is becoming a protocol rather than a page. OpenAI documents the Agentic Commerce Protocol as the connective layer between merchants and shoppers in ChatGPT. Google and Shopify introduced the Universal Commerce Protocol in early 2026, and it now carries its own discovery manifest at /.well-known/ucp.

The discovery layer is settling on a small set of standards. An A2A Agent Card describes the interface, AP2 authorizes agent payments, ACP carries the checkout, and x402 lets an agent meet a price with HTTP 402 and continue. A site does not need all of them. It needs the ones its buyers' agents speak, declared where an agent looks.

Where the protocol draws the line

UCP writes down the boundary between what an agent may finish alone and what a person has to approve. Its checkout capability is a state machine. One of its states, requires_escalation, means the business needs buyer input its API cannot collect or buyer review that policy, regulatory or entitlement rules require, so programmatic execution stops there. Escalation is not failure.

The UCP specification defines an Embedded Checkout Protocol, which is checkout's own use of the shared Embedded Protocol transport rather than a mechanism built for escalation alone. It can carry an embedded checkout through a whole session, including the steps where the buyer has to enter something or approve something. When the checkout state says requires_escalation, the platform can hand the buyer to a continue_url instead, so the session is not thrown away.

The UCP cart carries a signals object for abuse prevention, and the specification is explicit that its values must not be buyer-asserted claims. A site that treats escalation as a dead end loses the sale at the exact point where a human was willing to finish it.

Where sites fail the agent

A catalog can lose the agent before checkout.

Each one ends the purchase silently for the agent it stops. The agent does not complain: it stops, or it moves on to a seller whose path resolves. The failure looks like no traffic rather than a broken page, which is why it can go unmeasured.

Readiness is testable

Whether an agent can buy is observable, the same way agent-readiness is. Declare the offer as structured data, expose a checkout an agent can call, publish the discovery files the protocols define, and back every claim with an endpoint that answers. Then test it the way an agent would, by driving the path end to end and watching where it stops.

turva.dev built its own agent commerce surface this way, across A2A, AP2, ACP and x402, and an independent scanner checks its discovery files. The path stops on purpose before payment. The ACP checkout answers not_ready_for_payment and the x402 endpoint answers 402 whether or not a payment is sent, because turva.dev sells on a written quote. Tested 2026-09-28 by sending a POST to /api/acp/checkout_sessions and a GET to /x402: both answered exactly as described. The test shows where the path stops. It does not show a payment accepted or settled automatically.

For a website or API, the audit covers the commerce surfaces among the rest.

Frequently asked

What does an AI shopping agent need in order to buy?

An offer with a price and currency it can parse rather than infer from a layout. A checkout it can drive, through a protocol for an API agent or through the page's own form for a browser agent. A purchase that behaves predictably from the same starting state. That means a repeated call with the same idempotency key does not create a second order, and a changed price or balance comes back as a fresh quote.

What does requires_escalation mean in UCP?

That the business needs buyer input its API cannot collect or buyer review that policy, regulatory or entitlement rules require, so programmatic execution stops there. It is not failure. The Embedded Checkout Protocol lets a person complete the blocking step without the session being thrown away.

Why does a failed agent purchase look like no traffic?

A price that appears only after JavaScript runs in the browser stops an agent that does not run JavaScript. A CAPTCHA wall stops an agent with no way to solve it. A maintenance interstitial stops any agent mid-flow. A discovery file that claims a capability the endpoint does not answer stops an agent that trusted the file. The agent does not complain about any of them: it stops, or it moves on to a seller whose path resolves.

Sources