ACP and UCP: the buyer’s agent reads your data, not your page
ACP and UCP let AI agents check out on a buyer’s behalf, and agents compare products on structured data. What a buyer’s agent reads, and what your catalog has to hold.
On this page
For twenty years, the product page was the center of commerce. Every system and every dollar spent on digital commerce served one goal. Get a person to that page, and get them to click “Add to Cart.”
SEO, paid ads, UX design, A/B testing, product photography and review widgets all existed to serve that one page.
That is starting to change. Product pages don’t disappear, and they stay as one channel among many.
Some AI agents already find and compare products, and a few can complete a purchase, without rendering a product page. The main interface for high-intent buying may be starting to move off the page.
Two protocols set this down: the Agentic Commerce Protocol (ACP), released by OpenAI and Stripe in September 2025, and the Universal Commerce Protocol (UCP), launched by Google in January 2026 with Shopify, Walmart, Target, Etsy, Wayfair and others.
Together they are the infrastructure layer for machine-mediated commerce. Structured product data, not visual presentation, is the interface.
What ACP and UCP actually are.
These aren’t shopping features. They are commerce infrastructure protocols, closer to HTTP than to a storefront plugin. They set the rules for how one machine asks another machine about products, carts and payment.
Scroll sideways to see the whole table.
| Protocol | What it defines | How it connects | What it enables |
|---|---|---|---|
| ACP (Agentic Commerce Protocol) | A product feed format, checkout sessions and delegated payment. | A feed you submit, and a checkout API the agent calls. | ChatGPT, and any other agent that adopts ACP, can take a buyer through checkout. |
| UCP (Universal Commerce Protocol) | A merchant profile at /.well-known/ucp plus capabilities for catalog search, cart, checkout and orders. | Over REST, MCP or A2A. | Agents that use UCP learn what you support from your profile, then take a buyer through checkout. |
| MCP (Model Context Protocol) | How an AI model calls an outside tool, including commerce tools: search the catalog, check availability, fetch specifications. | Tools on an MCP server, called by the AI system. | AI systems that support MCP can query your catalog as typed tools. |
ACP and UCP are parallel checkout protocols from different ecosystems: ChatGPT uses ACP; Google’s AI Mode and Gemini use UCP. Merchants implement one or both. The Model Context Protocol (MCP) is how an AI system calls tools, and one of the transports UCP can use.
Note
Where the protocols stand in September 2026
ACP launched in September 2025 with checkout inside ChatGPT. In March 2026 OpenAI moved checkout into merchant apps and kept ACP as the underlying protocol. Google’s UCP, launched in January 2026, powers checkout in AI Mode and Gemini for eligible US merchants. Both specifications are still evolving, so check the current versions before you plan around a specific feature.
An agent is a different reader.
An AI agent isn’t a person who reads quickly. It consumes product information a different way.
Scroll sideways to see the whole table.
| Dimension | Human buyer | AI agent |
|---|---|---|
| Taking information in | One thing at a time, visually, with limited working memory. | In parallel, from typed fields, comparing many products at once. |
| What it wants to read | Images, prose, a narrative, a visual hierarchy | JSON, typed attributes, machine-readable schemas, API responses |
| How it decides | Part feeling, part reason. Swayed by presentation, brand and what other buyers say. | It matches attributes to what the buyer asked for, compares specifications, and checks that the constraints hold. |
| How it finds things | Browses categories, searches keywords, follows recommendations | Queries structured feeds, filters on typed attributes, compares each candidate against the stated intent |
| How it buys | Navigate the site, find the product, add to cart, enter payment, confirm | Open a checkout session with the product ID and variant, then complete it with a payment token. |
| What earns its trust | Brand reputation, reviews, how good the website looks | Complete data, attributes that agree with each other, fresh responses, fields that are right |
An agent can fetch your product page. It can read it, but far less reliably than typed fields. Pulling specifications out of prose, inferring variant relationships from dropdown menus, and reading availability out of JavaScript that runs on load is unreliable, brittle and slow.
What an agent needs is what the protocols define. Typed fields, reached the same way at every merchant.
The interface moves off the page.
This isn’t one more channel to add. It changes which system the buyer’s software actually talks to.
Scroll sideways to see the whole table.
| Layer | Product page | Agent commerce (emerging) |
|---|---|---|
| Discovery | Google text search, then SEO ranking, then a click through to your product page | The agent reads merchant feeds and catalog tools, and compares typed attributes across many merchants at once |
| Evaluation | A person reads the description, scrolls the images, checks the reviews, opens 3-4 competitor pages | The agent compares specifications across many products at once and keeps the ones that fit the buyer’s constraints. |
| Purchase | A person fills in the checkout form, enters payment, confirms the order | The agent opens a checkout session over ACP or UCP, hands over a payment token, and one API call finishes the transaction. |
| Differentiation | Better photography, better copy, better UX, better reviews | More complete attributes, specifications that are right, an API that answers quickly, data that is fresher |
| Investment focus | Design, copywriting, ad spend, conversion optimization | Data plumbing, attribute coverage, following the protocols, product data a machine can read |
| Visibility mechanism | Page rank, ad placement, marketplace position | Likely: how complete the data is, how closely you follow the protocols, how good the answers are. Products with gaps are the easiest to pass over. |
The product page becomes one rendering of your product data, not the primary interface. The PIM becomes the actual storefront. It holds the data that decides whether an AI agent can find and compare your products.
- A PIM holds the structured attributes agents use to compare products. That is your product presentation now.
- A PIM should flag gaps before an agent skips the product. That is your conversion optimization.
- A PIM can expose structured tools such as MCP. Opening them to shopping agents is a separate step.
- A PIM keeps product attributes accurate, while live price and stock come from the systems that own them. That is your reputation management.
- A PIM puts review around agent suggestions by default, so your team can check agent-drafted content before it applies. That is your brand quality control.
- A PIM can feed your channels today, and the endpoints agents use as ACP and UCP mature. That is your marketing and visibility.
What protocol-ready means for your data.
Taking part in ACP and UCP commerce needs product data infrastructure that many don’t have yet.
Scroll sideways to see the whole table.
| Requirement | What it means day to day | What happens without it |
|---|---|---|
| Typed, structured attributes | Every specification held as a typed, checked, machine-readable value, not as a sentence buried in a description. | Agents pull specifications out of free text unreliably. Your products come off worse than a competitor whose data is structured. |
| Complete attribute coverage | Every attribute an agent compares on is filled in. No gaps. | Agents are less likely to recommend what they can’t check. |
| Current availability and pricing | Stock and price come from a live API and match what is true now, not what yesterday’s export file said. | The agent recommends the product. The buyer tries to buy. It is out of stock, and the failed purchase may count against you. |
| Variant resolution | An agent can ask for “blue, size M, ships to Germany” and get one clear, structured answer. | The agent can’t turn the buyer’s preferences into a single buyable variant, so it moves to a competitor whose variants are clear. |
| Your catalog exposed as MCP tools | The catalog is reachable as typed tools any AI system that supports MCP can call: search, filter, get details, check availability. | AI assistants that work through tools, rather than feeds, can query your catalog only through an integration someone builds for each one. |
| UCP profile | A machine-readable file at /.well-known/ucp stating your capabilities, the protocols you speak and your endpoints. | Agents that use UCP can’t check out with you without one. |
| Channel-specific content | A different structured output per consuming system: the ChatGPT Shopping format, the Google AI Mode format, plain MCP tools. | One format for everyone may not match what a given agent expects, and your products read worse in its comparison. |
Where buying is heading.
Some of it is already visible, and some is still in early pilots.
- Conversational product discovery: a buyer tells an AI assistant “find me running shoes for flat feet under $150 that work on trails.” They don’t construct a keyword search and walk a category tree.
- AI-mediated comparison: agents can compare many products on structured attributes at once, work that used to mean a person opening tab after tab for hours. Products without structured specifications can drop out of the comparison set.
- Intent-driven purchasing: buyers state constraints and preferences, and the agent finds the matches. The buyer browses less and delegates more. Your product has to be findable by matching an intent, not by ranking in a result list.
- Autonomous procurement, in early pilots: some B2B procurement is being delegated to AI systems that read supplier catalogs. The procurement agent queries structured feeds, compares terms and initiates orders, with no product page visit in the loop.
- Dynamic product presentation: when a product does get shown to a buyer, the AI generates the presentation around that buyer’s intent, highlighting the specifications that buyer asked about. A static page with a fixed layout is replaced by presentation that adapts to context.
In each of these, the product page is beside the point. What counts is whether your product data is structured, complete, reachable and shaped the way the protocol expects. The interface isn’t your website. It’s your data.
This is a product operations problem.
It’s tempting to treat ACP and UCP as one more integration. Plug in a connector, expose an endpoint, done. That misses the structural part. The protocols expose whatever data quality you already have, and they amplify it in both directions.
- Taxonomy consistency: agents compare products inside a category. Inconsistent taxonomy puts your products in the wrong comparison set, or leaves them out of it.
- Attribute completeness: agents compare on the attributes that are present. Patchy attribute coverage loses to full coverage, whatever the products are actually like.
- Specification accuracy: agents take structured data at face value. A wrong specification becomes a mismatched purchase and a return.
- Enrichment speed: new products have to reach protocol-ready state quickly. If enrichment takes 6 weeks, a competitor is agent-discoverable 6 weeks before you are.
- Validation: data going out to AI agents has to be checked first. Unvalidated content reaching agent systems can cost you trust across the whole catalog.
- Price and stock freshness: both have to be current. Stale data produces failed transactions, and those may count against you.
- Supplier data: products you source inherit the supplier’s data quality. A chaotic supplier file means thin agent-facing attributes, and thin attributes make the product easy to pass over.
Protocol readiness isn’t a technical integration. It is operational work: taxonomy rules, enrichment pipelines, validation, completeness scoring, keeping price and availability current, and watching quality after launch. The work that makes product operations good is the same work that makes agent commerce possible.
Why the systems you already run don’t cover this.
Many brands keep product data in systems built for people to read.
Scroll sideways to see the whole table.
| Current system | What it gives you | What agent commerce asks for |
|---|---|---|
| Shopify/BigCommerce pages | HTML rendered for a person’s browser | JSON with typed attributes, variant trees, and current availability read over an API |
| ERP (SAP, Oracle) | Internal operating data: cost, procurement codes, stock levels | Buyer-facing attributes: features, specifications, comparisons, use cases, typed and structured |
| Spreadsheets | Unchecked, untyped data that somebody updates quarterly and that is often stale by then | Checked, typed, current data that matches a schema and can be read over standard protocols |
| Marketing copy decks | Brand-approved prose paragraphs | Attributes an AI can read straight off, rather than paragraphs it has to parse |
| Legacy PIM | Central storage, a form to type into, and a batch export to channels | Live API access, MCP tools, structured feeds that follow the protocols |
The gap is architectural. These systems were built for a person reading a web page. ACP, UCP and MCP expect typed data, current values, and the same field present on every product, served the same way to any caller that asks.
What to check this quarter.
ACP and UCP are in early adoption. Few PIMs support them natively yet, and many commerce teams are still optimizing product pages and conversion funnels. The data the protocols read can be checked now, and the same structured data makes better listings and better SEO in the meantime. Four checks:
- Typed comparison attributes: list the attributes a buyer’s agent would compare in your main category, then check that each one is a typed field, filled in on every product, rather than a phrase in the description.
- Variant resolution: ask for one specific variant, such as “blue, size M,” and check that exactly one buyable variant comes back, with its own identifier, price and stock.
- Price and stock freshness: find out how old price and stock are by the time a feed or tool serves them, and which system owns each. A file exported yesterday can offer stock you sold this morning.
- MCP reachability: check whether an AI assistant can query your catalog as typed tools, such as search, filter and get details, within permissions you control, or whether every AI system needs its own integration.
CataZenta exposes the catalog over MCP to your team’s assistants, with each user’s permissions. It doesn’t publish ACP feeds, offer ACP checkout or serve a UCP profile.