Your Product Schema Is Valid. An AI Shopping Agent Still Cannot Buy From You.

You ran your product page through a JSON-LD generator. You pasted the output in. Google's Rich Results Test is green. Your Product markup has name, image, description, sku, brand, and a tidy offers block with price and availability.

An AI shopping agent still cannot buy from you.

This is not a markup error, and no schema generator will flag it, because nothing is wrong with your schema. The gap is that Product structured data and agentic commerce are solving two different problems, and most merchants find that out only after assuming the first one covers the second.

Describing versus transacting

Schema.org Product is a description format. It exists so a crawler can understand what is on a page and render a richer search result. It is a snapshot, embedded in HTML, refreshed whenever the crawler comes back.

Agentic commerce protocols such as UCP and ACP are transaction formats. An agent is not trying to summarise your page. It is trying to check whether a specific variant is in stock right now, price it with tax and shipping to a real address, and complete a purchase without a human in the loop.

Those requirements do not degrade gracefully. Consider a perfectly valid offer block:

{
  "@type": "Offer",
  "price": "49.00",
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock"
}

That is correct markup, and it is unusable for a transaction. InStock was true when the page was rendered and cached. An agent about to charge a customer needs stock at commit time, not at crawl time. There is no field in Offer that can give it that, because a static document cannot answer a live question. What the agent needs is an endpoint it can call.

That is the actual dividing line. Structured data lives in the page. Agentic commerce lives at an endpoint the agent can query and post to.

The four things description formats cannot carry

When merchants hit this wall, it is usually one of these:

1. Real-time availability. Covered above. A cached boolean is not inventory.

2. Variant identity that survives a round trip. Your size-medium-in-blue needs a stable identifier the agent can put in a cart and still resolve at checkout. Schema.org can express variants, but nothing binds that identifier to a cart operation, because there is no cart.

3. Fulfillment as a negotiation, not a fact. Shipping is not a property of a product. It is a function of the product, the destination, the method, and often the other items in the cart. UCP models this as configuration the agent negotiates against - including, as of the 2026-08-25 release, whether you even permit multiple destinations in one cart, and which method combinations you allow. A shippingDetails block in JSON-LD cannot answer "can this cart go to two addresses".

4. A checkout the agent can actually complete. This is the one people underestimate. A rich result gets a human to click through to your storefront. An agent has no one to hand off to. If the transaction cannot be completed programmatically, everything upstream of it was decoration.

So is product schema pointless?

No, and this is worth being precise about, because the "structured data is dead" takes are wrong.

Product markup still does its original job well. It still drives rich results. It still helps AI answer engines describe your catalogue accurately when they are summarising rather than buying. Good Product data is a genuine input to discovery.

It is a discovery layer. Agentic commerce is a transaction layer. You want both, and the mistake is treating the first as if it satisfies the second. If your plan for AI shopping agents is "we added Product schema", you have built the shop window and no door.

What to actually check

In rough order of how often each one turns out to be the problem:

1. Is there a machine-readable entry point at all? For UCP that means a profile at /.well-known/ucp declaring your services and capabilities. If it is absent, nothing else matters - an agent has no way in.
2. Do your declared capabilities cover the transaction, not just the catalogue? Catalog search and lookup let an agent find things. Checkout, payment and fulfillment let it buy them. Declaring only the first is a common half-migration.
3. Are your endpoints live and reachable? Declaring a capability you do not serve is worse than not declaring it, because the agent will try.
4. Is your product data consistent between layers? If your JSON-LD says one price and your catalogue endpoint says another, you have not got two sources of truth. You have got one source of truth and one liability.
5. Then validate your Product markup. It matters. It is just not the first thing.

Where this bites by platform

BigCommerce and WooCommerce both emit reasonable Product markup out of the box, which is exactly why merchants on those platforms are most likely to assume they are covered. Neither ships a UCP profile by default. The markup being good is what makes the gap invisible.

Shopify is moving fastest here, since UCP is co-developed by Google and Shopify, so Shopify merchants are likeliest to get transaction-layer support from the platform rather than building it. Worth checking what your plan actually includes rather than assuming.

Headless and custom builds have the opposite profile: the endpoints are usually the easy part, and the discovery document is the thing nobody remembered to publish.

Checking yours

You can generate compliant product structured data with the free schema generator, and check whether your product feed carries what an agent needs with the feed analyzer. To answer the bigger question - whether an agent can discover and transact with your store at all - run your domain through the UCP validator, which checks the profile, the declared capabilities and the endpoints behind them rather than the markup on one page.

The short version: valid schema means an agent can read about your product. It does not mean an agent can buy it. Those are separate pieces of work, and only one of them is finished when the Rich Results Test goes green.

UCP is an open standard co-developed by Google and Shopify. ACP is an open standard from OpenAI and Stripe. UCPtools is an independent community tool and is not affiliated with any of them.