I saw a piece of news this week and kept staring at it for a while.
Coinbase Business announced that AI agents can now buy domains on Atom, a domain platform, through the x402 payment protocol. x402 is a protocol Coinbase is pushing that lets machines pay each other directly with stablecoins, with no human making a manual transfer. The news also added that most x402 payments so far have been for buying data and API requests, and this time the use case extends to buying domains. (Coinbase Business already opened up agent payments for merchants back on July 23, also using x402, and the pitch then was that merchants don’t need any extra setup.)
My first reaction was: hey, this is really close to what I think about every day. I’m building a service marketplace where agents do business with each other, so I pay extra attention to how things get handled the first time an agent goes out to buy something real.
How Buying a Domain Differs From Buying an API Call
Honestly, in the earlier x402 examples, the agent paid a few cents and got a piece of data back. It paid, the data came back, done. Even if something went wrong, it was a tiny amount of money, and you just retried.
Domains are different. They have to be registered first, which can fail, and the amount isn’t pocket change anymore. The example Atom shows in its write-up is a domain called austastic.xyz, priced at 1.80 USDC (USDC is a stablecoin pegged 1:1 to the US dollar). That’s not a big number, but the flow is already a full, proper transaction.
Atom’s Approach: Money Moves Only After the Goods Arrive
According to Atom, the agent connects to Atom’s MCP server (an interface that lets AI tools call a service directly) to search for names that fit what you need. Then it lays out the price, the fees, and when the authorization expires for the buyer to see. Only after the buyer agrees does the agent sign a USDC payment authorization on Base, and the buyer doesn’t have to submit any on-chain transaction themselves.
Next, Atom registers the domain while the payment is “held,” and only collects the money once registration succeeds. In Atom’s own words: “Buyers aren’t charged for registrations that don’t go through.” If registration fails, the buyer isn’t charged. The way I understand it, this is a lot like a credit card’s “authorize first, capture later.”
So strictly speaking, the breakthrough this time isn’t letting an agent swipe your card behind your back. It’s handing the grunt work, searching, comparing prices, and filling in details, over to the agent, while the final call is still left to a human.
Why This Purchase Needs a Human to Say Yes
This is the part I find most interesting. Nobody expects an agent to ask you first before buying an API call worth a few cents. But for a 1.80 USDC domain, the design is: the agent finds it, the human approves, and the funds are held first.
My observation is that the trust boundary gets drawn roughly right here. For small amounts, where a failure and a retry don’t hurt, you can let the agent decide on its own. Once real money is involved and the thing might fail, you want a human in the loop, and you want the money tied to “delivery succeeded.”
I’ve been thinking about this the whole time I’ve been building the marketplace. When both sides are machines, there’s no support line to call, and nobody to complain to about “I paid but got nothing.” The system has to absorb that on its own. If you also want to sell your service to other people’s agents, having a payment interface isn’t enough. You have to work out in advance how the money gets back to the buyer when delivery fails.
The Current Limits
Right now, agents can only buy newly registered domains. Atom says pricier premium domains are the next step. And x402 isn’t the only way to pay: Atom also supports credit cards, going through the Machine Payments Protocol from Stripe and Tempo.
I’m still not sure whether agents will pick domains for me someday (I can agonize over picking a name for three days all by myself). But if that day really comes, I’d want to look first at where that money is being held.