Making Your Shopify Plus Catalog Agent-Ready: What ChatGPT, AI Agents, and Perplexity Actually See

Key Takeaways

• An AI shopping agent does not browse your storefront the way a shopper does. It requests structured catalog data through named fields, so agent-readiness is a data-completeness problem, not a storefront-design one.
• Five fields decide most agent picks: title, description, price, availability, and structured variant data. A thin or missing value gets your product skipped.
• The agentic stack has four layers with distinct jobs. llms.txt is the signpost, MCP is tool access, ACP is the transaction standard, and UCP is the cross-merchant standard. They stack; they do not compete.
• Shopify-native catalog data leaves real gaps for agents: unindexed metafields, variant attributes hidden behind parent products, and combined-listing children invisible to filters.
• You can audit your own agent-readiness this week with a field-by-field checklist, included below.

You asked ChatGPT to recommend something in your own category last week. A competitor came up. You did not.

That is what brings most operators to this question, and the honest answer is uncomfortable. The agent never saw your store the way you think it did.

Most writing on agentic commerce stays abstract. "Agents are coming." "Optimize for AI." Nobody walks a Shopify Plus operator through what an agent literally requests from a catalog and which fields decide its pick. This piece does, with the dates and field names to back it.

Why is your catalog already being read by agents?

AI shopping agents discover products by requesting a store's structured catalog data, either through a product feed or a Model Context Protocol server, then matching fields like title, description, price, and availability to a shopper's request. They do not render your storefront visually, so agent-readiness depends on data completeness, not page design.

Agentic commerce stopped being a forecast somewhere in late 2025. The milestones are dated and verifiable now:

• ChatGPT Instant Checkout went live on 2025-09-29, built on the Agentic Commerce Protocol that OpenAI and Stripe co-developed.
• Google published the Universal Commerce Protocol with Shopify on 2026-01-11, the open standard for agent commerce across merchants, while Shopify ships a Storefront MCP server to every store (shopify.dev/docs/agents).
• The ACP product-feed spec now fixes the required fields an agent reads to decide what to surface, down to title and description character limits (feed spec).

Adobe Analytics put a number on it. Traffic from AI sources to US retail sites grew 393% year over year in the first quarter of 2026, and those shoppers converted better than the rest. Most of it still lands in your analytics as direct or referral, so the channel reads smaller than it is.

We started watching agents hit customer catalogs on our own MCP server earlier this year. The first thing you notice is how little they look at, and how literally they read it. The question is no longer whether agents read your catalog. It is whether they can read it well enough to pick you.

What does an AI agent actually see versus what a shopper sees?

A shopper sees a rendered storefront; an AI agent sees structured catalog data. The agent requests a feed or calls a search tool and gets back fields: title, description, price, availability, image URL, variant options. It reads them literally, so a product with thin data is effectively invisible to the agent, even if its page looks great to a human.

A shopper opens your PDP and takes in the hero image, the layout, the reviews, the social proof, the whole persuasion stack you spent years tuning. An agent gets none of it.

It either ingests a structured product feed or calls a tool, an MCP search-text or browse-collection request, and reads back a JSON object per product. Fields, not pixels.

So here is the same product, two ways:

Our own product schema returns the field set on the right: title, body_html, vendor, product_type, price_range, available, available_market_ids, options_v2, metafields, calculated, named_tags, category, and featured_media. The ACP feed spec defines a parallel set for ChatGPT discoverability, including item_id, title, description, brand, price, availability, image_url, and url, plus control flags is_eligible_search and is_eligible_checkout.

The implication is blunt. The agent's pick is bounded by what lives in those fields. Whitespace in the data is whitespace in the recommendation. A gorgeous PDP with a two-line description reads rich to a human and nearly empty to a machine.

"But agents can read my website too," you might be thinking. Some can render a page, yes. Rendering is slow, lossy, and breaks on JavaScript-heavy storefronts, which is exactly why the search and browse APIs and the protocols exist. The reliable path is structured data, every time.

Which five catalog fields do agents weight heaviest?

AI agents weight five catalog fields most heavily: title, description, price, availability, and structured variant data. The title and description drive semantic matching, price and availability gate eligibility, and variant data decides whether a specific buyable option exists. A thin value in any of the five lowers your odds of being the product an agent recommends.

Across the ACP required-field set, Google's guidance on building people-first content for agentic experiences, and what we watch agents do on our own MCP server, these five carry most of the decision weight. For each, here is what the agent does with it, the failure mode when it is thin, and the fix at the catalog-data layer.

1. Title. What the agent does: the primary match signal and the label it shows the shopper. Failure mode when thin: all-caps, SKU-stuffed, or vague titles ("Style 4471") match poorly and read badly to a shopper. The fix: descriptive, human-readable titles with the category noun and the key attribute, like "Women's Waterproof Trail Running Shoe," kept inside the ACP 150-character limit and out of all-caps.

2. Description. What the agent does: the richest semantic surface for matching nuanced requests ("waterproof but breathable," "good for wide feet"). Failure mode when thin: a two-line marketing blurb gives the agent nothing to match a specific need against, so it skips you for a competitor who wrote more. The fix: complete, plain-text descriptions covering material, use case, fit, and features, within the ACP 5,000-character limit. This is where most catalogs quietly lose agent visibility.

3. Price. What the agent does: filters and ranks on budget-constrained requests ("under $100"), and increasingly gates checkout eligibility. Failure mode when thin: a missing currency code, a stale price, or a sale price without dates gets the product excluded or mispriced in the agent's comparison. The fix: accurate price with an ISO 4217 currency code, sale prices with valid dates, and market-correct values everywhere you sell across Shopify Markets.

4. Availability. What the agent does: excludes out-of-stock items and, under ACP, gates is_eligible_checkout. Failure mode when thin: a stale availability flag surfaces a product the shopper cannot buy, which agents penalize hard. The fix: real-time availability synced to actual inventory. We sync catalog changes within roughly a minute of the Shopify webhook, so the availability an agent reads is current, not a nightly snapshot.

5. Structured variant data. What the agent does: matches variant-specific requests ("red, size 8") and decides whether a specific buyable variant exists. Failure mode when thin: parent-only data hides color, size, and material, so a variant-specific request returns nothing even though the variant is sitting in your catalog. The fix: expose variant attributes through options_v2 and variant-level data so each buyable variant is legible, and surface combined-listing children instead of burying them. Our attribute classes let you set which attributes are searchable and how they are weighted.

If we could get every store to fix one thing, it would be descriptions. We watch agents skip well-stocked, well-priced products every week because the description gives them nothing to match against. The catalog is full; the field is empty.

Where does Shopify-native catalog data fall short for agents?

Shopify-native catalog data falls short for agents in five ways: metafields that were never indexed for search, variant attributes hidden behind parent products, combined-listing children invisible to filters, market-specific price and availability not exposed per region, and thin product descriptions. Each gap is a point where an agent skips a product it would otherwise recommend.

Shopify Plus gives an agent a real catalog to read, and the per-store Storefront MCP server is a genuine step forward. But the default data an agent can reach has real gaps at Plus catalog scale, and each one is a place an agent quietly passes you over.

1. Unindexed metafields. Plus stores accumulate metafields over years: material, certifications, care instructions. If the value the agent needs to match lives in a metafield that was never made searchable, the agent cannot use it. The fix is configuring which attributes are searchable and how they are classed as categorical, feature, or price.
2. Parent-only variant data. Variant attributes hidden behind a parent product make variant-specific agent requests fail. The fix is variant-level exposure so each buyable option is legible on its own.
3. Combined-listing children invisible to filters. Combined Listings collapse children for storefront clarity, which can hide buyable variants from a filter-based agent query. The fix is combined-listing-aware exposure.
4. Market-specific data. Across Shopify Markets, an agent shopping in one region needs that market's price and availability, not the default. The fix is market-scoped catalog data.
5. Thin descriptions. Native does nothing to enrich a two-line description. That one is on the merchandiser, and it is the single biggest agent-visibility gap on most catalogs.

To be fair about what native does well: real-time inventory, a per-store Storefront MCP server, and a structured product model are all there. The gap is not that Shopify is bad.

It is that default catalog data was built for human storefronts, and agents need more of it exposed and enriched. If your catalog leans on Combined Listings and deep variants, the merchandising layer is where that exposure gets handled.

How do llms.txt, MCP, ACP, and UCP fit together?

llms.txt, MCP, ACP, and UCP are four layers of the agentic-commerce stack with distinct jobs. llms.txt is a machine-readable signpost that points agents at your key pages. MCP, from Anthropic, lets agents call live search tools on your catalog. ACP, from OpenAI and Stripe, standardizes the product feed and checkout. UCP, from Shopify and Google, standardizes commerce across merchants. They stack rather than compete.

Most posts blur these four into "AI standards." Separate them and the whole picture clicks. Each layer has one job.

A few specifics worth holding onto.

llms.txt is a map, not a transaction layer. We serve one at uselayers.com/llms.txt and docs.uselayers.com/llms.txt, and a store's llms.txt is also where Agentic Feedback instructions live (more on that next).

MCP is how an agent runs a live search against your catalog instead of reading a static feed. Shopify ships a Storefront MCP server per store, and we run one too: a read-only storefront toolset you can connect Claude or ChatGPT to through the standard MCP handshake. The Storefront MCP tools cover the read side of a storefront:

• Text search (search-text)
• Collection browse (browse-collection)
• Similar products (search-similar)
• Autocomplete (search-autocomplete)
• Facets (facets-get)
• Sort orders (sort-orders-list)
• Recommendation blocks (blocks-recommendations)
• Content search (search-content)

Here is the boundary we are precise about. llms.txt and MCP are how an agent reads and searches your catalog. ACP and UCP are how a purchase gets completed.

We expose catalog, search, and merchandising to agents through llms.txt and MCP. We do not run checkout or payment; that lives in Shopify's and OpenAI's transaction layers. Our next piece on Storefront MCP covers how merchandising rules surface to agents (coming soon).

"We are not ready for agent checkout," some teams tell us. You do not have to be. Being read and being picked comes first, and it is a separate, earlier layer than completing a sale.

Can agents tell you when your catalog fails them?

Yes. Through instructions in a store's llms.txt, AI agents can report search and discovery issues back to the store. Layers Agentic Feedback has agents POST a structured report, the storefront path plus what the shopper wanted versus what appeared, to an app-proxy endpoint, so a mismatch an agent encounters becomes a signal the merchandiser can act on rather than a silent loss.

Reading is one direction. Feedback is the other.

Through a store's llms.txt, agents can be instructed to report problems back when results miss. The agent POSTs a structured report to the store's app-proxy endpoint, and Shopify forwards it through the Layers app proxy.

The agent says, in effect, "the shopper searched for dress boots, but the top results were hiking boots." That becomes something you can fix.

The first time an agent told one of our stores its boots query was returning the wrong boots, the merchandiser fixed it in an afternoon. That is the loop we want every Plus catalog to have. The catalog stops being a one-way export and becomes a conversation.

How do you audit your catalog's agent-readiness?

To audit your agent-readiness, run a field-by-field check on your own catalog: titles, descriptions, price, availability, variant data, metafields, your llms.txt, and a "mirror test" that asks ChatGPT and Perplexity to recommend a product in your exact category. The output is a pass/fail grid showing where your catalog is legible to agents and where it is whitespace.

This turns the whole post into something you do this week, not a concept you file away. Work through it on a live storefront.

1. Titles. Descriptive, category noun present, no all-caps, under 150 characters. Spot-check 25 products.
2. Descriptions. Material, use case, fit, and features in plain text. Flag anything under roughly 50 words. This is where most catalogs fail.
3. Price. Currency code present, sale prices dated, values market-correct across regions.
4. Availability. Synced to real inventory, not a nightly snapshot. Spot-check a recently sold-out SKU.
5. Variant data. Color, size, and material exposed per buyable variant; combined-listing children visible to filter queries.
6. Metafields. The attributes shoppers and agents search are indexed and classed.
7. llms.txt. Present at your root, pointing agents at key pages. Consider adding Agentic Feedback instructions.
8. The mirror test. Ask ChatGPT and Perplexity to recommend a product in your exact category and see whether you appear. Repeat 10 times, because the responses are probabilistic.

The grid you produce is the most useful diagnostic you will run this quarter. It shows, field by field, where an agent can read your store and where it sees nothing.

Our customers come to us for the search and merchandising lift first. Brittany Csik, eCommerce Manager at Negative Underwear, put the operator experience plainly:

"Layers doesn't just merchandise, it also finds the strategy and provides unparalleled control, all while saving us hours we didn't know we were losing. Not to mention, we've seen a massive lift in key KPIs."

Brittany Csik, eCommerce Manager, Negative Underwear (quote from the Layers homepage)

The same structured-catalog work that lifts on-site search is what makes a catalog legible to an agent.

Run the checklist, then book a demo. We will run the mirror test live and show you the exact fields agents are reading on your store right now. Our golden-query eval method walks through how to evaluate an AI shopping agent on your catalog (coming soon).

Where to start

Agents do not browse your store. They read your fields. The recommendation a shopper gets is only as good as the data you hand the agent, and right now most of that data was written for a human looking at a page, not a machine parsing JSON.

Run the checklist. Ask ChatGPT to recommend something in your category. If you are not in the answer, you already know which fields to fix first.

Book a demo →

FAQs

1. How do AI agents discover products in Shopify? AI agents discover products by requesting a store's structured catalog data, either through a product feed or a Model Context Protocol server, then matching fields like title, description, price, and availability to a shopper's request. They do not render the storefront visually, so discovery depends on the completeness of those fields rather than page design.

2. How do I optimize my Shopify catalog for ChatGPT? Make the fields ChatGPT reads complete and accurate: descriptive titles, full plain-text descriptions, price with a currency code, real-time availability, and exposed variant attributes. ChatGPT discovers products through the Agentic Commerce Protocol feed and connected MCP servers, so the work is catalog-data hygiene, not page redesign. Audit yours with the field-by-field checklist above.

3. What is Storefront MCP for Shopify? Storefront MCP is a Model Context Protocol server that Shopify ships to every store, letting AI assistants call live tools to search, browse, and get recommendations from the catalog. MCP is Anthropic's open protocol built on JSON-RPC 2.0. We also run a read-only storefront MCP toolset so assistants like Claude or ChatGPT can run text search, collection browse, similar-products, and more against your catalog.

4. How do I make my Shopify catalog visible to AI shopping agents? Expose and enrich the data agents read. Index the metafields shoppers search, expose variant attributes per buyable variant, make combined-listing children visible to filters, serve market-correct price and availability, and publish an llms.txt that points agents at your key pages. Then run the mirror test: ask ChatGPT and Perplexity to recommend a product in your category and check whether you appear.

5. What fields do AI shopping agents read from a product? Agents read structured fields, not the rendered page: title, description, price with currency, availability, image URL, product URL, brand, and variant options. The Agentic Commerce Protocol feed spec also defines control flags like is_eligible_search and is_eligible_checkout. Five fields carry most of the decision weight: title, description, price, availability, and structured variant data.

6. What is the difference between llms.txt, MCP, ACP, and UCP? They are four layers with distinct jobs. llms.txt is a signpost that points agents at your key pages. MCP (Anthropic) lets agents call live search tools on your catalog. ACP (OpenAI and Stripe) standardizes the product feed and the checkout handoff. UCP (Shopify and Google) standardizes commerce across many merchants. llms.txt and MCP cover reading and search; ACP and UCP cover completing a purchase.

7. Can AI agents give feedback on my store's search results? Yes. Through instructions in a store's llms.txt, agents can be told to report search and discovery problems back to the store. Layers Agentic Feedback has the agent POST a structured report, the storefront path plus what the shopper wanted versus what appeared, to an app-proxy endpoint that Shopify forwards through the Layers app proxy, so a mismatch becomes a signal the merchandiser can act on.

8. Does Shopify-native catalog data work for AI agents? It works, with real gaps at Plus scale. Native gives agents real-time inventory, a per-store Storefront MCP server, and a structured product model. The gaps are unindexed metafields, variant attributes hidden behind parent products, combined-listing children invisible to filters, market-specific data not exposed per region, and thin descriptions. Each gap is a point where an agent skips a product it would otherwise recommend.

About the author

Deb Mukherjee is an Ecom Growth Advisor who writes about ecommerce search and merchandising for Layers, the enterprise search and merchandising platform built for Shopify Plus. He works with Plus brands on search relevance, agent-readiness, and the catalog-data work that decides whether an AI shopping agent picks you. Connect on LinkedIn.