Machine-to-Machine Payments
Why the next frontier in payments has no human in it. What it is, why it works now, and whether it's where the next payment companies get built.
Every leap in payments has done the same thing. It has moved the human further from the mechanics of paying.
We swiped and signed. Then we dipped a chip, and the card’s secret moved into the silicon. Then we typed the number into a browser. Then we stopped typing it at all.
Apple Pay, Google Pay, a tap, done. Visa has provisioned more than 12.6 billion network tokens. Most people who use them never learn that the real card number stays with the bank.
Each step abstracted the human from the credential. A person still decided, and a person still paid.
Then came agentic commerce, the story of the past year. An AI agent acts on a person’s behalf, sometimes only suggesting a purchase, sometimes preparing it and waiting for a click, and increasingly completing the buy on its own inside limits the person set once. (If you need a refresher on which protocols exist, check out “Payments Protocols”).
Agentic commerce still points one direction, though. An agent buying from a merchant, for a human, mostly on the card rails.
There’s one step past that. The machine stops shopping for a person and starts buying for itself.
That’s machine-to-machine payments. The payer is software, the payee is software, and the thing changing hands is usually a service the machine needs to do its own job. Compute, a model call, data, an API.
This isn’t theoretical. In the first half of 2026, Coinbase, Stripe, Google, Visa, Mastercard and AWS all shipped agent-payment products. In May, AWS wired agent payments into Bedrock’s AgentCore in preview, built with Coinbase and Stripe, letting software discover a service, agree a price, pay, and move on inside a single loop, settling in a fraction of a second with no human approval.
Two of those launches are the clearest lens on where this goes. Coinbase built a rail for machine payments, called x402. And in June 2026, Mastercard built a product for them, called Agent Pay for Machines. Most of this piece breaks down those two.
[Image 1: The evolution of payments, from swipe to machine-to-machine]
What follows is what machine-to-machine payments are, why they work now when they never did before, and the question that matters most. Is this a frontier where new payment companies get built? Or is it early crypto again, interesting to specialists and no one else for a few more years?
Let’s dive in.
What machine-to-machine actually means
Two terms get used as if they’re one. They aren’t.
Agentic commerce is an agent transacting on behalf of a person. It runs across three modes. Discovery, where the agent finds and recommends. Human in the loop, where it prepares the purchase and waits for approval. Fully autonomous, where it completes the buy within the guardrails the person sets in advance. All three are agentic commerce, and all end with a merchant buying something for a human, mostly on cards.
Machine-to-machine moves the buyer. Here the software is the customer. It pays for what it needs to finish its own work, and it pays other software, not a store. Compute, an API call, a dataset, or a task handed to another agent.
Autonomy isn’t the dividing line, which is where the terms get muddled. A fully autonomous agent buying someone a pair of headphones is still agentic commerce. The same agent buying the compute it runs on is machine-to-machine. The question is who the purchase serves and what’s being bought.
There are four kinds of machine payment, and only one is really live.
[Image 2: The four types of machine payments]
Agent-to-service is an agent paying for an API, a model call, or a slice of compute. That’s the one transacting today. Agent-to-agent, one agent hiring and paying another, is real but mostly experiments. Agent-to-merchant is agentic commerce again, running on cards. Device-to-device, for example a car paying for a charger or a sensor selling its data, is still mostly a promise in 2026.
So “machine-to-machine payments are exploding” means one narrower thing. Agents are paying for software services, in small amounts, very often.
The honest number is worth stating plainly. On rails like x402, agents have run well over 100 million transactions and tens of millions of dollars in volume since 2025, at an average ticket near 20 cents.
That figure needs a caveat. A large share of it is test traffic and meme-coin activity, not commerce anyone would recognize. The plumbing is real and shipping fast. The genuine demand is still small.
Both are true at once. A transaction count quoted without that caveat is a headline, not an analysis.
So why would we care?
Small today doesn’t mean small forever. Tokenization started small too, now more than half of all transactions are tokenized either via a wallet or network tokens.
Why the card can’t follow the money down here
The mechanical reason a new rail exists at all comes down to a fixed cost.
A card transaction incurs roughly 30 cents in fixed costs before any percentage is added. That’s invisible on a 90-dollar pair of shoes. It’s fatal on a 20-cent API call.
A fixed 30-cent fee on a 20-cent purchase isn’t a fee. It’s a barrier. Most machine payments live below it.
When an agent calls a model a thousand times a minute, each call costing a fraction of a cent, card economics don’t survive the contact.
[Image 3: Why the card can’t reach the bottom of the stack]
Cost is only half of it. The rest of the card stack assumes a person is present.
No one taps a phone, approves a push, clears a 3DS check, or squints at a CAPTCHA. Those steps exist to prove a human authorized the payment. Remove the human, and they lose their meaning.
A machine can’t prove it isn’t a robot. It is one.
The theme is familiar from these breakdowns. Payments got cheaper; complexity did not. The card rails are built around one assumption: a person at checkout decides to buy, and machine payments break that assumption at its root.
That break is the opening. It’s why there’s room, for the first time in years, to build something new underneath.
x402, the rail built on a part of the web nobody used
x402 comes with a good backstory.
When the web was designed in the 1990s, its authors reserved a status code, number 402, labeled “Payment Required,” and marked it for future use. The web might one day need to charge for something directly. It sat unused for nearly thirty years, because the web found other ways to make money and no machine needed to pay another one mid-request.
Coinbase built on it in 2025. That’s x402.
The mechanic is simple. An agent asks a server for something. The server replies that it costs, say, a quarter of a cent, and asks for payment first. The agent pays in stablecoin in the same exchange, asks again with proof, and gets what it wanted. No account, no signup, no human, in about the time it takes to load a page.
It spread for three plain reasons. It’s nearly free to add, and a developer can wire it up in an afternoon. It’s cheap to run because a stablecoin transfer costs a fraction of a cent rather than 30 cents. And Coinbase gave it away.
In April 2026, x402 moved to the Linux Foundation, the neutral home behind much of the internet’s shared infrastructure. Visa, Mastercard, Google, AWS and Circle are all involved. That shift turned x402 from one company’s product into something closer to a shared standard, which is how a payment rail reaches critical mass.
One point carries the rest of this piece. x402 is a single thin layer. It’s the moment of payment and nothing else.
It doesn’t know who the agent is. It doesn’t know whether the agent was allowed to spend. It keeps no invoice, runs no dispute, files no report. It moves value and steps aside.
That’s by design, and it’s useful. It also means x402 is a component, not a payments company.
Agent Pay for Machines
Mastercard took a different route, and a revealing one.
Rather than treat a stablecoin rail as a threat, Mastercard built a machine-payments product that puts stablecoins to work inside it. Agent Pay for Machines, announced in June 2026, treats machines as a genuine class of payer. In Mastercard’s own framing, businesses will build services for AI agents to buy, and those agents will transact with each other continuously, at machine speed, down to microtransactions.
It runs on four steps. Authorize, Discover, Execute, Settle.
Mastercard’s own example is a coffee shop, and it’s worth walking through because it makes the model concrete.
The shop wants a website and gives an AI agent one instruction: build and launch our online presence. In Authorize, the owner sets a spending limit and picks a funding method, a card, a stablecoin wallet, or a credit line, and that permission is recorded on-chain, so there’s a tamper-proof record of what the agent may do.
In Discover, the agent finds trusted providers for the images, the copy, the domain and the hosting, using network-issued credentials so each side knows the other is legitimate. In Execute, it buys all of it, firing off a mix of small and larger payments at machine speed, using lightweight vouchers rather than a full card transaction each time.
In Settle, the providers batch what they’re owed and get paid in the currency they choose, fiat or stablecoin, with Mastercard standing behind the settlement.
Two details matter more than they first appear.
The batching step answers a hard problem. A million sub-cent payments can’t run through the card system one at a time; the economics above would kill it. So the agent transacts against cheap vouchers in the moment, and the network aggregates them into proper settlements afterward.
And Mastercard isn’t resisting stablecoins here. It’s building them in. The funding can be a stablecoin wallet, the payout can be a stablecoin, and the network adds what a raw transfer lacks: identity, trust between strangers, and a settlement guarantee.
A network committed real product to this while the volume was still small. That’s a considered read on where commerce is heading, not a reaction to where it is.
The stack a machine payment needs
Two anchors, then. A free crypto-native rail in x402, and a network wrapping it in a guarantee in Agent Pay for Machines. Set against the same picture, they show the whole shape of a machine payment.
[Image 4: What a machine payment is actually made of]
A machine payment isn’t one thing. It’s a short stack of layers, each a separate job.
Identity and authorization: who is this agent, and was it allowed to spend this.
Protocol and negotiation: how the two sides agree on what’s bought and for how much.
Rails and settlement: the actual movement of money, where x402 lives and where Mastercard settles.
Metering and billing: counting what was used, pricing it, keeping the record. Readers of the usage-based billing edition already know this layer. It’s the meter.
Plot the anchors on it. x402 sits at the rails layer, and only there. Agent Pay for Machines reaches wider, across authorize, discover and settle, because a network can.
Look at the top and bottom of the stack. Identity and the meter. Not the rail.
The lesson repeats from earlier editions. The rail is the cheapest layer in the stack. Moving the money is nearly free and getting freer, and the value sits above it, in knowing which agent to trust and in metering what it actually used.
For machines that’s truer still. Here the rail isn’t just cheap. It’s free, and run by a foundation.
So is this a real opportunity?
Now the real question. Not what x402 is, but whether a serious payment company gets built here, one that never looks at a human transaction. And if so, what does it build?
The answer is yes, and the money was never in the rail.
There’s no opportunity inside x402 itself. Coinbase gave it away, the protocol fee is zero, and settlement is heading to the floor, the way it did once stablecoins made moving a dollar almost free. The transfer is free, so there isn’t much of a business in charging for it.
The opportunity is the work around the rail. That’s where a machine-native payment company gets built, and the pieces are clear once the stack is in view.
It has to handle identity: proving an agent can be trusted before anyone transacts with it. Call it Know Your Customer for a customer that can’t hold a passport. It needs guardrails: hard limits, allow-lists, and a way to cut off an agent’s spending the moment it misbehaves.
It needs metering: counting and pricing what the agent used, the same monetization layer software companies already pay well for. It needs settlement and reconciliation: turning a flood of tiny payments into books a finance team and an auditor can close. And it needs compliance for a payer that fits none of the existing boxes.
These companies already exist in early form. Skyfire is building agent identity and a wallet, anchored on a “Know Your Agent” check. Crossmint is building agent wallets that work across rails. Nevermined is building metering and settlement made for agents.
None of them is trying to own the transfer. All of them are building the workaround for it. And none of them cares about a human checkout.
That’s the shape of the answer. x402 is a foundation to build on, not the building. The serious companies treat it as one component, the way they treat the internet’s transport layer, and put identity, metering, guardrails, and reconciliation on top.
Some lean on the network path instead, letting Mastercard carry settlement and the guarantee while they own identity or the meter. Most do both because, early on, you support every rail and let the market decide.
Two settlement models are worth separating. The pure stablecoin path, x402 style, is instant and final, with no middleman and no guarantee. Fast and cheap, but if an agent pays the wrong party, there’s no one to call. It sits outside chargebacks and outside Regulation E, with no dispute path and no one clearly on the hook.
The network path, Mastercard-style, is a beat slower but comes with identity, a guarantee, and a reconcilable settlement. One is built for speed and cost, the other for trust. The interesting companies bridge the two.
Reaching the machines is its own question, and you don’t sell to a machine. You integrate where they already operate: the AI platforms through the tool connections agents already use; the protocols through x402 and its peers; and the network programs through partner rosters like Mastercard’s. Plug in where the agents are, and their spending runs through you.
Should PSPs and acquirers care yet?
The harder question is the one that comes up most in strategy rooms. For a PSP or an acquirer, is this move now, or watch-and-wait?
The honest answer has two halves.
As a revenue line, wait. The genuine volume is small, most of it isn’t real commerce yet, and no one makes their year on 20-cent agent payments in 2026. Reorganize around this today, and you’re early in the way that costs money.
As a control point, don’t wait.
The pattern is recent enough to remember. Stablecoins looked like a niche for years while specialists built the infrastructure, and then the incumbents bought their way in. Stripe bought Bridge. Mastercard bought BVNK.
The companies that owned the infrastructure when the market moved got paid. The ones who waited paid up.
Machine payments are following a similar pattern, with one difference worth noting. The timeline is shorter. In the stablecoin cycle, the incumbents had years to react. Here, Mastercard shipped a machine product while the volume was still a rounding error.
So the choice, stated plainly. Machine payments won’t pay for themselves soon. But identity and settlement are control points, and control points are cheap to hold early and expensive to reclaim late.
If agents become a real class of payer, and the trend points that way, no one wants to buy their position back later from whoever took it while they waited.
The best time to take that position was probably last year. The second best is now.
The takeaway
For thirty years, every advance in payments moved the human another step from the machinery. The line ends here. The payer is now software, buying from software.
The rail for that world will be free. Coinbase proved it by giving away x402, and Mastercard made the same point by wrapping free rails around the one thing still worth charging for: trust.
The companies that matter won’t be the ones moving the money. They’ll be the ones that worked out what to charge for instead: the identity of the agent, the limits on its spending, and the meter that prices its work.
Machine-to-machine payments are small today, and easy to wave off. So was every other step on that line, right up until it wasn’t.
The human has left the loop. The only question left is who owns it now.
Thank you for reading.
P.S. If you’re reading this and are looking for the insights to help you improve your own strategy, that’s exactly what I help payments companies figure out.
20+ years in payments data and strategy. From being the First Data Scientist at Adyen, to being the First VP of Data Science & Analytics at Checkout.com, to helping over 50 of the top 150 acquirers and issuers globally, through my consultancy.
For Advisory. Speaking. Consultancy. Email me or DM me to set up a call.
Or, if you just want to keep fueling these breakdowns and deep dives, buy me a coffee.