Agentic Payments: Build Now, or Wait?

I've spent the last few years on the delivery side of a team that builds financial platforms and production AI, and for most of 2026 the question I kept getting asked was some version of: are AI agents really about to start spending money — and should we be building for that now? This is the piece I wish I'd been able to hand people at the time.

The state of play

Eighteen months ago, "agentic payments" was a slide-deck idea. By the middle of 2026 it was a board-level question. Visa shipped Intelligent Commerce; Mastercard followed with Agent Pay; Stripe rolled out the Agentic Toolkit; Coinbase put x402 in front of every API on the internet; Google announced AP2 with more than sixty payments and technology partners. The result: every product team that touches commerce, content, B2B SaaS, or infrastructure now had to take a stance on whether they were building for software customers, accepting agent-initiated transactions, or both.

The question I kept hearing wasn't whether this was coming. It was whether teams should be allocating budget to it now — or whether the responsible move was to wait six to nine months for the standards to settle. That's a more specific question with a more specific answer, and it's worth working through carefully.

Where agentic payments already are

The first thing worth saying is that this is well past the research-project phase. The protocols and rails are real, they're shipping, and the volume is no longer hypothetical.

On the protocol side, three standards have emerged as the serious contenders. x402, Coinbase's reincarnation of the long-reserved HTTP 402 status code, lets agents pay for API calls, content, and compute using stablecoins on Base, Polygon, Arbitrum, and Solana. AP2, Google's Agent Payments Protocol announced with Coinbase and over sixty partners (PayPal, Mastercard, Amex, Adyen, Worldpay, JCB, UnionPay), focuses on agent-to-merchant authorisation. MCP, the Model Context Protocol that Anthropic open-sourced and the industry standardised on for agent tooling, now has a wave of payment-related extensions — Stripe even hosts a remote MCP server at mcp.stripe.com.

On the major-network side, the moves are equally concrete. Visa Intelligent Commerce has completed hundreds of secure agent-initiated transactions in closed beta, with more than 100 ecosystem partners. Mastercard Agent Pay is on track to enable all US cardholders by the 2026 holiday season, with a PayPal partnership for global rollout. Stripe's Agentic Toolkit is the most builder-friendly fiat-rail option on the market today, with Python and TypeScript SDKs and direct integrations with LangChain, CrewAI, and the Vercel AI SDK.

The stack was splitting into two layers — protocols (how agents ask to pay) and networks (who clears the transaction).

Underneath both layers, the settlement story has converged. Stablecoins are the agent-native rail because they settle programmatically and predictably — Stripe's acquisition of Bridge for roughly USD 1.1 billion is the loudest signal that the major payments players agree. Account abstraction (post-Pectra ERC-4337 and EIP-7702) is the wallet-layer feature that makes spending limits, allowlists, and circuit breakers possible at the protocol level. Agent identity — DIDs, verifiable credentials, attestation frameworks like Visa's Trusted Agent Protocol — is the next unsolved piece, and the gap is shrinking quickly.

At the application layer, the use cases are no longer hypothetical. Pay-per-call API access is shipping. Agent-managed subscriptions are shipping. Autonomous procurement is in pilot at multiple enterprises. And Australia — where I'm based — is already in the conversation: Mastercard completed the country's first authenticated agentic transactions using Agent Pay earlier this year. For Australian teams, the regulatory and rails conversation is no longer something happening only offshore.

The takeaway: if you'd walked into a strategy meeting six months earlier, you could legitimately have said "we don't need to think about this yet." By mid-2026 that window had closed.

Where it's heading, and how fast

The twelve-to-twenty-four-month trajectory is now visible enough to plan around, even if it's not fully settled.

A handful of things are effectively locked in. Stablecoin settlement as the agent-native rail isn't going anywhere; the regulatory tailwind around stablecoins through 2025 made this less risky, not more. Programmable spending controls at the wallet layer are now table stakes. The basic shape of agent identity and consent — this agent, acting on behalf of this principal, with this authority, expiring at this time — is converging across the standards in roughly the same direction.

A handful of things are still moving. Which specific protocol wins out at the rail layer is genuinely unsettled: x402 has the developer momentum, AP2 has Google's distribution and the broadest partner list, the card networks have the merchant relationships. Regulators will eventually take positions on agent-initiated transactions, particularly in the consumer-protection and chargeback domains. And the dispute-and-reconciliation layer — what happens when an agent buys the wrong thing — is barely scaffolded yet.

The shift underneath all of this is the bigger story. Businesses now need to design for non-human buyers. Pricing pages need machine-readable equivalents. Discovery shifts from search-and-click to delegation-and-approval. Subscriptions unbundle into per-request payments. And entirely new flow types — business-to-agent, agent-to-agent — show up that don't have natural human equivalents.

If you're a product team, the question isn't really "should we accept agent payments?" It's "do we want our product to be visible to non-human customers, and on whose terms?"

Should you build agentic payments now, or wait?

For most teams, the right move is to start now — but in a specifically scoped way. The signals below clarify which side of that line a team sits on.

Three signals that mean you should start now:

1. Your product has an obvious surface for agent buyers. API access, content paywalls, compute markets, programmatic procurement, B2B SaaS with metered usage. If your offering can plausibly be purchased by software, the cost of being late is real.
2. Your team has the engineering bench to handle the parts that aren't yet mature. Security, observability, identity, key management — these are not stripe-an-SDK-and-go problems. If you have the engineering culture that ships financial infrastructure responsibly, this is your edge.
3. Your competitors are also exploring. In emerging categories, the operational knowledge you build from running a real flow compounds. Being first matters more than being right on the standard.

Three signals that mean you should wait six to nine months:

1. Your product is consumer-facing with low margins and high regulatory exposure. The disputes-and-reconciliation layer is the least-settled piece of the stack, and the failure modes get amplified fastest in consumer commerce.
2. Your team is already stretched on existing AI initiatives. Agentic payments demand serious production discipline. If your team is still figuring out how to ship a reliable LLM feature, this isn't the moment.
3. Your buyer is in a regulated industry where agent-initiated transactions don't yet have clean compliance answers. Healthcare, financial services, government — wait for the regulators to take their first positions, then move.

The honest verdict: a structured experiment now, not a full product commitment. Pick one rail, scope one flow, set hard limits, and use the work to build operational knowledge before the patterns calcify. In practice, a team that's shipped both LLM features and payments work can stand up a scoped first flow in roughly a quarter — not the multi-year programme the topic's complexity might suggest.

How to start building for agentic payments

The teams getting ahead aren't waiting for standards to settle. They're running narrow, well-scoped experiments now, while the cost of getting it wrong is still low. Three moves to make in the next quarter, in order:

1. Make your existing product machine-legible — clean APIs, structured pricing, deterministic endpoints. Even if you're not ready to accept agent customers yet, this is the lowest-regret move on the list.
2. Pick one rail and ship one flow — x402 if you're crypto-native, Stripe Agentic Toolkit if you're fiat-native. Don't build the abstraction layer until you've actually shipped something concrete.
3. Treat agent identity and authorisation as design decisions now, not retrofits later — who can spend on behalf of your user, with what limits, with what audit trail. These questions are much easier to design for than to retrofit.

As a rough rule of thumb on the rail choice: x402 if your customer is crypto-native and you want sub-cent settlement; Stripe Agentic Toolkit if your customer is web-native and expects fiat with virtual card issuance; the card-network options (Visa Intelligent Commerce, Mastercard Agent Pay) if your customer expects card-style chargeback rights and you sell into mainstream consumer flows.

Why I have a view on this

I work on the delivery side of a team that's been building financial platforms for the better part of a decade, and that shipped a production AI tool now serving 85,000+ users globally — which was a hard education in shipping non-deterministic AI workflows reliably. Agentic payments sit exactly at the intersection of those two disciplines: payments infrastructure built right, plus production AI built carefully. The failure modes live in the seam between them — which is what I dig into in Part 2.

The teams getting ahead here are the ones running structured experiments now: not waiting for the standards to settle, not betting the company, but building operational knowledge before the patterns are locked in. If you're weighing the build-or-wait question for your own team, I'm always happy to compare notes.

Next in this series → Agentic Payments: How to Build Them Without Breaking Them

---

I drafted this in June 2026, before the wave of unified-stablecoin announcements from the card networks and Stripe. I'm keeping it here as written — a snapshot of where the agentic-payments stack stood then — with a follow-up on what changed. A version first appeared in the Labrys content pipeline, where I work on the delivery side.