On January 11, 2026, at the National Retail Federation conference in New York, Google announced something that most of the audience probably interpreted as another platform play. Another API. Another standard. Another attempt by a technology giant to insert itself deeper into the commerce stack. What Google actually announced was something far more consequential: the first open standard that gives autonomous agents a common language for commerce. The Universal Commerce Protocol - UCP - is not a product. It is not a feature. It is infrastructure. And infrastructure, as every designer knows, is the thing that determines what can be built on top of it.
For those of us who have spent the past eighteen months building the conceptual architecture of Agentic Experience Design, UCP represents a pivotal moment. Not because it solves the design problems we have been articulating - it does not - but because it creates the conditions under which those design problems become urgent, practical, and unavoidable. UCP is the plumbing that makes agentic commerce real at scale. And when the plumbing works, the architecture must be ready.
This essay examines what UCP is, what it means for the discipline of agentic experience design, and - critically - what it does not solve. Because the gap between what UCP enables and what it leaves unaddressed is precisely the space where AXD must operate.
The Integration Problem
To understand why UCP matters, you must first understand the problem it solves. Today's commerce infrastructure was built for a world in which humans navigate websites. Every retailer, every marketplace, every payment provider has its own interface, its own checkout flow, its own way of describing products, its own API conventions. When a human shops, this fragmentation is merely annoying - you re-enter your address, you re-type your card number, you navigate yet another checkout flow that looks slightly different from the last one.
When an autonomous agent shops, this fragmentation is fatal. An agent cannot "navigate" a checkout flow designed for human eyes. It cannot interpret the idiosyncratic layout of a product page. It cannot guess that one retailer calls a field "shipping address" while another calls it "delivery destination" while a third splits it across five separate inputs. The N-by-N integration problem - where every agent must build a custom integration with every merchant - makes agentic shopping economically unviable at scale.
This is not a new problem in computing. It is, in fact, one of the oldest problems in computing. And the solution is always the same: a protocol. HTTP solved it for documents. SMTP solved it for email. OAuth solved it for authentication. Every time a new category of machine-to-machine interaction emerges, someone must define the common language. UCP is the attempt to define the common language for commerce in the age of agentic AI.
"Every time a new category of machine-to-machine interaction emerges, someone must define the common language. UCP is the attempt to define that language for commerce."
What UCP Actually Is
The Universal Commerce Protocol is an open-source specification that standardises how AI agents interact with merchants across the entire shopping journey. It was co-developed by Google with Shopify, and endorsed by over twenty global partners including Etsy, Wayfair, Target, Walmart, Best Buy, Klarna, Stripe, Visa, Mastercard, American Express, Adyen, and Salesforce. It is available on GitHub as an open-source specification, and it is compatible with the three major agent communication protocols: Agent-to-Agent (A2A), Agent Payments Protocol (AP2), and Model Context Protocol (MCP). The AXD Institute's Protocol Tracker monitors UCP alongside seven other active agentic commerce protocols.
At its core, UCP works through a simple but powerful mechanism: a merchant publishes a manifest. This manifest is a structured, machine-readable declaration of everything the merchant offers and everything the merchant requires. What products are available. What the pricing rules are. What inventory levels look like. How checkout works. What payment methods are accepted. What delivery constraints apply. What promotions are active. What loyalty programmes exist. What regulations govern the transaction.
Any compliant agent can read this manifest and act on it. The agent does not need a custom integration with the merchant. It does not need to scrape a website. It does not need to reverse-engineer an API. It reads the manifest, understands the merchant's capabilities and constraints, and proceeds to transact. The protocol covers the entire commerce lifecycle: product discovery, cart creation, checkout, payment processing, order management, and post-purchase support.
By February 2026, UCP was already live in production. US shoppers could purchase items from Etsy and Wayfair through Google's AI Mode in Search and through Gemini, using Google Wallet for payment. The checkout happened entirely within the AI interface - no redirect to a merchant website, no separate checkout flow, no friction. The merchant remained the seller of record. The customer never left the conversation.
The Architecture of a Common Language
UCP's architecture reveals several design decisions that are worth examining from an AXD perspective. First, the protocol is capability-based. Rather than defining a rigid sequence of steps, UCP defines a set of capabilities that a merchant can expose: discovery, cart management, checkout rules, promotions, loyalty, delivery constraints, and regulatory compliance. An agent discovers what a merchant can do and adapts its behaviour accordingly. This is a fundamentally different design philosophy from traditional e-commerce APIs, which typically impose a fixed workflow.
Second, UCP separates payment instruments from payment handlers. This means a customer's payment method (a credit card stored in Google Wallet, for example) is decoupled from the payment service provider that processes the transaction. The agent can carry the customer's payment preferences across merchants without requiring each merchant to support the same payment processor. This separation is architecturally elegant and commercially significant - it removes one of the largest sources of checkout friction in cross-merchant agentic shopping.
Third, UCP is extensible. Merchants can create custom extensions to the protocol to support capabilities that the base specification does not cover. This is critical for industries with specialised requirements - pharmaceutical regulations, age-restricted products, bespoke manufacturing, subscription models - that cannot be anticipated by a universal standard.
Fourth, and perhaps most importantly for the AXD community, UCP defines what happens when automation fails. The protocol includes explicit provisions for fallback scenarios - moments when the agent cannot complete a transaction autonomously and must either escalate to a human or gracefully degrade. This is, in AXD terms, a recognition that absent-state design must always include a path back to presence. The protocol does not merely enable autonomous action; it acknowledges the limits of autonomous action.
Discovery in the Age of Agents
The most profound implication of UCP is not about checkout. It is about discovery. For decades, commerce has been shaped by whoever controls the moment of choice. In the twentieth century, it was the supermarket shelf. In the early internet era, it was the search engine results page. In the marketplace era, it was the Amazon product grid. Each shift in the locus of discovery redistributed billions of dollars of economic value.
UCP shifts discovery to the agent. When a human says "buy me running shoes under £120 that work for overpronation," the agent - not a search engine, not a marketplace, not an advertising platform - decides which merchants to query, which products to surface, and which option to recommend. The merchant's visibility depends not on SEO rankings, not on advertising spend, not on marketplace placement, but on whether the agent can read its manifest, trust its data, and successfully complete a transaction.
This is what we described in the Signal Clarity essay: the shift from human-readable to machine-readable commerce. UCP operationalises that shift - and the AXD Institute's guide to machine-readable commerce provides practical implementation guidance. A merchant that publishes a comprehensive, accurate, well-structured UCP manifest becomes discoverable to every compliant agent in the ecosystem. A merchant that does not becomes invisible. Not gradually invisible, the way a poorly optimised website slowly loses search rankings. Instantly invisible. Binary. The agent either reads your manifest or it does not. You are either in the agentic economy or you are not. This is the infrastructure of zero-click commerce - and the operating environment for AI shopping agents.
"The agent either reads your manifest or it does not. You are either in the agentic economy or you are not."
This has direct implications for the Four Pillars of AXD Readiness framework. The first pillar - Structured Data & Machine-Readable Identity - is precisely what UCP demands. The businesses that have already invested in comprehensive structured data, real-time inventory APIs, and parametric product descriptions are the businesses that will be ready for UCP. The agentic dividend we described - the bonus return on investments made for human-facing commerce that also serve autonomous agents - is now arriving faster than anyone anticipated.
The Checkout That Disappears
UCP's checkout model represents a fundamental break with twenty-five years of e-commerce design. In the traditional model, checkout is a designed experience - a sequence of screens that guide the customer through address entry, shipping selection, payment, and confirmation. Entire careers have been built on optimising these flows. A/B testing button colours. Reducing form fields. Minimising cart abandonment. The checkout funnel is the most measured, most optimised, most obsessed-over artifact in digital commerce.
UCP makes the checkout funnel irrelevant. When a transaction happens inside an AI conversation - the customer says "buy it," the agent reads the merchant's UCP manifest, applies the customer's stored payment and shipping preferences from Google Wallet, and completes the purchase - there is no funnel. There are no screens. There is no cart abandonment because there is no cart. There is no checkout flow because there is no checkout page. The entire transaction collapses into a single conversational moment.
For AXD practitioners, this is not merely a change in interface design. It is a change in the locus of trust. In traditional e-commerce, the customer trusts the merchant's checkout page - the padlock icon, the familiar payment logos, the SSL certificate. In UCP-powered agentic commerce, the customer trusts the agent. The customer trusts that the agent has correctly interpreted their intent, selected an appropriate merchant, verified the product meets their requirements, applied the best available price, and executed the payment securely. The merchant's brand, the merchant's website, the merchant's checkout experience - all of these trust signals become secondary to the customer's trust in the agent.
This is the shift from trust architecture as a merchant-customer relationship to trust architecture as a principal-agent relationship. And it is the shift that makes every concept in the AXD vocabulary - delegation architecture, trust calibration, operational envelope, consent architecture - not theoretical constructs but practical design requirements.
Amazon's Absence and What It Signals
The list of UCP partners reads like a who's who of global commerce: Shopify, Walmart, Target, Etsy, Wayfair, Best Buy, Visa, Mastercard, Stripe, Klarna, Salesforce. One name is conspicuously absent: Amazon. This absence is not accidental, and it tells us something important about the structural dynamics of the shift to agentic commerce.
Amazon's entire business model is built on controlling the moment of discovery. Product grids, sponsored placements, algorithmic rankings, the Buy Box - these are the mechanisms through which Amazon extracts value from the commerce ecosystem. An open protocol that allows any agent to discover, compare, and transact with any merchant - bypassing Amazon's discovery infrastructure entirely - threatens the foundation of Amazon's commercial leverage.
UCP makes discovery portable. It detaches the act of finding a product from the platform on which the product is listed. When an agent can query every UCP-compliant merchant simultaneously, the marketplace that once aggregated demand becomes just another merchant behind a protocol. Amazon's competitive moat - the fact that customers start their product searches on Amazon - evaporates when the customer's agent searches everywhere at once.
From an AXD perspective, Amazon's absence from UCP illustrates a broader principle: the shift to agentic commerce redistributes power from platforms that control attention to protocols that enable action. This is the same dynamic we explored in the Invisible Layer essay - the most consequential commerce will happen in a layer that no traditional platform controls. UCP is the infrastructure of that layer. And the platforms that resist it are the platforms that have the most to lose from the shift.
UCP Through the AXD Lens
When we examine UCP through the frameworks of Agentic Experience Design, several critical intersections emerge. Each of the twelve AXD frameworks illuminates a different dimension of what UCP enables - and what it leaves unresolved.
Intent Architecture. UCP assumes that the agent arrives at a merchant with a well-formed intent. But intent architecture - the design of how humans express, refine, and constrain their intentions - is entirely outside UCP's scope. The protocol handles what happens after the agent knows what the human wants. The design of how the agent comes to know what the human wants remains an AXD problem. When a customer says "get me something nice for dinner," the cascade from vague desire to specific product query is an intent architecture challenge that UCP cannot address.
Delegation Design. UCP enables the execution of delegated authority - the agent can transact on the customer's behalf. But the design of the delegation itself - what the customer has authorised, under what constraints, with what spending limits, for what categories of purchase - is not defined by UCP. The protocol assumes that the agent has been properly delegated. Whether that delegation was well-designed is an AXD question.
Trust Calibration. UCP creates a new trust surface: the customer must trust that the agent will use UCP responsibly - selecting appropriate merchants, verifying product quality, not being manipulated by merchant incentives. How that trust is calibrated over time, how it increases with successful transactions and decreases with failures, how the customer's operational envelope for the agent expands or contracts - these are trust calibration problems that UCP's existence makes urgent.
Failure Architecture. UCP includes provisions for fallback scenarios, which is commendable. But the design of how failures are communicated to the customer, how the agent recovers from a failed transaction, how trust is preserved when a UCP-mediated purchase goes wrong - these are failure architecture challenges. The protocol defines the technical fallback. AXD must design the experiential recovery.
Agent Observability. When a transaction happens inside an AI conversation via UCP, the customer loses visibility into the decision-making process. Which merchants did the agent consider? Why was this product selected over alternatives? Was the price the best available? Were there trade-offs the agent made without consulting the customer? Agent observability - the design of how an agent's reasoning is made legible - becomes essential in a UCP world where the entire commerce journey is mediated by an autonomous system.
The Trust Architecture of Open Protocols
UCP is described as an open standard, and this openness is frequently cited as its primary virtue. But openness in protocol design creates its own trust architecture challenges. An open protocol means that any agent can interact with any merchant. This is powerful for interoperability but creates questions about trust that the protocol itself does not answer.
How does a merchant know that an agent is acting on behalf of a legitimate customer? How does a customer know that the agent has not been compromised or manipulated? How does the ecosystem prevent malicious agents from exploiting UCP to execute fraudulent transactions? These are not hypothetical concerns - they are the same concerns that have plagued every open protocol in computing history, from email (spam) to HTTP (phishing) to OAuth (token theft).
This is where Know Your Agent (KYA) becomes operationally critical. In a UCP world, merchants need a framework for evaluating the agents that arrive at their manifests. Is this agent authorised? Is it operating within its delegated authority? Does it have a track record of legitimate transactions? The four pillars of KYA - Identity, Authority, Capability, and History - provide exactly this framework. UCP creates the channel through which agents transact. KYA provides the trust evaluation that determines whether a specific agent should be allowed to transact.
Similarly, Agentic Entity Resolution becomes essential infrastructure in a UCP ecosystem. When an agent queries multiple merchants via UCP, it encounters product data, merchant identities, and customer records across disparate systems. Determining that "Nike Air Zoom Pegasus 41" on one merchant's manifest is the same product as "Nike Pegasus 41 Running Shoe" on another's - and that both are different from a counterfeit listing using similar nomenclature - is an entity resolution challenge. Without reliable entity resolution, UCP's promise of cross-merchant comparison and optimal selection cannot be fulfilled.
What UCP Does Not Solve
It is important to be precise about UCP's scope, because the gap between what UCP enables and what it leaves unaddressed is precisely the territory of Agentic Experience Design. UCP solves the integration problem - it gives agents a common language for commerce. But it does not solve the design problem - it does not address how the human experience of agent-mediated commerce should be designed.
UCP does not solve the consent problem. When a customer tells an agent to "buy groceries like last week," what has the customer consented to? Has the customer consented to the agent selecting a different supermarket if the usual one is out of stock? Has the customer consented to substitutions? Has the customer consented to the agent spending more than last week's total if prices have increased? The consent horizon - the boundary of what the customer has actually authorised - is a design problem that UCP does not address.
UCP does not solve the monetisation problem. When discovery moves inside the agent, traditional advertising models collapse. There are no banner ads in a conversation. There are no sponsored search results when the agent queries merchants directly via their manifests. The question of how merchants pay for visibility in an agent-mediated world - and the ethical implications of agents that can be influenced by merchant payments - is a profound challenge that UCP's architecture does not resolve. It is, in fact, a challenge that UCP's architecture may exacerbate, by creating a new surface for commercial influence that is invisible to the customer.
UCP does not solve the accountability problem. When a UCP-mediated transaction goes wrong - the product is defective, the delivery is late, the price was incorrect - who is accountable? The merchant, who published the manifest? The agent, who selected the merchant and executed the transaction? The protocol, which facilitated the interaction? The platform (Google), which hosts the agent? Traditional consumer protection frameworks assume a bilateral relationship between buyer and seller. UCP introduces a multilateral relationship - buyer, agent, protocol, platform, merchant, payment provider - that existing legal and regulatory frameworks are not equipped to govern.
"UCP solves the integration problem. It does not solve the design problem. The gap between what UCP enables and what it leaves unaddressed is precisely the territory of Agentic Experience Design."
UCP does not solve the equity problem. An open protocol is only as open as the resources required to implement it. Large retailers with engineering teams and existing API infrastructure can publish UCP manifests quickly. Small businesses, independent artisans, local shops - the merchants who already struggle with digital commerce - face a new barrier to entry. If the agentic economy is built on UCP, and UCP implementation requires technical sophistication, then UCP risks creating a new digital divide between merchants who can be discovered by agents and merchants who cannot. The AXD Readiness framework must account for this equity dimension.
Google's Universal Commerce: Implications for Practitioners
UCP's arrival accelerates the timeline for every concept in the AXD vocabulary. What was theoretical eighteen months ago is now operational. The design implications are immediate and practical.
Design for manifest quality, not page quality. The merchant's UCP manifest is now the primary artifact of commerce design. Its completeness, accuracy, and richness determine whether agents can discover, evaluate, and transact with the merchant. AXD practitioners working with retail clients must shift their focus from optimising human-facing pages to optimising machine-readable manifests. This is not a technical task - it is a design task. What information does an agent need to make a confident purchasing decision on behalf of a customer? How should product attributes be structured to enable meaningful cross-merchant comparison? What trust signals should the manifest include?
Design for agent trust, not customer trust. In a UCP world, the merchant's primary "customer" is increasingly the agent, not the human. The agent evaluates the merchant's reliability, data quality, fulfilment track record, and return policies. The agent decides whether to recommend the merchant to the human. Merchants must design for agent trust - providing verifiable credentials, transparent policies, and consistent data quality - as much as they design for human trust. The Trust Triangle now has a new vertex: the agent that mediates between principal and merchant.
Design for graceful degradation. UCP includes fallback provisions, but the experience of those fallbacks must be designed. When an agent cannot complete a UCP transaction - because the merchant's manifest is incomplete, because the payment method is unsupported, because the product is out of stock - the transition from autonomous action to human involvement must be seamless. This is Failure Architecture in practice: designing the moment when the invisible becomes visible, when the absent human must become present.
Design for observability in invisible transactions. When a customer buys something through a UCP-mediated agent interaction, the entire commerce journey - discovery, comparison, selection, checkout, payment - happens without the customer seeing any of it. The customer sees only the result: "I've purchased the Nike Pegasus 41 from Retailer X for £109.99, arriving Thursday." But the customer may want to know: why this retailer? Why this price? Were there alternatives? What trade-offs were made? Agent Observability must be designed into UCP-powered experiences - not as a technical log, but as a comprehensible narrative of the agent's reasoning.
Design for the new metrics. Clicks, sessions, conversion rates, cart abandonment - the metrics that have governed e-commerce for two decades - lose meaning in a UCP world. New metrics must be designed: agent selection rate (how often agents choose your merchant), intent satisfaction (how well your products match agent queries), transactional reliability (how often UCP transactions complete successfully), and manifest quality score (how complete and accurate your UCP manifest is). AXD practitioners must help organisations transition from human-centric to agent-centric measurement.
The Universal Commerce Protocol is not the end of a story. It is the beginning of one. It is the infrastructure that makes agentic commerce technically possible at scale. But technical possibility is not the same as good design. The history of the internet is littered with protocols that enabled new capabilities without adequate thought for the human experience of those capabilities. HTTP enabled the web but did not prevent dark patterns. SMTP enabled email but did not prevent spam. OAuth enabled federated authentication but did not prevent consent fatigue. UCP will enable agentic shopping. Whether that shopping experience is trustworthy, transparent, equitable, and well-designed is not a protocol question. It is a design question. It is an AXD question. And it is the question that the next chapter of this discipline must answer.