# Agentic Commerce & Agent Payments

> Agentic commerce is the part of the agentic web where an AI agent buys, sells, or pays on a user's
> behalf — settled over machine-native payment rails (x402, AP2, ACP, UCP, MPP, Kite, Visa TAP) and
> completed through agent checkout flows like ChatGPT Instant Checkout. This pillar explains and links;
> the full settlement spec for each rail lives at /protocols/payments/<id>. last_verified: 2026-06-15.
> · markdown twin of /commerce.

## Agentic commerce, defined: how value moves on the agentic web

Agentic commerce is the part of the agentic web where an AI agent buys, sells, or pays on a user's
behalf — discovering a price, getting authorized to spend, settling over a machine-native payment
rail, and returning a receipt — without a human filling in a checkout form. e-commerce serves a human
at a browser; conversational commerce serves a human in a chat; agentic commerce serves an agent
acting for a human, which is why it needs new rails and a measurable Agent Success Rate.

## Agent payment flow: discovery, authorization, settlement, receipt

Every agent payment follows four steps:

1. **Discovery** — the agent finds the price and the accepted rail (e.g. an HTTP 402 Payment Required response carrying x402 terms, or a structured product feed).
2. **Authorization** — a payment mandate cryptographically scopes the spend (amount, merchant, expiry). This is AP2's contribution, over A2A + MCP.
3. **Settlement** — the rail moves value per its settlement_type: stablecoin/on-chain for x402, a card rail for ACP and Visa TAP.
4. **Receipt** — a verifiable record (transaction hash or signed receipt) closes the loop for audit and dispute.

## Payment rails move money between agents on the agentic web

Every rail here is specified in the Payments & Settlement layer of the Protocol Atlas (/protocols/payments).

- **x402** (`/protocols/payments/x402`) — settles HTTP-native payments at the 402 status code; stablecoin/on-chain. (Verify against x402.org / Coinbase at build; any tx-count figure must cite a primary source — not asserted here.)
- **AP2** (`/protocols/payments/ap2`) — adds payment mandates over A2A + MCP; extends x402. (Verify against the AP2 spec at build.)
- **ACP** (`/protocols/payments/acp`) — OpenAI + Stripe's Agentic Commerce Protocol; reported live in ChatGPT Instant Checkout; card rail. (Verify against the primary OpenAI/Stripe source at build.)
- **UCP, MPP, Kite, Visa TAP** — the rest of the landscape; emerging; owner/date/maturity verify against primary at build.

## Rail comparison: which agent payment rail to accept when

Choose by settlement type and use case: x402 for HTTP-native/stablecoin micropayments; ACP (via ChatGPT
Instant Checkout) for in-chat retail on a card rail; layer AP2 mandates for scoped authorization; treat
UCP/MPP/Kite/Visa-TAP as emerging.

| Rail | Settlement type | Spec | Maturity | Ideal use case | When NOT to use |
|---|---|---|---|---|---|
| x402 | Stablecoin / on-chain | /protocols/payments/x402 | Live (reported) — verify against primary at build | HTTP-native, per-request or stablecoin micropayments | Retail card purchases; refunds and chargebacks expected |
| AP2 (Agent Payments Protocol) | Mandate layer (rail-agnostic) | /protocols/payments/ap2 | Emerging (reported) — verify against primary at build | Proving an agent's spend is scoped and authorized | As a settlement rail on its own — it scopes, it does not settle |
| Agentic Commerce Protocol (ACP) | Card rail | /protocols/payments/acp | Live in ChatGPT Instant Checkout (reported) — verify against primary at build | In-chat retail checkout for physical / retail goods | Per-request machine micropayments below card-economics |
| UCP | Verify against primary at build | /protocols/payments/ucp | Emerging — verify against primary at build | A broader commerce/checkout interoperability layer (verify scope) | Treat as a watch item until its primary spec is confirmed |
| MPP | Verify against primary at build | /protocols/payments/mpp | Emerging — verify against primary at build | Machine / merchant payment plumbing (Stripe + Tempo, per research — verify) | Treat as a watch item until its primary spec is confirmed |
| Kite | Verify against primary at build | /protocols/payments/kite | Emerging — verify against primary at build | An agent-payment network (verify owner and settlement model) | Treat as a watch item until its primary spec is confirmed |
| Visa TAP (Trusted Agent Protocol) | Card network | /protocols/payments/visa-tap | Emerging — verify against primary at build | A card-network agent rail for trusted-agent purchases (verify) | Treat as a watch item until its primary spec is confirmed |

## Agent checkout flows complete the purchase on the agentic web

ChatGPT Instant Checkout, built on ACP, lets a user buy from a participating merchant without leaving
the chat (verify against the primary OpenAI source at build). The metric that grades the flow is the
**Agent Success Rate (ASR)**: the share of agent-attempted checkouts that complete. A low ASR signals a
store visible to agents but not transactable by them. To raise it, see /agent-readiness/commerce.

## Agentic commerce maturity signals which rails are production-ready

Reported production-ready rails include x402 and ACP; AP2 is rolling out; UCP/MPP/Kite/Visa-TAP are
emerging. Every maturity/launch/adoption claim must be filled from its primary source at build, never
from an internal doc. Adoption over time: /state-of-the-agentic-web.

## Agent payment demo: a SIMULATED x402 checkout on this site

This site ships a **SIMULATED** x402 checkout — a real 402 Payment Required handshake with mocked
settlement. It is a DEMO and moves no real money: no funds are transferred, no wallet is charged.

```
HTTP/1.1 402 Payment Required
Accept-Payment: x402
X-Payment-Terms: {"rail":"x402","amount":"0.01","currency":"USDC","demo":true}
# -> agent retries with X-Payment: {"signature":"0xSIMULATED","demo":true}
HTTP/1.1 200 OK { "receipt":"demo-tx-SIMULATED", "settled":false, "note":"DEMO — moves no real money" }
```

## Agent payments start with a rail and end with a commerce-ready store

You now understand what agentic commerce is, how an agent pays, and which rail to accept — but does
your own store let an agent discover a price, authorize, and check out, and can you prove it? Each rail
maps to one concrete change in your store, and the commerce dimension of the Agent-Readiness Audit
checks whether you made it: /agent-readiness/commerce (engineer) -> /services (audit, certify, list).