Agentic commerce, explained
Agentic commerce 101
What it is, who is building it, what is actually live, how the companies make money, and what still is not solved. I spent too much time trying to understand this mess. This is the version I wish existed.
Last verified: Aug 24, 2026
The 30-second version
Agentic commerce is software spending money on someone's behalf. A person or company sets the goal and the budget; an agent does the buying. In the last eighteen months, nearly every major payments company shipped something for it: ways to give an agent bounded spending authority, ways for machines to request and execute payment over HTTP, networks for the money to settle on, and standards for merchants to tell legitimate agents from bots.
Two things are true at once. The infrastructure is real and moving fast. And the clearest machine-native activity today is developers' agents buying API access for cents, while much consumer commerce is still human-approved. Knowing which claim is which is most of understanding this space.
One distinction carries most of this page: atomic purchases, like an API call, prove themselves on delivery. Result-shaped work, like research, code, or completed tasks, does not. The outcome layer exists for the second kind.
The stack, as four questions
Every product answers one of four questions. Only the last one is unstandardized.
Every product below answers one of four questions about a transaction:
A useful trust decomposition runs through the same stack: authority trust (was the agent allowed), selection trust (did it buy the right thing), settlement trust (did the money move), and outcome trust (did the purchase produce what was agreed). The first and third are getting solved. The second is being attempted. The fourth remains fragmented and much less standardized.
What is real today
Bounded spend authority and machine-payable APIs are live. Autonomous consumer commerce is not.
Proven, live, usable now:
- Agents can receive bounded spending authority: session envelopes, scoped cards, onchain spend permissions, wallet policies.
- Agents can use card and stablecoin payment mechanisms without ever holding raw credentials.
- Machine-payable APIs are live; an agent can hit a paid endpoint, get told the price, pay, and retry, with no account.
- The major networks are building agent identity and checkout infrastructure in the open.
Much less proven:
- Autonomous consumer shopping at scale. The most-distributed attempt, ChatGPT's Instant Checkout, was shelved within months.
- Agent-to-agent commerce at scale. The standards are weeks to months old.
- Portable outcome verification. No major incumbent payment protocol provides a general, portable answer to whether purchased work was correct.
- The economics. Almost every protocol is free; monetization is deferred to a land-grab later.
How to read activity claims
Protocol activity is not automatically autonomous agent commerce.
Before absorbing anyone's numbers, including the ones below, know that activity claims in this space come in five different kinds, and they are not interchangeable:
- Agent-originated purchases: an agent bought something with no human in that transaction's loop. Very little public evidence of this exists at scale.
- Human-approved, agent-assisted: a person confirmed a purchase an agent surface set up. This is what ChatGPT and Google checkout volume is.
- Developer API traffic: developers' agents buying API access. Real, machine-native, cents-sized.
- Protocol transaction counts: onchain or protocol tallies of unknown composition. x402's headline numbers are this, and Chainalysis documented that a speculative token-minting wave drove much of the growth.
- Merchant integrations and partner counts: who signed up. Says nothing about usage.
Protocol activity is evidence that machine-payment infrastructure is used. It is not automatically evidence that autonomous agents are making result-shaped purchases. Keeping that straight is most of the skill, and the rest of this page uses these categories explicitly.
Who does what
Sixteen players across four layers. No row reaches verified autonomous retail scale.
| Player | Layer | Status | Strongest real evidence |
|---|---|---|---|
| AWS AgentCore Payments | Authority | GA (Aug 2026) | Named launch partners; no volume yet |
| Ramp Agent Cards | Authority | Preview | None public |
| Stripe Link for agents | Authority | Live | Named agent clients; per-purchase approval |
| Privy | Wallets | Live | Big wallet volume, none of it agent-specific |
| Coinbase spend permissions | Authority | Live | Protocol counts, secondary sources only |
| x402 | Payment protocol | Live | Real developer API payments, cents-sized |
| MPP | Payment protocol | Live | Production merchants; no volume published |
| AP2 | Authorization | Live spec | 60+ partners; no usage data |
| ACP | Checkout protocol | Live (beta spec) | Human-approved ChatGPT purchases |
| TAP | Agent identity | Preview | Processor working group |
| Tempo | Settlement | Live mainnet | Mainnet + validators; permissioned set |
| Visa VIC / ICC | Card network | Pilot | Hundreds of closed-beta transactions |
| Mastercard Agent Pay / AP4M | Card network | Live / announced | Live issuer rollout, several countries |
| UCP | Commerce | Live (US) | Purchases inside Google surfaces; no volume |
| A2A | Interop | Live v1.0 | 150+ member orgs; usage by sector only |
| OpenAI Instant Checkout | Commerce | Mothballed | Under 30 merchants before the pivot |
No row reaches verified autonomous retail commerce at scale. The strongest genuinely machine-native activity is developer API traffic in cents-sized payments.
The products, one at a time
One sentence, the facts that matter, and the strongest reality caveat. Details one click away.
Each entry: the one-sentence version and the two or three facts that matter, with the deeper economics and limitations one click away.
Authority and wallets: who may spend, how much, with what
AWS AgentCore Payments GA
Give an agent a spending envelope. You connect a wallet (Coinbase or Stripe's Privy), set a max spend per session, and AWS enforces the limit at the infrastructure layer.
- An over-budget request is rejected no matter what the agent decides; orchestrates x402 and MPP.
- Went GA August 18, 2026 with named partners. No public volume; it is weeks old.
More details
- Funds via card or USDC; normal AWS observability (CloudWatch, dashboards).
- Does not judge whether what the agent bought was any good. Budgets, not outcomes.
- Economics: no agent-specific pricing published; assume normal usage-based service revenue.
- Launch partners: Anchor Browser, Travala, Heurist AI, BlockRun, Elsa AI.
Ramp Agent Cards Preview
A one-time corporate card for an agent. Fresh card number at purchase time, locked to one merchant, capped, dead after first use or 12 hours.
- Inherits the company's normal Ramp spend policies; plugs into agent runtimes over MCP.
- No public customers or volume for the agent lane yet.
More details
- No 3D Secure, card-on-file, or subscriptions; direct merchant checkout only; 13 blocked merchant categories.
- Economics: standard card interchange plus Ramp's platform. The agent card is a feature, not a new business model.
Stripe Link for agents Live
Let an agent spend your existing payment methods without ever seeing your card number, through a one-time credential scoped by amount, merchant, and expiry.
- Today every credential request needs your approval in the Link app. Delegated spending, not autonomous spending.
- Launch clients included Claude and OpenAI agents. No usage figures published.
More details
- Standing spending limits and no-approval modes are stated as planned, not shipped.
- Fiat cards and bank accounts today; stablecoins listed as future.
- Economics: normal Stripe processing on the resulting transactions.
Privy Live
Programmable rules around a wallet: amount limits, allowlists, network scoping, time windows. An API any app or agent platform can embed. A Stripe company since 2025.
- The wallet under other products, including one of the two options in AWS AgentCore Payments.
- Reports 160M+ accounts and $15B+ processed monthly. Those are aggregate wallet numbers, not agent activity.
More details
- Policy engine covers per-chain rules, time-bound signers, and cumulative-value windows.
- Named customers include Ramp, Deel, Hyperliquid, Klarna.
- Economics: developer-platform pricing, plus strategic value to Stripe's money-movement stack.
Coinbase CDP wallets and spend permissions Live
A crypto wallet an agent can use, where the owner signs a standing permission capping spend per token and per time window, enforced onchain and revocable.
- One of the more mature crypto-native approaches to "give an agent money safely," and the settlement wallet behind much x402 activity.
- Circulated adoption figures trace only to secondary sources, and they are protocol counts, not purchases of results.
More details
- Agentic Wallets keep keys in enclaves, never exposed to the agent or model; session caps, allowlists, activity logs.
- EVM-only, token-spend-only today; no fiat cards.
- Economics: platform usage plus Coinbase's Base sequencer and USDC ecosystem.
Payment protocols: how machines ask for and execute payment
x402 Live
A website or API can reply "this request costs money," and the agent can pay and retry automatically. A payment request inside HTTP itself, settled in stablecoins on Base.
- x402 has real usage. But the headline counts (160M cumulative per Coinbase; Chainalysis independently counts 100M+ on Base through Q1 2026) total only tens of millions of dollars, the average payment is about twenty cents, and Chainalysis documents that a speculative token-minting wave (one pay-to-mint token did 150k+ transactions in its first month) drove much of the growth. Counts here are not autonomous-agent commerce.
- What is genuinely real underneath: developers' agents paying per API call, no accounts or keys. That works today.
More details
- Governance moved to the Linux Foundation in 2026, backed by Circle, Google, Microsoft, Stripe, Visa; Stripe accepts x402 USDC on Base.
- The protocol is free; facilitators and sellers monetize around it.
- No refunds, disputes, identity, or any notion of whether the paid-for result was good.
MPP, the Machine Payments Protocol Live
A common language for machines to pay each other, from Tempo and Stripe: one-off charges, metered sessions, subscriptions, and receipts, over whichever rail both sides accept.
- The generalization of the x402 pattern: same HTTP 402 handshake, rail-agnostic, more billing shapes.
- Launched March 2026 with Tempo's mainnet; real merchants in production (Browserbase and others; Spoolis's own paid lane runs on it). No published transaction counts.
More details
- Rails: Tempo stablecoins by default, cards through Stripe, Visa and Lightspark extensions, Lightning, Solana, Stellar, EVM.
- Payment happens on the seller's terms; no conditional or escrowed release, no outcome semantics.
- Economics: protocol free; Stripe monetizes processing, Tempo chain activity.
AP2, the Agent Payments Protocol Live spec
A signed permission slip proving a real person authorized what their agent is buying: three signed mandates any payment network can verify.
- The accountability layer card networks want before honoring agent transactions at scale. It authorizes; it does not move money.
- From Google, donated to the FIDO Alliance, 60+ partners. Partner list, not usage data.
More details
- Intent, cart, and payment mandates as W3C Verifiable Credentials; v0.2.0 added human-not-present flows.
- Rail-agnostic, with a stablecoin extension built with Coinbase; mandate chain doubles as a dispute audit trail.
ACP, the Agentic Commerce Protocol Live
The standard that let ChatGPT check out at a merchant: the agent passes a narrowly scoped payment token and the merchant stays merchant of record.
- Every ACP purchase today is a human confirming inside an agent surface. Not built for machine micropayments.
- The protocol outlived its flagship surface; see the Instant Checkout story below.
More details
- From OpenAI and Stripe, Meta added as co-creator, PayPal as a processor; the spec is active and still labeled beta.
- Merchant charges the token through its own processor; checkout state stays on merchant systems.
TAP, the Trusted Agent Protocol Preview
A way for a shopping agent to prove "I am a known, accountable agent" on every web request, so merchants can let it through without weakening bot defenses.
- From Visa and Cloudflare: signed HTTP headers verified against a Visa-operated directory.
- Identity only. A verified agent can still make a bad purchase. No usage metrics yet.
More details
- Working group at launch: Adyen, Stripe, Worldpay, CyberSource, Elavon, Nuvei.
- The Visa-operated directory is also the neutrality question.
Rails and networks: where the money settles
Tempo Live mainnet
A payment network built for software and agents: a stablecoin blockchain with no volatile token, fees paid in dollars, settlement in under a second. Incubated by Stripe and Paradigm.
- Mainnet live March 18, 2026, launching MPP alongside. First outside validators: Stripe, Visa, Zodia.
- The validator set is permissioned, which is the honest caveat on any decentralization claim. No independent volume figures yet.
More details
- Batching, scheduled payments, smart accounts, guaranteed-blockspace payment lanes; 40+ named partners.
- Economics: tiny per-transaction stablecoin fees rather than interchange, paid through a fixed-price fee AMM. With no token, our read is that value accrues to the company (reportedly $500M raised at a $5B valuation) and Stripe-adjacent businesses. The industry-wide stablecoin prize is float, the yield on reserves.
Visa: Intelligent Commerce and ICC Pilot
Visa's program to keep agent shopping on Visa rails: one integration, Intelligent Commerce Connect, accepts transactions from every major agent protocol.
- Hundreds of real agent-initiated transactions completed in closed beta. ICC is a pilot with seven named partners.
- Consumer scale by "holiday 2026" is Visa's forecast, not data.
More details
- ICC accepts TAP, MPP, ACP, and UCP; by accepting every protocol, Visa monetizes acceptance no matter which standard wins.
- Visa validating on Tempo is a hedge into the stablecoin model; card economics are heavy for sub-cent machine payments.
Mastercard: Agent Pay and AP4M Live
Mastercard binds a tokenized card credential to a specific verified agent, merchant scope, and consent. Live for real cardholders, among the furthest along of the incumbents.
- Broadly available to US cardholders through supporting issuers since late 2025; first live transactions completed with CommBank in Australia and Westpac in New Zealand.
- The June 2026 sequel, Agent Pay for Machines, extends to machine-to-machine payments across cards, banks, and stablecoins. 30+ partners; partners are not volume.
More details
- Agentic Tokens extend Mastercard's tokenization stack; AP4M records agent permissions on public chains per reporting.
- No card network has published agent-initiated payment volume.
Commerce and interop
UCP, the Universal Commerce Protocol Live
A common language for AI agents to discover and buy from merchants, from Google and Shopify with a large retail coalition. Live in Google's AI surfaces for US shoppers.
- Designed with an escape hatch: when the agent cannot finish, checkout escalates to a human browser. That choice tells you where the technology actually is.
- 20+ endorsers including both card networks and Stripe. No published volume.
More details
- Apache 2.0 spec covering discovery through post-purchase; per-cart payment-handler negotiation; Shopify Checkout Kit for merchants.
- Demand side is effectively Google-controlled despite the open license.
A2A, the Agent2Agent Protocol Live
The standard way two agents from different vendors introduce themselves and hand work to each other. Not a payments protocol; AP2 is its payments companion.
- Linux Foundation stewarded (it started at Google), v1.0 stable, integrated by all three hyperscalers.
- 150+ supporting organizations, and that number is memberships, not deployments.
More details
- Signed Agent Cards for identity and capability discovery; task delegation semantics; SDKs in five languages.
- Production use is claimed by sector (supply chain, financial services, insurance), not by named customer.
OpenAI Instant Checkout Mothballed
ChatGPT's own buy button. The most important cautionary story in this space, worth telling straight.
- Launched in 2025 with the largest consumer distribution any agent-commerce product has had, roughly 50 million shopping queries a day.
- By March 2026 OpenAI shelved it from search results. Reports put the merchants that ever went live between a dozen and around thirty, a tiny fraction of Shopify's base; Walmart said in-chat checkout converted at about a third of its own site's rate.
More details
- Purchases moved into merchant-built ChatGPT apps (Target, DoorDash, Instacart, The Knot); the ACP protocol lives on underneath.
- The lesson is not that OpenAI failed. It is that distribution does not compress the hard parts: merchant integration, inventory and tax complexity, and what buyers actually want to do inside a chat. Announcements and adoption are different facts.
Who actually uses this today
Developers are the real machine-buyers today. Consumers mostly still check out themselves.
In rough order of how real the usage is:
- Developers are the actual machine-buyers today. Their agents pay per API call over x402 and MPP. Small dollars, real behavior.
- Enterprises are the earliest bounded-spend segment: procurement and cloud-cost agents inside policy limits, mostly vendor-narrated so far.
- Merchants are integrating faster than buyers are buying: Etsy live, a small Shopify subset, a big-box coalition endorsing UCP.
- Consumers mostly use agents for discovery and then check out themselves. Surveys show real hesitance about delegating the purchase.
How the money is made
Most protocols are free. The businesses sit around them.
Almost every protocol here is free. The businesses sit around them. That single fact explains most of the strategic behavior: everyone is racing to own a position, and monetization is deferred.
| Layer | Who pays | Monetization today | Monetization later |
|---|---|---|---|
| Authority + wallets | Agent operators, embedding developers | Platform/usage fees, card interchange | Standing-authority infrastructure as SaaS |
| Payment protocols | Nobody (free specs) | Facilitator and processing fees around them | Position and toll control if a standard wins |
| Card rails | Merchants (interchange, network fees) | Normal four-party economics; no new agent pricing | Tokenization/credentialing value-added services |
| Stablecoin rails | Transacting parties (tiny fees) | Per-transaction fees; issuers earn float on reserves | Network scale; agent share unknown |
| Commerce surfaces | Merchants (checkout fees) | Observed at launch, then pivoted; effectively pre-revenue | Surface economics if consumer behavior arrives |
| Outcome verification | Buyer or seller per transaction | Early, demand unproven (our own layer, stated honestly) | Per-decision fees, outcome history |
One structural fact underneath: sub-cent machine payments break interchange economics, fixed card costs exceed the payment. That is why Mastercard's machine product adds bank and stablecoin legs, and why Visa became a validator on a stablecoin chain.
What one real transaction looks like
Put the layers together on a concrete purchase: an agent buys 100 enriched company records at $1 per accepted record.
Every layer on this page handles the first four steps. The fifth, judging the result against the agreement and letting the economic outcome follow, is still done ad hoc: buyer acceptance, support tickets, refunds, disputes. That is the layer Spoolis builds. It applies mostly to result-shaped purchases rather than two-cent API calls, and not every transaction needs it.
Where the stack is still fragmented
Five seams where the stack still does not compose.
- Outcome verification: no major incumbent payment protocol provides a general, portable answer to whether purchased work was correct or how much was earned.
- Identity and delegation edge cases: TAP proves an agent is known; AP2 proves a human authorized; nothing yet composes them end to end across surfaces.
- Disputes and recovery: card rails keep chargebacks; crypto rails mostly have nothing; neither understands partial success.
- Portability: an agent's history, permissions, and results do not travel between platforms.
- Standards sprawl: at least eight overlapping protocols from five camps. Visa's answer, accept all of them, may be the most honest read of where this settles.
Where this is probably going
Direction is clearer than timing. Timelines have embarrassed everyone.
Direction, stated carefully: more software buying software; delegated spend limits replacing per-purchase approval as trust builds; machine-native checkout for machine-sized purchases; receipts and results becoming portable inputs to the next transaction; and either convergence of the protocol pile or aggregation layers that make convergence unnecessary. Timelines here have embarrassed everyone so far, including the biggest distribution owners on earth.
The acronym decoder
- A2A · Agent2Agent Protocol
- Agents from different vendors introducing themselves and delegating work. Linux Foundation. Not payments.
- ACP · Agentic Commerce Protocol
- Agent checkout at merchants. OpenAI + Stripe. Powered Instant Checkout.
- AP2 · Agent Payments Protocol
- Signed proof a human authorized the agent's purchase. Google, now FIDO Alliance.
- AP4M · Agent Pay for Machines
- Mastercard's machine-to-machine extension of Agent Pay, multi-rail.
- ICC · Intelligent Commerce Connect
- Visa's protocol-agnostic on-ramp for agent transactions. Pilot.
- KYA · Know your agent
- A term of art, not a spec: the KYC analog for verifying an agent and its delegation.
- MAP · Mastercard Agent Pay
- Card credentials bound to a verified agent and consent scope. Live.
- MPP · Machine Payments Protocol
- The rail-agnostic language for machine payments. Tempo + Stripe.
- TAP · Trusted Agent Protocol
- Cryptographic agent identity in HTTP so merchants can admit real agents. Visa + Cloudflare.
- UCP · Universal Commerce Protocol
- Agent-to-merchant shopping across the full journey. Google + Shopify.
- VIC · Visa Intelligent Commerce
- Visa's umbrella initiative over ICC and TAP. A program, not a protocol.
- x402
- HTTP's 402 status code revived: the request itself says this costs money. Coinbase, now Linux Foundation.
Questions people actually ask
What is agentic commerce?
Software spending money on a person's or company's behalf, within authority they delegated. The human sets goals and limits; the agent transacts. It does not require both sides to be agents.
What is the difference between agentic commerce and agentic payments?
Agentic payments is the narrower piece: the mechanics of an agent authorizing and executing a payment. Agentic commerce is the whole transaction: discovering, agreeing, paying, delivering, and judging the result. Most of today's infrastructure is agentic payments; the rest of commerce is still assembling.
What is the difference between authorization, settlement, and outcome verification?
Authorization answers "may this payment happen" (the human said yes, the budget allows it). Settlement answers "did the money actually move." Outcome verification answers "did the purchased work happen as agreed, and how much was earned." Card networks do the first two well. The third is not part of any incumbent payment protocol.
What is an agent wallet?
A wallet an agent can operate under programmable rules the owner sets: amount caps, merchant or recipient allowlists, expiry. The agent gets scoped credentials, never the raw card number or key.
What is x402?
An open protocol where a server answers a request with HTTP 402, "payment required," plus a price, and the client pays in stablecoins and retries. It makes any API payable by a machine with no account.
What is MPP?
The Machine Payments Protocol, an open standard from Tempo and Stripe for machine-to-machine payments: one-off charges, metered sessions, subscriptions, and receipts, across multiple payment rails.
What is the difference between x402 and MPP?
x402 is the original single-rail pattern: stablecoins, mostly USDC on Base. MPP generalizes the same HTTP 402 handshake across rails (stablecoins, cards, Lightning) and adds sessions, subscriptions, and receipts.
What is AP2?
The Agent Payments Protocol: cryptographically signed mandates proving a real person authorized what their agent bought. It authorizes payments; other protocols execute them.
What is the difference between Link for agents and Ramp Agent Cards?
Link delegates a consumer's own saved payment methods to an agent with per-purchase approval. Ramp issues single-use corporate cards to an agent under company spend policy. Consumer wallet versus corporate card.
What does Tempo do?
Tempo is a stablecoin blockchain built for payments: fees paid in dollars, sub-second settlement, batching and scheduled payments. It launched MPP and serves as a settlement rail for machine payments.
Do agents need crypto?
No. Card-based paths exist (Link, Agent Pay, Visa's programs). Stablecoins have become common at the machine-to-machine micropayment end because cards are uneconomical below a few cents.
Can agents use credit cards?
Yes, through tokenized credentials bound to a verified agent (Mastercard Agent Pay, live for cardholders in several countries) or scoped one-time cards (Link, Ramp). Not by typing your card number into a form.
Who controls how much an agent can spend?
The principal, through whichever authority layer they use: a session budget (AWS), a card cap (Ramp, Link), an onchain spend permission (Coinbase), or wallet policies (Privy). Enforcement sits in infrastructure, not in the agent's judgment.
Where does Spoolis fit?
After payment authority and execution. Spoolis is for transactions where payment depends on whether the agreed outcome actually happened: it checks the delivered result against the agreed terms and produces a verifiable outcome payment systems can act on. Most two-cent API calls do not need it. Result-shaped purchases often do.
Sources and verification
Every load-bearing claim, with its source and verification date
All claims verified 2026-08-24 against primary sources (vendor docs, spec repos, press releases); secondary sources are marked. The full machine-readable dataset behind this page, including per-claim activity classification, is maintained as a versioned research model.
| Claim | Source |
|---|---|
| AgentCore Payments GA 2026-08-18, session budgets, named partners | AWS blog |
| Ramp single-merchant capped expiring agent cards, preview | agents.ramp.com |
| Link SPT scoped credentials, per-request approval, limits planned | Stripe blog |
| Privy policy engine; scale figures are aggregate wallet activity | Privy docs, privy.io |
| Coinbase Spend Permissions mechanics and GA | CDP docs |
| x402 counts (160M per Coinbase; 100M+ per Chainalysis); token-minting wave; ~$0.20 average | Chainalysis, CoinDesk secondary |
| x402 micropayment demand "not there yet" | CoinDesk secondary |
| MPP scope, rails, SDKs, production merchants | mpp.dev, Stripe blog |
| AP2 mandates, FIDO donation, 60+ partners, no usage data | AP2 repo, Google blog |
| ACP mechanics, PayPal joining, beta spec cadence | ACP repo, Stripe docs |
| TAP signed-header identity, Visa directory, working group | Visa IR, Cloudflare |
| Tempo mainnet 2026-03-18, fee AMM and no-token model, reported $500M/$5B raise | Tempo docs, The Block secondary |
| Visa closed-beta transactions, ICC pilot partners, protocol list | Visa PR |
| Mastercard Agent Pay issuer rollout; AP4M 30+ partners | Mastercard IR |
| UCP design, live Google surfaces, coalition | Shopify engineering, Google dev blog |
| A2A v1.0, 150+ orgs, hyperscaler integration | Linux Foundation |
| Instant Checkout shelved 2026-03-24; merchant count 12-30; Walmart conversion figure | CNBC (primary reporting), Walmart via Wired/CNBC secondary |
| ~3% of transactions involve AI agents (survey-derived) | Checkout.com report, June 2026 |