How Google’s UCP Defines Agent-Ready Websites

Since January 2026, when Google unveiled the Universal Commerce Protocol (UCP) at the National Retail Federation conference, the architecture has quietly redefined what it means for a website to be agent-ready. Backed by Shopify, Etsy, Wayfair, Target, and Walmart, UCP is far more than a shopping standard. It is the first production-grade blueprint for how any website must expose itself to AI agents: through discoverable actions, predictable outcomes, persistent sessions, and explicit agent policies.

UCP was initially released as infrastructure for Google Merchant Center retailers. But the deeper story lies in its design. UCP is the first real implementation of what I have called the Interaction pillar of machine-first architecture. If you want to understand what agent-ready websites look like in practice, the developer documentation for UCP is where you should start. The architecture is the lesson, and its relevance extends well beyond Google Shopping.

What Google Actually Built

UCP is an open standard that creates a common language between AI surfaces like Gemini and Google AI Mode and merchant backends. According to Google’s “Under the Hood” post on UCP, the protocol has four moving parts worth studying.

First, there is a discovery endpoint at `/.well-known/ucp`. Agents query this URL to learn what a merchant’s website can do, which products it sells, which actions it exposes, and which transports it supports. This manifest is the handshake between an AI agent and a merchant’s backend. Without it, an agent has no knowledge of what to parse or call. At best, it will try to guess.

Second, UCP reduces the entire transaction to three REST endpoints for checkout: create a session, update a session, complete a session. That is it. No cart page, no address form, no confirmation screen. The checkout state lives in session responses, not in rendered HTML. The human layer of your website gets completely ignored. An interface will exist, but it will not be the one you designed.

Third, UCP supports transport flexibility through REST, Model Context Protocol (MCP) bindings, and Agent-to-Agent (A2A) communication. An agent running inside Gemini and an agent running on a custom MCP client can both hit the same UCP endpoints without custom adapters. This was a very smart move.

Fourth, UCP is published as an open specification at ucp.dev. Any website, AI platform, or merchant platform can implement it. Google does not own the protocol or its governance. This openness matters because the architecture becomes portable to any website outside Google Merchant Center, even if Google’s own onboarding path does not extend there.

Google is building UCP for its own Shopping ecosystem first. But UCP’s design is the real lesson for everyone else. That design is a textbook implementation of the Interaction pillar of machine-first architecture. Shopping carts are abandoned by roughly 70% of humans, according to Baymard Institute’s long-running checkout research. You can expect the agent abandonment rate on websites with no Interaction layer to be closer to 100%.

UCP Is The Interaction Pillar In Production

The Interaction pillar of machine-first architecture describes what a website must expose so an AI agent can accomplish a goal on it. It has five properties: discoverable actions, predictable outcomes, workflow continuity, error recovery, and agent policies. UCP maps to each one almost perfectly.

Discoverable actions. The Interaction pillar says agents need a machine-readable index of what they are allowed to do on a page before they try to do it. UCP’s `/.well-known/ucp` capability manifest is exactly that index, shipped as a production endpoint. An agent fetches the manifest, reads the list of available operations, and plans its next step. No trial and error, no DOM scraping.

Predictable outcomes. The Interaction pillar says every action should return machine-readable state: computed totals, allocated inventory, success flags. Not a 200 OK with an HTML receipt. UCP session responses carry structured data at every step: pricing breakdowns, discount allocations, and explicit session state. An agent reading a UCP response knows exactly what just happened and what it owes next.

Workflow continuity. The Interaction pillar says agents need stable session references that survive across multi-step workflows. UCP sessions have persistent IDs, and PUT updates carry that ID forward. An agent can add a line item, apply a discount, adjust shipping, and complete the order across multiple calls without re-creating state.

Error recovery. The Interaction pillar says failures should return structured alternatives, not dead ends. When a UCP discount code fails, the session response explains why and surfaces alternatives the agent can try. A human might click “try again.” An agent needs a payload that tells it what to do next.

Agent policies. The Interaction pillar says websites should declare what agents are allowed to do, what requires human confirmation, and what is off-limits entirely. UCP’s capability declarations are that policy layer. A merchant signals which actions agents can invoke, under what conditions, and where human approval is required. Request signatures and tokenized payments enforce the policy at the protocol level.

Google’s `/.well-known/ucp` endpoint is the Interaction pillar’s “discoverability of actions” being shipped as production infrastructure. Agents query it to learn what a website can do before they attempt to do it. UCP requires three REST endpoints for checkout: session creation, updates, and completion. That is the entire Interaction pillar reduced to three API calls.

The Gap UCP Exposes For Everyone Else

UCP is Google’s answer to the agent-traffic gap inside its Shopping ecosystem. Every non-UCP website still has that gap, though not every retailer agrees on where it actually lives.

Breanna Fowler, Dell’s Head of Global Consumer Revenue Programs, told Digital Commerce 360 in an April 2026 interview that she has not yet noticed “anything behaviorally consistent” in the agent traffic reaching Dell.com. Her focus is search and discoverability, not agent-specific infrastructure. “If I can’t find your products easily and effortlessly, no amount of content and configurator capabilities, nobody really gives a crap about that stuff,” she said.

Fowler is right that nothing matters if agents cannot find the product. But for an AI agent, “finding” a product does not mean typing into a search box. Finding means querying a capability manifest, reading a structured product catalog, and invoking a discoverable action. In a human-first website, findability is a UI problem. In an agent-ready website, findability is a protocol problem. UCP exists because Google decided that treating findability and checkout as protocol problems, not UI problems, is the only way agent conversions ever scale.

A Gemini agent shopping through a UCP-enabled merchant does not parse a product grid, does not guess at form fields, and does not hope nothing re-renders under it. The agent queries `/.well-known/ucp`, reads the capability manifest, and advances the session through UCP’s three checkout endpoints. The rest of the web, every SaaS dashboard, every B2B quote flow, every booking system, every subscription portal, has no equivalent protocol coming to rescue it.

Baymard Institute’s aggregated checkout research puts the human cart abandonment rate at 70.22% across 50 studies. The agent abandonment rate on websites without an Interaction layer is closer to 100%. Humans hesitate at checkout. Agents cannot even find checkout.

What Every Website Can Learn From UCP’s Architecture

You do not need to implement UCP. You are probably not even a commerce business. But UCP’s architecture still generalizes into five principles any agent-ready website should implement: a capability manifest, structured actions, machine-readable state, persistent sessions, and an explicit agent policy.

Publish a capability manifest. Agents need to know what your website can do before they start. That manifest might be a `/.well-known/` endpoint, an `llms.txt` file, a WebSite schema node with `potentialAction` entries, or an MCP server listing available tools. The format matters less than the existence. If there is nothing for an agent to query, the agent has to guess. Guessing is how conversions die.

Expose actions as structured data. Schema.org has supported Actions for over a decade, including `BuyAction`, `OrderAction`, `ReserveAction`, `SubscribeAction`, and `SearchAction`. Almost no websites use them. UCP’s POST `/sessions` endpoint is effectively a `BuyAction` target given a stable API contract, which is what schema.org Actions have needed for a decade to actually work. Any website can do the same on its own actions: declare the action type, name the endpoint, document the payload.

Return machine-readable state at every step. Every response to an agent should carry structured state the agent can parse: what happened, what changed, what is next. HTML confirmation pages are not machine state. A redirect to `/thank-you` is not machine state. JSON with named fields and explicit flags is machine state. Returning JSON state instead of HTML confirmation pages is the single biggest architectural shift from human-first design to agent-ready design.

Design for sessions, not pageviews. Agents do not restart when they get distracted. They come back to a workflow in progress and expect the state to still be there. Sessions with stable IDs, safe-to-retry updates, and graceful resume paths are not optional for agents. They are the base layer. Pageview analytics trained a generation of product teams to think in discrete hits. Agents think in transactions.

Declare your agent policy explicitly. An agent policy defines three things: what agents can do without asking a human, what requires human confirmation, and what is off-limits entirely. UCP answers these questions through capability declarations. Your website can answer them through an `AGENTS.md` file, a `/.well-known/` policy endpoint, or structured annotations. Pick one. Publish it. Guessing a policy is how agents end up taking actions their users did not intend.

None of these principles require Google’s participation. None require UCP’s adoption. They require a decision to treat a website as an API surface for agents in addition to a screen for humans.

Citation Gets You Into The Answer. Actions Get You Into The Revenue

Most of the AXO conversation today is still about the Content pillar: how to get cited in ChatGPT answers, how to rank in Google AI Overviews, how to become the source AI surfaces quote. That work matters. Citation drives awareness, and awareness is the top of the funnel.

UCP demonstrates the Interaction pillar, which is the other half of the agent-ready website stack that AEO and GEO do not cover. The Interaction pillar is about being transacted through by an AI agent, not quoted in its answer. The difference between a cited website and a transactable website is the Interaction pillar. Citation gets you into the AI’s answer. Discoverable actions get you into the AI’s revenue.

On the Cheeky Pint podcast, Sundar Pichai described a future where an AI user has “many threads running” at the same time: research, comparison, booking, purchase, all executing in parallel on behalf of a single human. In that model, the website that lets the agent resolve its thread fastest wins the thread. Resolution means completing an action, not loading a page. Dell has the traffic and loses the thread. A UCP-enabled merchant resolves the same thread in three API calls.

UCP is the first production artifact that gets the Interaction pillar right. It will not be the last. Every website that wants to participate in agent-mediated revenue will eventually need to ship its own version of the same architecture, through an open protocol, a schema.org capability layer, a WebMCP endpoint, or a custom MCP server. The spec can vary. The principles cannot.

UCP is the working reference implementation of the Interaction pillar, built by Google and running in production inside Google Shopping today. Every other website still owes its own answer. Dell’s Breanna Fowler said discoverability is what matters. For an agent, discoverability is a protocol.