UCP Explained: Architecture, Payments, and Agentic Commerce

Why Google’s Universal Commerce Protocol Matters for Agentic Commerce

What if the next disruption in commerce didn’t come from a faster checkout button or a more intuitive UI, but from a new way machines talk to machines about buying things? That’s the premise behind the Universal Commerce Protocol (UCP), a nascent open standard driven by Google and its ecosystem partners, which seeks to redefine digital commerce for an AI-first world.

UCP aims to replace the thread of custom interfaces of the online retail system. It produces a set of machine-readable capabilities, from discovery and pricing to checkout, that any autonomous agent can invoke with predictable outcomes. For CTOs and founders building the next generation of commerce platforms or AI services, UCP isn’t just another spec to skim. It’s an inflection point that could change the way that products are discovered and purchased.

AI helping customers to shop is not new. We already ask tools like Gemini or ChatGPT questions such as “Which phone should I buy?” or “Is this laptop worth the price?” But even today, AI mostly stops at advice. Once a decision is made, we still have to do the buying. That gap between deciding and doing is exactly what the Universal Commerce Protocol is trying to fix.

What is Universal Commerce Protocol?

UCP is an open protocol designed to let AI shopping agents move beyond recommendations and actually complete commerce tasks, introduced by Google and a growing set of ecosystem partners. Instead of sending users to product pages or checkout flows, agents can discover what a merchant supports, negotiate terms, and invoke a transaction directly. All of this happens through a standardized, machine-readable interface.

Most commerce systems today are built for people: pages to browse, forms to fill, buttons to click. UCP assumes a different actor entirely. It treats software agents as first-class participants in commerce, with clearly defined capabilities, security boundaries, and payment authorisation and consent flows. For tech leaders, this signals a move away from UI-driven commerce toward protocol-driven infrastructure.

The implications are practical, not theoretical. As AI agents become more capable, businesses that expose their products and systems in ways machines can reliably understand will be easier to discover, easier to transact, and easier to integrate. UCP is Google’s attempt to define that common language early, before every platform makes its own version.

In the sections that follow, we’ll look at how UCP works under the hood, how it differs from existing approaches, and what CTOs and founders should consider if they’re building commerce systems meant to survive an agent-driven future.

Agentic Commerce: Why Google Needs a Standard Way to Buy

Launched by Google at the National Retail Federation’s annual conference in New York, UCP is an open, standardized commerce protocol that defines a common language for AI agents and commerce systems to work together. The immediate use case is practical: UCP will power a new checkout experience that allows consumers to buy products directly through Google’s AI Mode in the browser and in the Gemini app.

The Limits of Today’s E-commerce Architecture

Modern e-commerce systems were built for human interaction. They rely on pages, forms, and flows that assume a person is clicking through each step. For AI agents, this creates friction. Every retailer exposes inventory, pricing, checkout, and fulfillment differently, forcing platforms to build one-off integrations at scale. This results in what engineers often describe as an N×N integration problem. As AI surfaces proliferate, that model doesn’t scale and fragments the customer experience across channels.

Agentic Commerce Changes the Buyer Model

Agentic commerce assumes a different buyer altogether. Instead of browsing pages, AI agents evaluate constraints, verify availability, apply discounts, and execute purchases programmatically on behalf of users.

That shift breaks many assumptions embedded in existing commerce stacks, especially those tied to UI-driven flows rather than system-level capabilities. UCP formalizes this change by treating AI agents as first-class participants in commerce, not just discovery tools.

UCP as a Shared Commerce Language

At its core, UCP defines a machine-readable abstraction layer for commerce, enabling agents not just to transact but to interpret contextual signals that power AI-driven personalization. This builds on the real-world shift toward hyper-personalized experiences outlined in Unthinkable’s post on Integrating AI to Hyper-Personalize Shopping Journeys, where AI systems dynamically adapt product offerings and recommendations based on user behavior.

Agents can then interact with those capabilities without custom code for every retailer. According to Google, the protocol is designed to eliminate the need for unique connections per agent.

From Specification to Production: Who’s Backing UCP

UCP is not being developed in isolation. Retailers and platforms, including Shopify, Walmart, Target, Etsy, and Wayfair, participated in shaping the protocol.

Payment networks and providers such as Adyen, American Express, Stripe, Mastercard, and Visa have publicly endorsed it, signaling cross-industry alignment.

Shopify, which has spent years operating checkout infrastructure at a massive scale, has positioned UCP as a way to standardize commerce interactions without stripping merchants of control. Walmart, meanwhile, plans to integrate UCP-powered discovery directly into Gemini, using its product and purchase history to recommend complementary items and apply membership benefits across Walmart and Sam’s Club.

Initially, UCP-powered checkout will use Google Pay as the payment provider, with PayPal planned for future integration. Importantly, Google has emphasized that UCP is payment-provider agnostic, allowing additional payment systems to plug in over time.

The Tradeoffs Merchants Can’t Ignore

UCP keeps retailers as the merchant of record, but it also raises hard questions. If checkout moves into AI agents and browser-level experiences, merchants risk losing the final point of interaction, the moment traditionally used for cross-sell, upsell, and brand reinforcement.

Industry analysts have pointed out that this “last touchpoint” can account for a significant share of incremental revenue, making off-site checkout a strategic decision rather than a purely technical one. At the same time, refusing to participate risks reducing discoverability as AI-driven shopping becomes more common.

Agentic commerce only works if three groups move together: consumers must trust agents to buy on their behalf; merchants must make inventory and product data machine-readable; and payment providers must verify intent, identity, and legitimacy to reduce fraud. Payment networks are moving quickly. Merchants, understandably, are more cautious.

Why This Shift Is Happening Now

What makes UCP notable is not just the technology, but the timing. AI agents are already influencing purchase decisions at scale. The remaining step, execution, requires infrastructure that didn’t previously exist. UCP is Google’s attempt to define that infrastructure early, before competing implementations harden into silos.

This is not a flashy product launch. It’s a protocol. Most users will never see it. But for CTOs, founders, and platform leaders, it represents a deeper shift: commerce moving from UI-centric experiences to protocol-driven systems designed for autonomous software.

UCP Defined: Bridging the Gap for Autonomous Agents

As AI systems move from assisting users to acting on their behalf, commerce infrastructure is being forced to adapt. The Universal Commerce Protocol (UCP) is Google’s answer to a basic but unresolved problem: how autonomous agents and merchant systems can reliably understand each other without custom integrations or weak workarounds.

The Universal Commerce Protocol (UCP) is an open, machine-readable standard introduced by Google that allows AI agents to discover products, negotiate terms, and complete purchases directly with merchants across the full commerce lifecycle.

UCP is designed to let software agents interact directly with commerce systems using standardized capabilities, rather than navigating human-oriented user interfaces or bespoke APIs.

Why UCP Matters for Retailers, Consumers, and Developers

For retailers, UCP reduces the need to build and maintain separate integrations for every AI surface, assistant, or marketplace. Integrate once, and your inventory becomes accessible to any UCP-compatible agent, improving discoverability as AI-driven shopping grows.

For consumers, the benefit is execution. Instead of being handed off from an AI recommendation to a manual checkout flow, purchases can be completed directly where intent is expressed, in search, chat, or assistant interfaces.

For developers and platform teams, UCP introduces a cleaner separation of concerns. Business logic, payments, identity, and fulfillment are handled as discrete capabilities, making commerce systems easier to evolve as agent behavior and distribution channels change.

UCP vs Other Protocols: Openness and Standardization

UCP emphasizes openness and interoperability rather than ecosystem lock-in. It is designed to work across agents, merchants, payment providers, and platforms, positioning it as long-term infrastructure.

UCP is not the first attempt to formalize agent-driven commerce. OpenAI’s Agent Commerce Protocol (ACP), for example, focuses on enabling agents to perform transactions within specific ecosystems. The key difference is scope and philosophy.

Google has also positioned UCP as complementary to its earlier Agent Payments Protocol (AP2), which focuses specifically on payment orchestration, while UCP covers the broader commerce lifecycle.

This distinction matters. As agentic commerce matures, protocols that remain flexible, extensible, and platform-neutral are more likely to survive early experimentation and become long-term infrastructure.

Key Roles in the UCP Ecosystem

Universal Commerce Protocol works because it draws clear boundaries between participants. Rather than collapsing discovery, checkout, payments, and identity into a single platform, UCP separates concerns across a small number of well-defined roles. This allows the ecosystem to scale without forcing merchants, agents, or payment providers into a single execution model.

AI Agents

AI agents are the initiators of commerce in the UCP model. Acting on behalf of users, they handle discovery, comparison, negotiation, and transaction orchestration. Crucially, agents don’t need to understand the internal complexity of each merchant’s system. They interact through standardized capabilities exposed via UCP.

For AI platforms, this simplifies onboarding at scale. Instead of building integrations for every retailer, agents rely on a consistent protocol while retaining the freedom to use their existing agent frameworks, whether that’s Model Context Protocol (MCP), Agent-to-Agent (A2A), or custom orchestration layers. This decoupling is what makes agentic shopping viable across multiple consumer interfaces, including AI Mode in Google Search and the Gemini app.

Merchants and Business Servers

Merchants remain at the center of the transaction. In the UCP ecosystem, they expose a business server that publishes their commerce capabilities, products, pricing logic, fulfillment options, and post-purchase workflows in a machine-readable form.

Importantly, UCP is designed so that merchants retain ownership of their business logic. They decide how checkout works, how discounts are applied, and how fulfillment is handled. They also remain the Merchant of Record, preserving control over compliance, liability, and customer relationships.

Merchants can choose an “embedded” option that allows them to maintain a fully customized checkout experience, even when transactions are initiated by AI agents off-site. This addresses a key concern raised in many industry analyses: avoiding full disintermediation while still participating in agent-driven commerce.

Payment Providers

Payment providers handle identity, payments, and consent without centralizing control. In early implementations, Google Pay acts as the default payment gateway, with others such as PayPal expected to integrate over time.
For architects, this separation matters. Identity verification, authentication, and consent management can evolve independently of commerce logic, reducing coupling and making it easier to adapt to regulatory or security requirements across regions.

Platforms and Orchestrators

Platforms sit at the coordination layer. They host AI agents, manage discovery across merchants, and surface commerce experiences to end users. Their role is not to replace merchant systems, but to orchestrate interactions between agents, business servers, and payment handlers.

This is where UCP’s ecosystem approach becomes clear. By standardizing how these parties interact, without dictating who owns the customer or controls the transaction, UCP allows platforms to enable agentic shopping while giving merchants and developers meaningful flexibility.

What is The Architecture of UCP?

The Universal Commerce Protocol is not a monolithic system or a new commerce platform. It is a layered architecture designed to make existing commerce systems legible to autonomous agents. Its design choices reflect a clear priority: interoperability at scale without stripping control from merchants or platforms.

At a high level, UCP separates discovery, communication, execution, and payments into discrete layers. This separation allows each part of the system to evolve independently and work together through well-defined interfaces.

Foundational Principles: Modularity and API First Design

UCP is built on a modular, API first foundation. Rather than prescribing a single end-to-end commerce flow, it defines small, composable units of functionality that can be combined as needed. Each unit does one job and exposes a clear contract for how agents can interact with it.

This approach mirrors how modern distributed systems are built. Business logic is not embedded in user interfaces or tightly coupled workflows. Instead, it is exposed through stable interfaces that machines can reliably consume. For commerce teams, this reduces integration risk and makes it easier to adapt as new agent capabilities emerge.

The Discovery Manifest: How Agents Find What They Need

Discovery is the entry point to the UCP architecture. Merchants publish a discovery manifest that describes what their business server supports. This includes available products, supported checkout capabilities, payment methods, fulfillment options, and post-purchase actions.

Agents use this manifest to understand what actions are possible before attempting a transaction. Rather than probing undocumented endpoints or scraping pages, agents can programmatically determine whether a merchant can fulfill a specific request.

From a systems perspective, the discovery manifest acts as a contract. It reduces ambiguity, minimizes failed requests, and allows agents to make informed decisions early in the flow.

The Transport Layer Agent to Merchant Communication

UCP is transport agnostic by design. It does not mandate a specific protocol for how messages are sent between agents and merchant systems. This allows businesses to adopt UCP without replatforming their entire stack.

The key requirement is consistency at the semantic level, not the transport level. As long as messages conform to the protocol’s expectations, agents and merchants can communicate reliably. This flexibility is one reason UCP is positioned as infrastructure rather than a product feature. It can coexist with existing systems instead of replacing them.

The Capability Layer Executing Commerce Actions

The capability layer is where commerce actually happens. Capabilities are the atomic units of action in UCP and enable autonomous checkout without requiring agents to navigate carts. Each capability represents a specific business function that an agent can invoke. Together, they form the building blocks of agent-driven commerce.

Discovery

Discovery capabilities allow agents to query available products and understand constraints such as availability, delivery options, or eligibility. This is not a simple search. It is structured access to merchant data that agents can reason over.

Checkout

Checkout capabilities handle the creation and execution of a transaction. Rather than navigating a cart or form, agents invoke checkout directly using standardized inputs. This includes passing user intent, selected items, and delivery preferences in a machine-readable format.

Pricing

Pricing capabilities expose how costs are calculated. This includes base prices, taxes, fees, and contextual adjustments. By making pricing logic explicit, UCP reduces surprises and enables agents to compare options accurately across merchants.

Discounts

Discount capabilities allow merchants to apply promotions, membership benefits, or negotiated offers dynamically. This is particularly important in agentic commerce, where agents may optimize for total value rather than list price.

Fulfillment

Fulfillment capabilities cover order handling after checkout. This includes shipping methods, delivery timelines, order status, and post-purchase updates. By treating fulfillment as a first-class capability, UCP ensures the protocol extends beyond the moment of payment.

Taken together, these layers form a coherent architecture that shifts commerce from interface-driven workflows to protocol-driven systems. For engineering leaders, the significance lies in what this enables. Commerce logic becomes reusable. Integrations become predictable. And AI agents gain a reliable way to move from intent to execution without custom engineering for every merchant.

The Agentic Commerce Lifecycle Under UCP

Under UCP, the agentic commerce lifecycle follows a defined lifecycle: discovery of merchant capabilities, selection and negotiation of actions, checkout execution, fulfillment tracking, and post-purchase support. Each step is exposed as a standardized capability that AI agents can invoke programmatically.

UCP is designed to support every phase of an agent-driven purchase, from initial discovery through post purchase support. This end-to-end framing is consistent across Google’s technical documentation and independent analysis of the protocol’s design.

Discovery

The lifecycle begins with discovery. AI agents identify potential merchants and offerings by querying UCP-enabled business servers. Instead of crawling pages or relying on unstructured data, agents use the discovery manifest exposed by merchants to understand what products are available and which commerce capabilities are supported.
According to the Google Developers Blog, this explicit discovery step is foundational. It allows agents to determine upfront whether a merchant can meet a user’s intent before attempting deeper interaction. This reduces failed flows and unnecessary requests, which is essential at scale.

Negotiation and Capability Selection

Once discovery is complete, agents move into negotiation and capability selection. At this stage, the agent evaluates which actions to invoke based on constraints such as price thresholds, delivery timelines, membership benefits, or supported payment methods.

This step is often overlooked in traditional commerce systems because negotiation is handled implicitly through user interfaces. In UCP, it is explicit and machine-readable. Agents select the appropriate capabilities exposed by the merchant, such as checkout or discount application, based on what best satisfies the user’s intent. MarkTechPost highlights this capability-driven approach as a key distinction between UCP and earlier commerce integrations.

Checkout Execution

Checkout execution is where UCP is most visible. Rather than redirecting users to a cart or form, agents invoke checkout directly using standardized inputs defined by the protocol. These inputs include selected items, pricing context, delivery details, and user consent signals.

Google’s documentation emphasizes that UCP does not replace existing checkout systems. Instead, it provides a structured way for agents to trigger them.

Fulfillment and Order Management

The lifecycle continues after payment. UCP treats fulfillment as a first-class concern, not an afterthought. Agents can interact with fulfillment capabilities to retrieve order status, delivery updates, and handling details. This design choice is significant. By extending the protocol beyond payment, UCP ensures that agent-driven commerce can support real-world expectations around shipping, tracking, and service level commitments.

Post Purchase Actions, Returns Status Support

The final phase of the lifecycle covers post-purchase actions. This includes initiating returns, requesting refunds, checking order status, and accessing customer support. In traditional systems, these actions often require manual navigation or separate workflows.

Under UCP, post-purchase interactions are exposed as capabilities that agents can invoke on behalf of users. This allows AI systems to manage the entire lifecycle of an order, not just the moment of purchase. It also reduces operational friction for merchants by standardizing how post-purchase requests are handled across channels.

Preparing Your Business for UCP

Agentic commerce requires systems that autonomous agents can reliably understand and execute against. For CTOs and founders, readiness is about exposing commerce capabilities in a way AI agents can reliably discover and execute.

For teams modernizing their commerce architecture, Unthinkable’s custom e-commerce solutions offer concrete examples of how modular, API-first systems can be designed for AI-driven and agentic commerce.

The Importance of High Quality Structured Product Data

Agentic commerce fails without structured, machine-readable product data, aligning with Google’s guidance on structured data for commerce. AI agents depend on explicit attributes such as availability, pricing rules, fulfillment constraints, eligibility, and post purchase conditions. Unlike humans, agents cannot infer intent from unstructured pages or inconsistent schemas.

Retailers participating in early UCP integrations have consistently highlighted product data quality as the single biggest determinant of success. Product detail pages are no longer just conversion assets. They are the operational input for agent-driven discovery and checkout. Poor structure leads to failed transactions and reduced visibility across AI shopping surfaces.

Technical Readiness Modernizing Merchant Systems

Composable systems integrate faster with UCP. It is designed to work alongside existing commerce infrastructure, not replace it. However, merchants with modular, API driven systems are significantly better positioned to expose UCP capabilities without major refactoring.

Teams should focus on separating pricing logic, discounts, fulfillment, and post-purchase workflows from tightly coupled user interface flows. When these capabilities can be invoked programmatically, AI agents can transact without weak workarounds.

Assessing AI Readiness Beyond the Protocol

Agentic commerce is a governance decision, not just a technical one. Preparing for UCP also requires clarity around autonomy and control. When agents initiate transactions, teams must define guardrails for pricing, promotions, returns, and fulfillment exceptions.

Early U.S. adopters are treating agentic commerce as a new distribution channel rather than an extension of web or app commerce. That means defining policies up front instead of reacting to unexpected behavior later.

The tradeoff is real. Agent-driven checkout increases reach and convenience, but it also shifts where and how customer interactions occur. Businesses that address this strategically are better positioned to scale agentic commerce without eroding control.

Developer Entry Points, Specifications, and Ecosystem Signals

Start small, integrate once, and iterate. UCP is an open, evolving standard with published technical documentation and reference flows. Google has positioned the protocol to interoperate with existing agent frameworks rather than replace them, signaling long-term ecosystem intent.

In practice, early adoption looks incremental. Teams expose a limited set of capabilities, validate agent behavior in controlled environments, and expand based on real usage. This mirrors how previous infrastructure shifts, such as API platforms and cloud services, gained traction.

For developers, the opportunity is to build once and participate across multiple AI-driven commerce surfaces as adoption grows.

Why We Care and What Comes Next

Agentic commerce is not a speculative trend. It is an infrastructure shift already reshaping how discovery, checkout, and payments work inside AI-driven interfaces such as Google Search AI Mode and Gemini.

For technology leaders, the UCP matters because it changes where commerce logic lives. In a world of AI shopping agents, competitive advantage no longer comes from better screens or faster front ends. It comes from how clearly systems expose intent, capability, and trust to machines.

This is exactly the kind of transition where many platforms fail. Not because the protocol itself is complex, but because legacy architectures were never designed for machine-readable commerce, autonomous checkout, or protocol-level payment authorization and consent. UI-driven workflows, tightly coupled pricing logic, and weak integrations become liabilities when software agents are the primary buyers.

For teams looking to build next-generation commerce systems, understanding how to expose commerce capabilities in ways machines can reliably interpret means thinking beyond the UI and into the semantics of interaction. Our work in AI agent development services illustrates how to design systems that are both human-friendly and machine-ready, layering autonomy with robust engineering foundations.

If you are evaluating how your commerce architecture needs to evolve for agent-driven buying, talk to our team to explore what machine-readable commerce looks like in practice and how to begin architecting systems that scale with autonomy.