Why AI Agents Can't Buy From Your Store (And What Structured Product Data Fixes)

Your store looks fine to humans. To an AI agent trying to buy from it, it may be a dead end. Not because your products aren't good. Because your data isn't structured in a way the agent can parse.

This is the gap that most ecommerce brands don't know they have. You've optimised for Google. You've written good product descriptions. Your images are clean, your checkout works, and your SEO is solid. None of that is the problem.

The problem is that AI shopping agents - the systems being built into ChatGPT, Perplexity, Gemini, and increasingly into enterprise procurement workflows - don't browse your store the way a customer does. They don't read your copy. They don't respond to your hero image. They query structured data feeds, evaluate schema markup, and either include your product in their recommendation set or discard it before a human ever sees the result.

How AI shopping agents actually work

Understanding why structured data matters requires understanding what AI agents are doing when a user asks them to buy something.

When someone asks an AI agent "Find me a waterproof hiking boot under £150 and order it," the agent doesn't open a browser and start clicking. It calls APIs. It queries product feeds. It evaluates structured attributes - size ranges, waterproofing certifications, price, real-time stock - and compares them programmatically against the buyer's criteria.

The agent is making a purchasing decision on behalf of a human. It needs deterministic data. It can't guess at your sizing chart from a paragraph of marketing copy. It can't infer your stock level from a hero image. It needs machine-readable fields in machine-readable formats.

A product page that converts at 4% for human visitors can have a 0% inclusion rate in AI agent recommendation sets. The two surfaces operate on entirely different signals.

What structured product data actually is

Structured product data is machine-readable information about a product, formatted so that AI systems can parse it without interpretation. The primary format is JSON-LD Product schema (schema.org/Product), embedded in your page's HTML. Supplementing that are product feeds - structured files delivered directly to platforms like Perplexity and OpenAI that allow those platforms to index your catalogue for agent-driven discovery.

The key distinction from traditional product content: structured data is not written for humans. It's not the description. It's not the title tag. It's a parallel set of machine-readable fields that tell an AI system exactly what this product is, what it costs, whether it's available, and what category it belongs to - in a format the system can evaluate programmatically without reading a sentence.

When that data is missing, incomplete, or inconsistent, agents don't try to figure it out. They move to the next product. In a catalogue of thousands of SKUs, the agents running product comparisons for buyers will systematically exclude the ones they can't parse - and your analytics won't tell you it's happening.

The fields that determine whether agents include your products

Not all product data fields are equally important for AI agent visibility. These are the ones that determine inclusion versus exclusion:

• 🔑
  GTIN (Global Trade Item Number)

  The universal identifier that lets agents match your product across platforms, compare it with competitors, and verify it's the same item being referenced elsewhere. Without a GTIN, the agent can't cross-reference your product. It's treated as unverifiable and excluded from multi-source comparisons.

• 🏷️
  Brand (as an explicit schema field)

  Not just mentioned in the title - declared as a structured field. AI agents filter by brand programmatically. If brand isn't a schema field, the agent has to infer it from text, which introduces uncertainty and lowers confidence in the recommendation.

• 💷
  Price with currency (machine-readable)

  Displayed price is not the same as schema price. Agents query the schema field, not the rendered HTML. If your price exists only as styled text on the page and not as a structured data field, agents can't evaluate it against budget constraints.

• 📦
  Real-time availability

  AI agents won't recommend out-of-stock products for purchase. More importantly, they need availability updated in real time - not once a day. A product that goes out of stock between feed updates will be recommended to buyers who then can't complete the purchase. That creates agent failure, and agents learn to trust more reliable catalogues.

• 📂
  Product category (using standard taxonomy)

  Custom category labels like "Our Best Picks" or "Summer Collection" are meaningless to an agent. Standard product taxonomies - Google Product Category, GS1 classifications - allow agents to surface your product for the right query type. Without them, the product may never appear for category-level searches.

• 📐
  Specific attributes (dimensions, materials, compatibility)

  This is where most product data falls apart. Agents matching a buyer's specific requirements - "waterproof, size 10, under £150, compatible with crampons" - need those attributes as discrete, queryable fields. A paragraph of prose that mentions these details won't be parsed. The attribute either exists as a structured field or the product is excluded from that query.

Brands with complete product attributes see 3–4 times higher AI agent visibility than those with partial data. That gap is entirely structural - it has nothing to do with product quality, price competitiveness, or brand strength.

The specificity problem: vague data versus queryable data

The most common product data failure isn't missing fields. It's fields that exist but contain vague, non-queryable values.

Same product. The first version cannot be matched to a buyer's specific requirements. The second can. Agents don't penalise vague data - they just exclude the product and move to one they can evaluate with confidence.

The agentic commerce layer that most brands haven't heard of yet

Beyond product schema, a new infrastructure layer is emerging that will determine which stores AI agents can actually purchase from - not just recommend.

Google's Universal Commerce Protocol (UCP), as of Q1 2026, enables AI agents to add products from multiple retailers to a single cart and complete purchases in one transaction. Retailers that implement UCP-compliant product endpoints appear in agent-initiated purchase flows. Those that don't are skipped - even if their products rank well in conventional search and their product schema is complete.

This is the distinction between being discoverable by an AI agent and being purchasable by one. Most current discussion about structured product data focuses on discovery. The next phase is transactional: an agent that can research, select, and buy on a user's behalf - without the user ever visiting your store.

The content layer still matters - but differently

Structured product data determines whether an agent can evaluate and purchase your product. But there's a second surface that structured data doesn't reach: the AI-generated recommendations that appear when buyers ask conversational questions before they're ready to buy.

"What's the best waterproof hiking boot for wide feet?" is not an agent purchase query. It's a research query - and the answer comes from AI-generated content that cites product reviews, buyer guides, and brand pages. This is the ASEO (AI Search Engine Optimisation) layer: optimising your content so that AI platforms cite it when answering research questions that precede a purchase decision.

The two disciplines are different but complementary. Structured product data gets you into the agentic purchase flow. ASEO gets you cited in the research conversation that happens before that flow starts. A brand that dominates both owns the entire buyer journey - from "what should I buy?" to "buy it."

What to do this week

You don't need to rebuild your entire product catalogue. Start with your highest-value SKUs - the products that should be appearing when AI agents match buyer criteria in your category.

For each one, audit: Is the GTIN present? Is brand declared as a schema field? Is price in machine-readable JSON-LD, not just rendered HTML? Is availability updated in real time? Are product attributes specific and queryable rather than descriptive and vague?

Then run a Google Rich Results Test on the product page. If the Product schema isn't returning structured data, an AI agent querying that product can't parse it either. That's the fastest diagnostic available right now - and the most honest signal of your current agent visibility.