What are agentic payments?

Agentic payments are transactions initiated by AI agents on behalf of a person or company. The agent picks the merchant, decides the amount, and completes the payment without a human clicking a button. They are the payment layer of a much bigger shift: software that does not just suggest actions, but takes them.

For most of the internet's history, a payment has been the moment a human says yes. Cards, Apple Pay, Swish, and BankID are all designed around a human in front of a screen who approves each transaction. Agentic payments break that assumption. The agent is the user, and the human moves from approving every transaction to setting the rules the agent operates under.

Why now

Three things finally lined up in 2025 and 2026 to make this practical:

• Capable agents. Modern coding, research, and operations agents can run multi-step tasks for minutes or hours. They hit APIs, scrape data, call tools, and produce real work output. That work has real costs.
• A payment protocol they can speak. Coinbase's x402 standard reuses the long-dormant HTTP 402 Payment Required status code so any web resource can quote a price and any client (human or agent) can pay inline. No card form, no checkout redirect, no human in the loop.
• Programmable money on stable rails. Stablecoins (USDC, EURC, and new entrants like SEKAU) settle in seconds for fractions of a cent. That makes metered, per-call pricing actually viable, the same way HTTPS made online commerce viable.

What makes agentic payments different

On the surface, an agent paying $0.04 for an API call looks like any other small charge. The mechanics underneath are almost nothing like consumer or B2B payments.

1. Volume and frequency are different by orders of magnitude

A human makes a handful of payments a day. An agent doing research, code, or operations work can make hundreds of micropayments in a single task: one for each paid API call, dataset query, tool action, or compute unit. Pricing models that did not work at human speed, like true pay-per-call, pay-per-token, or pay-per-second, start to make sense once a machine is on the buyer side.

2. The agent is the buyer, the human is the principal

In every existing rail the cardholder, the account holder, and the person clicking "pay" are the same entity. With agents they split apart. The principal (you, or your company) owns the funds and the policy. The agent acts under that policy. The merchant gets paid by a wallet that belongs to the principal but is operated by the agent. This is closer to corporate procurement than to consumer checkout, but at a speed and granularity neither was designed for.

3. The trust model inverts

With a human you can ask "is this you?" mid-transaction (a CAPTCHA, a 3DS challenge, a push to your phone). With an agent that kind of interrupt is meaningless, because the agent will answer yes. So the trust check has to move earlier, to before the agent ever sees a merchant: into the policy that defines what the agent is allowed to do.

How an agentic payment actually flows

The x402 protocol gives the industry a shared shape for this. A round trip looks something like this:

1. The agent makes an HTTP request to a merchant (an API, a dataset, a tool endpoint).
2. The merchant responds with 402 Payment Required and a small JSON body describing the accepted assets, networks, recipient address, and amount.
3. The agent's payment layer checks the request against the policy the human set (budget remaining, per-call cap, merchant allowlist, approval thresholds).
4. If allowed, the payment layer asks the wallet provider to sign a payment payload. Funds never leave the principal's wallet until this point.
5. The agent retries the original request with the signed payment header attached.
6. The merchant verifies, settles on-chain (typically in 1–2 seconds), and serves the real response. A receipt is written for the principal.

What agents are actually paying for today

• APIs and datasets: premium endpoints, search, enrichment, market data.
• Compute and tools: short-lived sandboxes, CI runners, code search, browser automation.
• Research: paywalled reports, legal databases, scientific literature.
• Operations: bookings, scheduling, procurement of small services.
• Other agents and software: paying another autonomous service for a subtask.

How they differ from cards, B2B AP, and crypto-as-it-was

Cards solve "a human is at a checkout." They require a present human and a merchant who accepts a 1.5–3% fee plus chargeback risk. Neither is workable when an agent is paying 4¢ per API call, hundreds of times a minute.

Traditional B2B accounts payable solves "a company pays a vendor on net-30 terms." It is built around invoices, approvals, and batches, not per-call settlement.

Crypto-as-it-was solved "transfer value between wallets." It moved the rails but left the user experience unchanged: still a human, still signing each transaction, still confirming addresses. Agentic payments need the rail and a governance layer on top of it.

Where governance comes in

The hardest problem in agentic payments is not the transaction. It is the rules. Giving an agent a wallet with a balance is a recipe for runaway spend, accidental purchases from spoofed merchants, or simply no audit trail when finance asks "where did this $1,800 go this month."

What companies actually need looks like corporate spend management, just at agent speed and granularity:

• Per-agent monthly budgets and per-transaction caps.
• Merchant allowlists (often: x402-verified merchants only).
• Approval thresholds where a human is pinged above a certain amount.
• Full audit trails with receipts tied back to the task that triggered the payment.
• The ability to pause or revoke an agent's spend without rotating the underlying wallet.

That governance layer is what Vayr Pay is building, sitting between the agent and a managed wallet provider like Coinbase. Funds stay with the provider. The agent talks to merchants over x402. Vayr Pay enforces the rules on every payment and writes the receipt.

Agents do not need a wallet. They need scoped, policy-bound access to one.

Why Europe matters here

European regulation is the first to take stablecoins seriously through MiCA, and the first euro stablecoins (EURC) and national-currency stablecoins (SEKAU for SEK) are shipping into a market that finance teams can actually account for. That makes Europe a natural starting point for agentic payments built on stablecoin rails, rather than a region playing catch-up.

The short version

Agentic payments are not a new payment method. They are a new payer. The payer is software, the volume is high, the amounts are small, and the trust check has to move from the moment of payment to the policy that defines what the software is allowed to do. Get that policy layer right, and agents can transact at machine speed without anyone losing sleep over the bill at the end of the month.

• Cloudflare will let anyone charge agents. Someone still has to let agents pay.
  Cloudflare's Monetization Gateway turns any API, page, dataset, or MCP tool into a paid resource over x402. That solves the merchant side. The buyer side — how an AI agent actually decides to pay, under whose rules — is the other half of the problem.
• MCP meets x402: how tool-calling agents actually pay for tools
  MCP gave agents a standard way to call tools. x402 gives those tools a standard way to charge. Here is how the two fit together, and what a paid MCP tool call actually looks like end to end.