Agents can think. They can't pay.

An AI agent can research a market, write the code, and ship it. But the moment it needs something behind a paywall, like a data feed, an OCR endpoint, or a better model, it stops cold and waits for a human to paste in a credit card.

We spend all of our attention on making agents smarter. Bigger context windows, better tools, sharper reasoning. But the thing that most often ends an agent's run isn't intelligence. It's money. An agent that can't pay for what it needs isn't autonomous. It's an intern who has to come find you every time there's a bill.

Everything on the internet assumes a human is buying

Every paid API you have ever used was designed for a person. You create an account. You verify an email. You paste a card into a Stripe form. You get an API key, a dashboard, and a monthly invoice. That flow is completely reasonable for a human who signs up once and uses the service for months.

An agent has none of that. It doesn't have an account. It can't be handed your card without becoming a liability. And it discovers what it needs at runtime, so the whole point is that you didn't know in advance it would need a currency API at 2am. The billing model of the web and the way agents actually work are fundamentally mismatched.

The obvious fixes all break

Every team hits this wall and tries the same three things first. They all fall apart.

• Give the agent your API key. This works until the agent, or a prompt injection riding in on some webpage, burns your quota, hits a rate limit at the worst moment, or leaks the key into a log.
• Give it your credit card. Now there are no per-call limits, no real visibility into what it bought, and unbounded downside if it loops.
• Pre-buy credits with every vendor. This is fine for two or three services. It is hopeless across the long tail of tools an agent might reach for, and it defeats the point of an agent that finds what it needs on its own.

Each of these is a workaround for the same missing primitive: a way for software to pay for one thing, once, without a standing relationship.

What machine-native payments actually require

If you design payments for agents from scratch, rather than for humans, you arrive at a short, strict list.

• Instant settlement. The call happens now, so the money has to move now. No three-day holds, no chargebacks weeks later.
• Real micropayments. A single call might cost a fifth of a cent. Card rails, with their fixed minimum of around 30 cents, make that economically impossible.
• No accounts. Identity is a wallet the agent controls, not an email and a password it can't manage.
• Programmable limits. Spend caps the agent literally cannot exceed, set by you, enforced before the money moves.

That list quietly rules out cards and bank transfers, and points at something specific: a stablecoin on a fast, cheap chain. USDC on Stellar settles in seconds for a fraction of a cent, and pairs with an open protocol for paying as you go over plain HTTP.

402: the status code the web forgot

HTTP has always had a status code reserved for exactly this moment: 402 Payment Required. It has been sitting in the spec, unused, for 25 years, because there was never a clean way to actually pay inside the flow of a request. The x402 protocol finally wires it up. The exchange is four steps and one round trip.

• The agent calls an endpoint with no payment.
• The server replies 402 with a price and a pay-to address.
• The agent signs a USDC payment and retries, carrying the proof in an X-PAYMENT header.
• The server verifies it, does the work, and returns the result with a receipt.

What this unlocks

A payment primitive this small changes what an agent is capable of, and what a developer can sell.

• Agents buy exactly what they need, the moment they need it, inside limits you set. No human in the loop, and no standing subscriptions.
• Any developer can monetize an API by wrapping it once and getting paid per call. No accounts to manage, no billing system to build, no Stripe integration.
• A real marketplace of capabilities becomes possible. APIs, tools, models, and datasets that agents can discover and pay for on their own.

This is the layer we are building at Tael. You wrap any capability, give it a price, and let agents pay per call in USDC on Stellar. The agent brings its own wallet, and the builder gets paid automatically. That is the whole idea: give agents the one thing they were missing, and get out of the way.