Agent-to-agent commerce means a program buying a resource from another program: a data lookup, an inference call, an API response. No account opened in advance, no subscription, no human clicking approve. The buyer is software acting for somebody, and the seller has never heard of it before the request arrives.
Nothing in that description is new as an idea. What changed is that all four requirements below became satisfiable at once, and the last of them only in 2026.
The four layers, and which one was missing
| Layer | What it answers | State |
|---|---|---|
| Quotation | How does the buyer learn the price before committing? | Solved — x402, HTTP 402 with a machine-readable price |
| Settlement | Can the transfer cost less than the resource? | Solved — stablecoin transfers on low-fee chains |
| Authority | What stops the agent spending more than it should? | Solved outside the agent, not inside it |
| Accounting | Who spent this, on whose instruction, and can it be audited? | The gap — closed only in 2026 |
Read that table as a sequence rather than a list. Each layer is worthless without the ones above it, and an organisation will not adopt any of them until the bottom one holds.
Layer 1: a price a program can read
HTTP has carried a reserved status code for payment since the beginning of the specification, and it went unused for thirty years because the human web settled on subscriptions and advertising. Neither works when the client is a program making a thousand requests an hour on somebody else's behalf.
x402 gives the code a job. The server answers a request with 402 and a machine-readable price; the client pays and repeats the request; the resource comes back. The protocol launched in September 2025, and in July 2026 the x402 Foundation was formed under the Linux Foundation.
Layer 2: settlement cheaper than the resource
This is the constraint that killed every earlier attempt at micropayments. If moving the money costs more than the thing being bought, the arrangement inverts and nobody uses it twice. Cheap settlement is what made per-request payment arithmetically possible, and it is the only layer where the blockchain part is genuinely load-bearing.
Layer 3: authority the agent cannot argue with
A budget written into a prompt is a budget the model can be talked past. Anything reaching the agent's context — a web page it reads, a document it processes, an email it summarises — is a candidate instruction, and the model has no reliable way to tell instructions from data.
So the limit has to live outside. In practice that means a funded wallet with a ceiling, or a card credential scoped so tightly that exceeding it is not a decision the agent gets to make. The agent asks; something that is not a language model decides.
Layer 4: the one that was actually missing
In August 2026 Ramp opened an alpha letting corporate AI agents pay for x402-gated resources: USDC agent wallets on Solana, funded by the customer, with spend controls, attribution and an audit trail attached. The announcement carried the sentence that describes the whole gap: more than 35 million transactions had settled over x402, and until then none of them had touched a corporate ledger.
The protocol worked. The volume was real. And none of it was legible to a finance function. A payment that cannot be attributed, categorised and reconciled is not a corporate payment — it is an unexplained debit, and no controller signs off on a category of those.
- Attribution — which agent, acting for whom, on what instruction.
- A limit enforced outside the agent rather than inside its prompt.
- A record that outlives the agent and can be produced at audit.
- A path from that record into ordinary accounting, without a manual reconciliation step.
None of those four are protocol features, and none required changing x402. They are the wrapper an organisation needs before it will permit the protocol at all — which is why the consequential announcements in this area are about plumbing rather than payments.
Who else moved in the same week
The Ramp alpha did not arrive alone. The same days brought AWS announcing agent transactions through Bedrock AgentCore Payments, and Stripe acquiring OpenRouter. Read together, three separate parties concluded that the constraint on machine payments was never the settlement rail — it was everything that has to be true before a company lets software spend its money.
What is still missing
Two things, and both are about what happens when the transaction goes wrong rather than when it goes right.
Refunds and disputes
Every deployment we have looked at handles the happy path and improvises when the resource fails after payment. There is no established mechanism for a machine to dispute a machine. That gap will decide whether serious providers adopt the model, because a seller who cannot be held to delivery is a seller a procurement function will not approve.
Proving the thing was delivered
When the resource bought is an inference result, the buyer has no way to check that the seller ran the model it claimed. This is the problem zkML addresses: a proof that a specific model produced a specific output, verifiable without re-running it or seeing the weights. A result that can be proved is a result an automated counterparty can accept — which is the missing condition for a real market in machine-bought inference.
How to evaluate a vendor in this space
| Ask | Weak answer | Strong answer |
|---|---|---|
| Where does the spending limit live? | In the agent's system prompt | In the wallet or card credential, enforced before the agent is consulted |
| What does the audit trail record? | The transaction | The transaction, the agent, and the instruction that caused it |
| How does it reach accounting? | Export a CSV | A path into the ledger with categories already attached |
| What happens if the resource fails? | Not addressed | A defined dispute or refund path |
| Can delivery be verified? | Trust the seller | A proof, or an explicit statement that there is none |
Questions
- Is x402 a blockchain protocol?
- No. x402 is an HTTP convention: a server answers with status code 402 and a machine-readable price, the client pays and repeats the request. Payment is usually settled in a stablecoin because that is currently the cheapest way to move small amounts between parties with no prior relationship, but the protocol does not require any particular chain.
- Why not just give the agent a corporate card?
- That is roughly what the working deployments do, with two additions. The credential is scoped so tightly that the agent cannot exceed it, and the record ties each charge to the agent and the instruction behind it. An ordinary card gives you the payment without the attribution, and the attribution is the part a finance function needs.
- Can a language model be trusted to stay within a budget?
- No, and it should not be asked to. Any instruction reaching the model's context is a candidate instruction, so a limit expressed in a prompt is a limit that can be argued with. Enforce it in the wallet or the credential, where the enforcement is not a language model's decision.
- How large is this actually?
- More than 35 million transactions had settled over x402 by August 2026, according to the announcement that first put corporate accounting behind them. That figure counts protocol activity, not corporate adoption — corporate adoption started from approximately zero at that point, which is the reason the announcement mattered.