Stripe recently acquired AI routing platform OpenRouter for a reported $7.5 billion, making it one of the largest venture-backed AI startup exits and fintech M&A deals of the year. It’s a blockbuster deal that instantly became one of the most intriguing tech developments to occur this year. Not just because of the dollars involved or the reasons your tech newsfeed or social media timeline insists.

The broader perception seems to be that this is just a standard software developer tooling narrative. Financial analysts and tech enthusiasts would have you believe the main takeaways here are the massive acquisition price and Stripe’s shiny new resource to lower AI token costs. To many, OpenRouter is simply a tech-savvy developer utility that routes basic prompts to inexpensive AI models while setting aside pricey frontier models for complicated reasoning tasks.  Others view it as a way to prevent vendor lock-in from cloud ecosystem giants such as AWS Bedrock. But these perspectives are missing the big picture.

From my perspective, it’s clear that this acquisition sends a definitive signal about where the future of digital payments is heading – not just the future of artificial intelligence software. While it won’t happen overnight, agent-to-agent commerce is clearly opening the floodgates to a paradigm where autonomous software agents will serve as fully empowered economic participants that can conduct business on behalf of both individuals and enterprises.

In my line of work, that means we aren’t far away from the time when, for example, an automated car insurance agent can eventually meet, negotiate with, evaluate risk for and sell coverage to another company’s autonomous agent – with the entire exchange happening seamlessly behind the scenes.

From agents that assist to agents that transact

Consider how AI agents operate nowadays versus how they will perform in the near future. Today, agents primarily pass context back and forth across software interfaces. Case in point: A consumer uses a car shopping agent to search vehicle inventory for a new Toyota RAV4; after the consumer chooses the exact vehicle they want, the agent passes the pertinent details – make, model, buyer location and other criteria – to an insurance-quoting agent. In this model, data flows fluidly. Yet the software systems themselves complete no actual financial transaction. The agents aid the user, but human intervention via a checkout process, credit card entry or manual sign-off is needed to finalize the vehicle purchase.

Meta’s recent move to open access for developers to build Muse connectors is proof that this transition from passive assistance to direct execution is already underway. Personal agents like Muse, Instinct, OpenClaw and Dots can now leverage simple API connectors to handle browsing and user context in the background. At the same time, e-commerce giants like Shopify are giving agents direct access to checkout, with OpenRouter serving as the critical routing engine sitting right in the middle. This demonstrates that the real secret sauce is in the transaction layer, not just model intelligence.

These developments signify a major leap from agent assistance to direct execution. In the agent-to-agent economy just over the horizon, software agents will actively complete end-to-end transactions without an information handoff hard stop. Instead of multiple agents involved, a single AI agent will be able to buy specialized micro-services from another agent, retrieve proprietary data from secure databases, negotiate contract details using preset operational guidelines and fulfill sophisticated tasks on demand.

Before panic ensues, let me make it clear that this shift doesn’t mean real people, or their jobs, will completely disappear from the loop. This entire ecosystem still requires oversight from human beings, who will be needed to set important goals, define ethical boundaries and enforce regulatory safeguards. The fundamental change underway is that the machine-to-machine layer will be increasingly responsible for the mechanics of commerce, and the minutiae humans find tedious.

Agent-to-agent commerce isn’t just a niche tool or a standalone use case. It’s a new layer of interaction, one that could operate just beneath the surface of many existing business processes and revamp how enterprises negotiate, exchange services and produce revenue.

The infrastructure problem

None of this will be easy. Reconfiguring an economy centered around autonomous software agents presents colossal financial and technical challenges that conventional banking systems weren’t designed to navigate. Comprehending the difficulty ahead requires looking more closely at the basic mechanics of machine-to-machine interactions. For starters, software agents interacting in real time lack built-in trust capabilities. They need instant, verifiable financial settlement to validate that tasks have been finished before they can permit access to data or services. What’s more, the dollar amounts involved in these micro-payments are commonly too tiny to validate invoicing methods or standard payment processing workflows.

And therein lies the rub, and the infrastructure gap laid bare: Existing payment systems simply weren’t built for machine-speed, high-volume micro-transactions. Credit card networks, wire transfers and other traditional payment pathways depend on static batch processing, multi-day settlement windows and high fixed transaction fees. For instance, when an AI agent must make a $0.002 micro-payment to another agent to process a 1,000-token prompt, access a database or perform a targeted computation, waiting two business days for an ACH transfer or forking over a $0.30 credit card processing fee makes the whole interaction economically infeasible.

Of course, this infrastructure problem isn’t happening in a vacuum. Significant tech and digital finance players are working furtively to create machine-native transaction systems. Exhibit A: Fintech innovator Circle is crafting stablecoin payment systems that enable AI agents to send and receive funds in real time without human intervention needed. Exhibit B: Joint initiatives are being developed, like the agentic commerce protocols by Stripe and OpenAI. These and other examples prove that industry movers and shakers acknowledge that empowering machines to safely and instantly transact money represents the next crucial frontier for digital infrastructure.

Viewing Stripe’s acquisition of OpenRouter through this lens totally reframes the deal as not just a straightforward software purchase, but a major step in a multi-pronged infrastructure strategy. Think of OpenRouter as a central dispatch hub that oversees and directs scores of AI agent workloads throughout many different systems. It links developers to legions of AI models across numerous providers. And it carefully assesses every incoming request to pick the best model based on cost, speed and complexity of the task. Stripe, on the other hand, serves as the international financial backbone in this dynamic, providing stablecoin rails and the micro-payment wherewithal necessary for real-time monetary settlement.

Like two gigantic pipes that thread snugly together, Stripe and OpenRouter become the missing plumbing for agent-to-agent commerce. OpenRouter functions as the master control valve in this metaphor, directing where tasks go; Stripe then supplies the high-pressure financial flow that instantly settles the value exchanged.

It’s this synergistic dynamism that helps the estimated $7.5 billion price paid make sense. This isn’t merely an existing software business with a dependable revenue stream Stripe is absorbing; the new parent company is securing a controlling position at the precise historical inflection point where AI workloads pivot to autonomous commerce. Stripe is now strategically placed at the intersection of digital payment settlement and model orchestration. Consequently, as AI agents emerge as primary economic drivers, every token request and micro-transaction is routed through its combined plumbing.

What this could mean for insurance

All of which brings us back to my domain: the insurance industry, a space where transactions already include multiple parties, ultra-complex data structures and meticulous choices made across narrow organizational boundaries. Currently, manual underwriting, multi-step risk evaluations, document verification and legacy payment clearance are required to bind an insurance policy. But envision this paradigm in an agent-to-agent economy. Revisiting that RAV4 buyer, imagine their personal car-shopping AI agent verifying one available for purchase at a nearby dealer and then instantly contacting an insurance company’s autonomous agent. The latter examines the vehicle specs and driver history, performs underwriting computations, calculates a precise risk premium, validates data credentials, collects the premium using instant stablecoin or micro-payment rails and enacts the coverage mid-transaction – all with zero human assistance.

This is more than a hypothetical scenario. It’s an emerging reality, one that requires immediate attention from carriers and enterprise leaders. It means insurers must now develop algorithmic underwriting logic that a machine can apply and defend, construct verifiable data exchange systems that guarantee authenticity and data privacy during AI negotiations, and implement financial methods that can manage instant premium settlement 24/7. They must also begin planning for how their product gets represented, discovered, evaluated and transacted by someone else’s agent. Because the foundational infrastructure for this autonomous economy is no longer theoretical. Companies are already building the routing, identity, payment and commerce layers that could allow agents to become economic actors.

The ultimate question is not if or exactly when this machine-driven sea change will arrive. It’s what enterprises can do right now to ready their products and platforms to surf these waters successfully, catch the rising wave and ride it out with perfect poise.

Over 20-plus years in the enterprise trenches, I’ve watched multi-million-dollar technology transformations stumble over the same blind spot. We spend months debating cloud architectures, database benchmarks and vendor feature matrices. But the tech itself? That’s rarely where the real bleeding happens. The real pain arrives later, in the messy organizational wake:

• Who actually controls this system?
• What critical business function did we just accidentally outsource?
• How painful will it be to untangle ourselves when the vendor changes their licensing model?

Agentic AI is about to make those questions considerably more interesting. We have spent years worrying about application and vendor lock-in. The next form of lock-in may sit several layers deeper.

For most of my career, and arguably most of the history of computing, machines have waited for us. We gave the instructions, approved the transactions, made the decisions. Agentic AI is beginning to change that relationship. An agent can interpret an objective, break it into tasks, find the services it needs and execute those tasks with limited human intervention. The moment an agent can do more than recommend a purchase and can actually make one, it stops being a technology tool. It becomes an economic participant.

Few technology leaders are asking the question that follows — and by the time more of them do, the answer may already be decided: What financial infrastructure will these machines operate on, and who will control it?

The International Monetary Fund’s 2026 note on agentic AI and payments describes a shift from human-initiated transactions toward agent-mediated ones — from a “click-to-pay” model to a “decide-to-pay” model — with implications for authorization, settlement, liquidity, compliance and resilience. The IMF also highlights a fundamental tension between probabilistic AI behaviour and the deterministic requirements of payment infrastructure.

That caution is worth sitting with. If the institutions closest to global payments infrastructure are already examining how to preserve authorization, control and settlement finality as AI becomes more autonomous, that is itself a signal about how much is at stake in who builds and governs the rails.

Picture what this looks like inside an enterprise. A procurement agent instructed to reduce the cost of a service identifies several providers, checks their credentials and reputation, negotiates terms and initiates payment — with a human approving only the exceptions. A logistics agent dynamically buys transport capacity as demand shifts. A software agent discovers an API, uses it for a specific task and pays for the consumption without anyone visiting a payment page. None of this requires exotic technology. It requires identity, authority, trust, reputation, marketplaces, wallets and payment rails built to work with autonomous participants rather than humans clicking “confirm.”

In other words, the agentic economy will need its own economic infrastructure.

Money is becoming infrastructure

The petrodollar is the clearest historical parallel, and it’s worth being precise about the mechanism rather than just the label. In the early 1970s, as the dollar came off the gold standard, the US reached an understanding with Saudi Arabia, and by extension OPEC, that oil would continue to be priced and settled in dollars. Oil-exporting nations then recycled much of that revenue back into US Treasury securities and dollar-denominated assets. Nobody decided that oil needed a new currency invented for it. The currency that was already dominant simply became the substrate the world’s most strategic commodity traded on — and countries with no direct relationship to the US found their energy trade, and much of their national accounting, running through a currency they didn’t issue and couldn’t control.

The analogy to AI is imperfect but suggestive. If compute and intelligence become this century’s strategic commodities the way oil was for the last one, could the infrastructure through which autonomous machines exchange value become dominant in the same quiet way?

Pieces of this are already forming. The US has built a regulatory framework around dollar-backed payment stablecoins, and the US Treasury has explicitly linked implementation of the GENIUS Act to reinforcing the dollar’s role in digital finance. China has the digital yuan, Europe is progressing a digital euro and BRICS countries are exploring local-currency settlement and alternative rails. None of this makes an “AI dollar” inevitable, and these initiatives aren’t all competing for the same role. But they show money becoming part of the digital infrastructure itself, not just a thing that moves across it.

The Bank for International Settlements’ 2026 Annual Economic Report found that more than 99% of fiat-backed stablecoin supply remains dollar-pegged, even though stablecoin use in the real economy is still small next to traditional payment systems. That gap matters: The infrastructure is developing quickly, but the machine economy hasn’t been built on top of it yet. We’re unusually early — discussing the architecture before it becomes hard to change.

Two paths, and probably a third

There are broadly two ways this could evolve. The first extends today’s financial architecture into the machine economy: Agents get digital identities, wallets and delegated authority, but ultimately still operate through the banks, payment networks, financial institutions and technology platforms we already use, with an AI layer added on top. There’s nothing wrong with this. We already have institutions, regulation, compliance and dispute-resolution mechanisms built for handling money — reinventing all of that simply because the customer is now an AI agent would be wasteful.

The second, more interesting possibility is a more open economic layer built specifically for autonomous agents: Open marketplaces where agents discover services across providers, establish trust through portable identity and reputation, and transact using interoperable payment mechanisms. Trust doesn’t disappear in this model; it gets established through verifiable identity, reputation and programmable rules instead of a single central intermediary. I’m not suggesting everything should be decentralized, or that blockchain automatically solves this — financial transactions carry requirements around compliance, legal finality, fraud prevention and accountability that can’t simply be wished onto a distributed ledger.

The World Economic Forum’s work on AI agents and payments makes a similar point from the financial-services perspective: Traditional identity controls may no longer be sufficient when software is acting between the customer and the transaction. Understanding an agent’s intent, authority and context becomes part of establishing trust.

The fork that actually matters is this: Do we want autonomous agents to inherit the financial dependencies we’ve spent decades trying to untangle, or is this a chance to design something more open from the start?

It matters for enterprises specifically because we’ve lived this before. We’ve spent years reducing application and infrastructure vendor lock-in. Agentic AI could create a far broader dependency — not lock-in to a single application, but to an entire technology and economic ecosystem at once. This is what I’d call AI supply-chain sovereignty: Not owning every component of the stack but understanding the dependencies well enough to retain strategic choice. If your models, cloud infrastructure, agents, identity layer, marketplace and payment rails all sit inside one ecosystem, you may have built a sophisticated version of lock-in without ever naming it that.

In practice, the resolution is probably a hybrid rather than a clean win for either model: Regulated rails carrying legal finality, dispute resolution and compliance, with open protocols layered on top for discovery, portable identity and reputation. Picture agents shopping across an open marketplace for services, but settling and resolving disputes through accountable, licensed intermediaries’ underneath. That blend is the more likely third path — and probably the one enterprises should be designing toward now, rather than betting everything on either pure extreme.

What this means in practice

A few things follow from this for technology leaders. Make model and infrastructure portability an architectural principle, not an afterthought. Understand where private infrastructure and open-weight models can sit alongside commercial frontier models, and design agent architectures capable of talking to multiple services rather than being permanently wired to one marketplace.

This is increasingly consistent with how McKinsey describes the infrastructure shift required for agentic AI: Modularity, composability, decoupling and vendor flexibility become important as agents interact across systems, tools and transactional environments. For technology leaders, that is not simply an infrastructure concern. It is an argument for preserving optionality in the broader AI stack.

Rethink what an agent wallet actually is. The important concept isn’t cryptocurrency — it’s delegated financial authority. An enterprise agent needs something like identity and access management for money: Who is this agent, what is it authorized to purchase, how much can it spend, which counterparties can it use and when does a transaction escalate to a human?

Recognize that payments are no longer purely finance’s problem. For years, technology has treated payments as something that sits on the other side of the org chart: Finance decides how money moves, and technology integrates whatever’s required. Once a machine can decide and execute a transaction in the same motion, the payment mechanism becomes part of the technology architecture itself.

Finally, add the economic layer to your AI architecture diagram. We already map data, applications, models, cloud and cybersecurity. It’s time to also map where identity, reputation, marketplaces, payment rails and currencies sit in that chain — and what happens to the business if any one of them becomes unavailable. That’s the practical meaning of sovereignty here: Not owning everything but making sure no single component can switch off the intelligence the business depends on.

The choices we make now

The larger question is still open. We could reproduce today’s financial architecture for machines, with agents operating inside increasingly sophisticated ecosystems controlled by governments, financial institutions and platforms. Or we could deliberately build more open, interoperable economic infrastructure where agents discover services and establish trust across organizational and technological boundaries. The real outcome will likely be messier than either — regulation and trusted institutions aren’t going away, even as open protocols increasingly provide the connective tissue between autonomous participants. What matters is that we still have some influence over that balance.

The petrodollar wasn’t created because someone decided oil needed a new currency; it emerged from the interaction of a strategic commodity, global trade, financial markets and geopolitics. The agentic economy may develop the same way, with compute and intelligence generating the economic value and new financial infrastructure determining how that value moves.

For technology leaders, the question may end up being bigger than who builds the smartest AI. It may be who controls the economic infrastructure through which autonomous intelligence participates in the economy — and whether we make that infrastructure open enough that no single company, platform or jurisdiction becomes indispensable.

Every service in your payment stack can pass its own readiness test in isolation, and checkout can still go down at peak. The problem usually isn’t a failed service. It’s the shared capacity they all draw against at once.

I’ve sat in more than one Black Friday readiness review that looked like this. Authorization load tested to twice projected peak volume. The fraud engine stress-tested separately, scored well, signed off on its own. Settlement with a documented failover plan. Every team walks out of that room with a green checkmark next to their system, and every checkmark is earned. Nobody cut corners.

And more than once, I’ve watched checkout fail anyway once the real traffic hit. Authorization was healthy. Fraud was healthy. Settlement was healthy. The checkout experience wasn’t. Every dashboard the incident channel pulled up looked fine in isolation, the same kind of silent failure I’ve seen play out in other production systems, just showing up here in payments instead. It’s exactly what made the incident hard to diagnose in real time.

The assumption underneath every one of those readiness reviews is one I held myself for a long time: that system readiness is the sum of component readiness. If authorization passes, and fraud passes, and settlement passes, the payment platform is ready. It’s a reasonable assumption, and it’s incomplete in a specific, testable way. A system can be individually ready and collectively unready. Proving that every component survives the load is not the same as proving the transaction survives when every component is under pressure and reacting to the others.

Why passing every individual test still leaves you exposed

Most organizations already do the conventional peak-season work well: load testing, capacity planning, failover exercises. That work matters, and it isn’t the gap. The blind spot sits one layer below it, in what happens when those individually healthy systems interact under the same stress. When it shows up, it isn’t a testing-effort problem. It’s a testing-design problem. Authorization has an owner and a test plan. Fraud has an owner and a test plan. Settlement has an owner and a test plan. None of those plans include the other two teams’ behavior as a variable, because none of them was ever asked to.

Fraud scoring tightens automatically under a velocity spike. That’s correct behavior, not a bug. The problem isn’t that the control responds incorrectly. It’s that it responds correctly to one signal while the rest of the payment stack is already under pressure from something else, at the exact hour authorization is carrying its heaviest load. The CIO question isn’t whether each control works. It’s whether the controls work together under the same stress conditions, and in my experience, that shared surface is rarely mapped explicitly before peak season starts.

Every system in a payment stack draws on the same underlying resilience: shared connection pools, shared databases, the capacity to absorb retries and rerouted traffic without breaching a commitment. I think of it as a resilience budget, a concept I’ve used before to explain why systems quietly run out of capacity nobody is tracking. Every dependency, every retry, every automated response spends some of it. The mistake isn’t in how any one team measures their own balance. It’s that nobody measures what the whole transaction path has left once every system is drawing on it at once. That’s the same lens I’ve applied to rethinking what enterprises should measure in production systems more broadly, and it holds just as well here: resilience is something continuously spent, not a line you hope not to cross.

The stakes are real. One UK study from FreedomPay, Dynatrace and Retail Economics estimated payment outages cost retailers and hospitality businesses £1.6 billion a year, with businesses averaging more than five major outages annually, most of them during peak trading windows, exactly when a per-system test said everything would hold.

Three questions worth asking before your next peak event

If testing each system in isolation isn’t enough, these are the three questions I’d bring into a readiness review instead of “did each system pass?”

What capacity is shared across systems your organization treats as independent? Authorization, fraud, and settlement typically share infrastructure somewhere: a connection pool, a shared database, a common upstream service, even when the teams that own them think of them as unrelated. A test that clears each system at 70% utilization of its own resources can still fail if all three are quietly drawing from the same 70% of a shared resource at the same time.

What does each system automatically do when another one slows down? This is the one worth sitting with, because the most dangerous component in a distributed system isn’t always the one that fails. Sometimes it’s the one that responds correctly to stress without knowing what the rest of the system is already experiencing. A fraud engine tightening under velocity, an autoscaler reacting to load, a remediation script firing on its own local view- each one can do exactly what it was built to do and still be the reason checkout goes down, because none of them knows what capacity everything else is already spending.

What happens in the minutes after recovery starts, not just during the failure itself. A retry storm after a slowdown can do more damage than the slowdown itself. Most readiness reviews test whether a system survives peak load. Far fewer test what it does in the ninety seconds after it starts to recover, when queued requests, retries and backlogged traffic all arrive together. That’s usually where the real cascade happens, and it’s almost never in the test plan.

The test I’d actually demand before the next peak event

None of this requires new infrastructure. It requires running one test that, in my experience, almost no organization runs on its own: a synthetic peak load against authorization, with the fraud engine’s tightening threshold deliberately triggered at the same time, the way a real velocity spike would. Watch what happens to authorization latency under that combined load, not in isolation. It’s the same discipline behind the intent-based testing work my patent grew out of: define what correct behavior looks like, then deliberately create the conditions that test whether it holds. If that test hasn’t happened on purpose, in a controlled window, the real event will run it for you, and it won’t ask permission first. That’s the gap sitting in most readiness plans right now, and it’s a gap in ownership as much as testing.

Someone needs to be accountable for checkout as a single business-critical transaction path, not for authorization, or fraud, or settlement individually. For many organizations, that person doesn’t exist yet, because resilience budgets don’t show up on any one team’s dashboard. Building that ownership is closer to how error budgets and SLOs already work inside most engineering organizations than to anything new: extend the same discipline across systems instead of stopping at their boundaries. The payment platforms that survive peak events aren’t necessarily the ones whose individual systems are strongest. They’re the ones whose leadership stopped asking whether each piece is individually ready and started asking whether the whole transaction is. They know how much resilience the transaction path has left, and what happens to revenue and customer trust when every component starts spending it at once. That’s not a readiness checkbox. It’s a different question. And until someone owns it, a room full of green checkmarks can still hide a red checkout button.