For more than thirty years, we’ve built online commerce around one simple assumption: the customer is human.
Humans browse websites. They compare products, read reviews, add items to a shopping cart, and eventually click a Buy button. Every ecommerce platform, analytics dashboard, checkout optimisation experiment, and conversion funnel is built around that interaction. The user interface isn’t just part of commerce, it is commerce. Now imagine asking an AI assistant:
“Book somewhere nice for dinner tomorrow night. Invite Sarah and James. Keep it under £150.”
You don’t expect a browser window to open. You don’t expect to compare restaurant websites yourself, fill out reservation forms, or type your card details into a checkout page. You simply expect the task to be completed. To do that, the AI has to discover restaurants, compare menus and reviews, check availability, make a reservation, coordinate calendars, and pay any required deposit. At no point does a human click a Buy button - the software does.
That seemingly small change has surprisingly large implications. If software is becoming the customer, then almost every assumption we’ve made about online commerce starts to look outdated.
This isn’t the first time computing has experienced a transition like this. We moved from command lines to graphical interfaces, from desktop applications to the web, from web pages to mobile apps, and from manual workflows to APIs. Every transition made software more programmable and less dependent on direct human interaction. Commerce is following the same trajectory.
Thinking isn’t enough
Much of the excitement around AI has focused on large language models, but an LLM alone doesn’t accomplish very much. It can answer questions and generate text, but it can’t complete real-world tasks without interacting with external systems. Modern AI agents work because they repeatedly execute a surprisingly simple loop. They reason about the current situation, decide what information or action is needed next, call a tool, observe the result, and then reason again. They continue iterating until the original goal has been achieved. Buying something isn’t a separate activity. It’s simply another step inside that reasoning loop.
Once you see it that way, the traditional checkout experience starts to look surprisingly strange. Humans need buttons because we interact through visual interfaces. Agents don’t. They interact through structured data and APIs. Asking an AI agent to navigate thousands of different websites is rather like asking a web browser to learn a different version of HTTP for every website it visits. Humans can tolerate inconsistency, software cannot.
The Railway Problem
During the nineteenth century, railway companies had an unexpected problem. Different companies built tracks to different gauges. A train could travel perfectly well until it reached the boundary of another network, where passengers and cargo had to stop, unload, and transfer onto another train built to a different standard. The trains weren’t broken. The tracks weren’t broken. The problem was that nobody had agreed on the rails.
Today’s commerce ecosystem has the same issue.
Every merchant has a different product catalogue, different APIs, different checkout flow, different authentication model, and different assumptions about how purchases should happen. Humans cope because we’re remarkably adaptable. AI agents don’t. Every new merchant effectively becomes another bespoke integration.
The railway industry eventually discovered that building better trains wasn’t the answer. The problem was the tracks. In Britain, years of incompatible railway gauges created delays, inefficiencies, and costly transfers until the Regulation of Gauge Act of 1846 established a standard gauge for new railways. It took decades for the network to fully converge, but once it did, trains could move freely across the country instead of stopping at every boundary. Commerce is approaching a similar moment. The obvious solution isn’t to build smarter agents that understand thousands of bespoke storefronts. It’s to agree on the rails they all run on.
Commerce Needs a Common Language
We’ve solved this problem before. Browsers don’t understand every website individually; they understand HTTP. Email clients don’t integrate separately with every mail provider; they speak SMTP. Open protocols allow independently built systems to communicate without prior knowledge of one another.
Commerce needs the same abstraction. Rather than forcing every AI agent to understand every merchant, merchants can expose machine-readable commerce capabilities through a common protocol. Instead of scraping HTML pages, agents can search structured catalogues, compare products, retrieve pricing and availability, and initiate purchases using a shared language. Build once. Use everywhere.
That’s the promise of the Universal Commerce Protocol (UCP). Instead of designing commerce exclusively for humans, it provides a standard way for software to discover and transact with other software.
Discovering Products is Only Half the Story
Finding something to buy is relatively easy. Paying for it safely is much harder.
Simply handing an AI your credit card details is unlikely to become an acceptable security model. Instead, agents need delegated authority. A user might allow an agent to spend up to £100, only with approved merchants, only for restaurant reservations, and only before Friday evening. The important distinction is that the agent receives permission, not ownership.
Shared Payment Tokens represent one approach to making that possible, allowing users to delegate narrowly scoped payment authority without exposing the underlying payment credentials. Rather than sharing a card number, users share intent and limits. Trust becomes programmable.
A Status Code Waiting for its Big Moment
Interestingly, the web anticipated this future long before AI agents existed. Buried in the HTTP specification is a response code almost nobody has ever encountered in the real world: 402 Payment Required.
Unlike familiar responses such as 200 OK or 404 Not Found, HTTP 402 has remained largely unused for decades. It was reserved for a future where software might need to negotiate payment automatically. That future never really arrived. Browsers became the dominant interface. Humans stayed firmly in the purchasing loop. When payment was required, the answer wasn’t another protocol, it was another webpage. For years, HTTP 402 felt like an unfinished sentence. AI agents may finally provide its ending.
When software is communicating directly with software, a machine-readable payment negotiation suddenly makes far more sense than redirecting to a checkout page designed for human eyes.
Buying Capabilities Instead of Products
Today, we mostly imagine AI agents buying products for people. That’s still human commerce with a different interface. Machine Payment Protocol (MPP) hints at something much bigger.
Imagine an autonomous software engineering agent writing an application. Halfway through its task it realises it needs access to a premium security scanner. It purchases access for ten minutes. Later it rents GPU capacity to run a model, subscribes to a proprietary API for a single request, purchases access to an identity verification service, and pays for translation capabilities so it can process documentation written in another language. None of those purchases is the goal. They’re simply capabilities the agent acquires while solving the problem it was given. Humans buy products to complete tasks. Agents buy capabilities to continue reasoning. That’s a fundamentally different model of commerce. Payment stops being the destination of the user journey and instead becomes another tool inside the reasoning loop.
The Next Platform Shift
Every major computing platform eventually becomes programmable. We no longer automate button clicks when an API exists. We no longer scrape web pages when structured interfaces are available. Commerce is beginning the same transition.
The Buy button isn’t disappearing. Humans will continue browsing websites, comparing products, and clicking checkout for many years to come. But increasingly, they won’t be your only customer.
The next generation of customers won’t care how beautiful your product page is. They’ll care whether they can discover your catalogue programmatically, understand your pricing, negotiate permissions, and complete transactions safely through standard protocols.
For developers, that changes the questions we should be asking:
- Is my product discoverable by an agent?
- Can software understand my catalogue without scraping HTML?
- Have I designed my APIs for autonomous clients as well as human-operated front ends?
- What does my checkout look like when nobody ever sees it?
Those questions are no longer theoretical. AI agents are rapidly becoming another class of software client, alongside browsers, mobile apps, and backend services. The interface isn’t disappearing, it’s simply moving. Your next customer won’t click your checkout.
It’ll call it.