Product Research · Sep 19, 2026 · 18 min

Agent-Ready Product Data: How to Optimize Your Catalog for ChatGPT Ads, Meta Muse & Shopify Agentic Commerce

Sean Travis

Founder · Kaldon

TLDR

Agent-ready product data is structured, machine-parsable catalog information that AI shopping agents can query, interpret, and act on. In September 2026, Shopify enabled agent visibility by default, Amazon blocked major AI crawlers in robots.txt, and ChatGPT Ads, Meta Muse, and agentic storefronts now require 95%+ GTIN coverage, <15-minute inventory lag, and complete JSON-LD schema. If agents can't parse your catalog, they'll recommend competitors instead.

TLDR. Agent-ready product data is structured, machine-parsable catalog information that AI shopping agents can query, interpret, and act on. In September 2026, Shopify enabled agent visibility by default, Amazon blocked major AI crawlers in robots.txt, and ChatGPT Ads, Meta Muse, and agentic storefronts now require 95%+ GTIN coverage, <15-minute inventory lag, and complete JSON-LD schema. If agents can’t parse your catalog, they’ll recommend competitors instead.

What Is Agent-Ready Product Data?

Agent-ready product data is structured, machine-parsable catalog information that AI shopping agents can query, interpret, and act on. In September 2026, Shopify enabled agent visibility by default, Amazon blocked major AI crawlers in robots.txt, and ChatGPT Ads, Meta Muse, and agentic storefronts now require 95%+ GTIN coverage, <15-minute inventory lag, and complete JSON-LD schema. If agents can’t parse your catalog, they’ll recommend competitors instead.

Your product catalog is not just for human shoppers anymore. ChatGPT Ads, Meta Muse, Shopify Sidekick, and Google Gemini are now browsing, comparing, and recommending products on behalf of shoppers. They need data that is complete, consistent, trustworthy, and exposed via APIs or structured feeds. If your catalog is messy, stale, or HTML-only, agents will skip you and recommend competitors with cleaner data.

This is unmet demand discovery in reverse: instead of finding what shoppers want, you’re making sure agents can find what you’re shipping. The same way you optimize for Google’s search crawlers, you now optimize for ChatGPT’s shopping agents.

On September 15, 2026, AWS and Salesforce announced expanded integrations that put CRM data, context, and skills inside Amazon Quick for AI agents, with no custom integration. On September 10, Shopify emphasized that Sidekick is becoming a more important part of the merchant experience, reinforcing that AI agents are now a default surface for product discovery across all plans. As of September 9, 2026, amazon.com’s robots.txt blocked every major AI crawler and shopping agent, including GPTBot, ClaudeBot, PerplexityBot, Google-Extended, GoogleAgent-Shopping, and meta-externalagent. This means Amazon product data can’t be scraped by agents directly, and DTC/Shopify merchants who allow agent access have a structural visibility advantage.

Why Agent-Ready Product Data Matters in 2026

AI shopping agents are live in production across four major surfaces: ChatGPT Ads, Meta Muse, Shopify agentic storefronts (Gemini, Copilot), and voice assistants (Alexa for Shopping). Each agent depends on structured product data to discover, compare, and recommend products. If your catalog doesn’t meet agent-ready standards, you’re invisible.

ChatGPT Ads launched in early 2026 and lets merchants pay for placement in ChatGPT’s shopping recommendations. The ads are generated from your product feed. If your feed has missing GTINs, empty descriptions, or stale pricing, ChatGPT won’t run your ads.

Meta Muse is Meta’s AI shopping assistant inside Instagram and Facebook. It browses catalogs via Meta’s commerce feeds and Shopify’s Catalog API. It needs complete Product and Offer schema, per-variant pricing, and real-time inventory.

Shopify agentic storefronts went live in June 2026 with agent visibility turned on by default. Google Gemini, Microsoft Copilot, and ChatGPT can now discover Shopify products via the Universal Commerce Protocol (UCP), build carts, and pass shoppers to checkout. Merchants can opt out, but opting in requires clean data: GTINs, variant-level offers, JSON-LD schema, and structured attributes in metafields.

Alexa for Shopping launched “Update Me When” on September 1, 2026, enabling Alexa to monitor Amazon’s catalog and parts of the wider web and send personalized notifications when relevant product events occur, without a new explicit query. Shoppers can select multiple products from search results and have Alexa compare them on features, prices, and reviews. This is agent-initiated discovery, where the agent surfaces products without a shopper query.

The common thread: all four surfaces need structured, machine-readable product data. Prose-only descriptions, HTML-only PDPs, and stale inventory break agent workflows. Agents don’t scrape your site and guess. They read feeds, APIs, and JSON-LD. If your data is missing or wrong, agents skip you.

This is covered in more depth in AI Agent Commerce Product Discoverability in 2026 and AI Shopping Agents Product Data Optimization.

The Three-Tier Agent-Ready Data Model

AI commerce protocols (Agentic Commerce Protocol, Universal Commerce Protocol, Model Context Protocol) all assume a clean, enriched, real-time product catalog as their foundation. A late-August 2026 technical resource from MongoDB defines three tiers buyers now reference explicitly in requirements for AI commerce platforms:

Tier 1: Identity and Price (required)

GTIN, MPN, SKU
Title, brand
Price, currency, sale price
Availability state (in stock, out of stock, backorder)
Condition (new, refurbished, used)
Taxonomy (product type, category)
Image URL, product URL

Tier 2: Structured Attributes (expected)

Material, dimensions, weight
Color, size, capacity
Compatibility, certifications
Ingredients, care instructions

Tier 3: Agentic Context (differentiating)

Use-case and occasion tags
Q&A pairs
Compatible accessories and substitutes
Fit and suitability guidance
Sustainability attributes
Structured shipping and return policies
Ratings, review counts
Vector embeddings

Agents need Tier 1 to function. They expect Tier 2 to differentiate. They use Tier 3 to personalize and recommend. If you only have Tier 1, you’re discoverable but not competitive. If you have all three tiers, you’re the product agents recommend.

Agent-Ready Data Requirements by Surface

Each AI shopping surface has specific data requirements. Here’s what each agent needs to discover and recommend your products.

ChatGPT Ads

ChatGPT Ads pull from your Google Merchant Center feed. The feed must meet Google’s product data specification and ChatGPT’s additional requirements:

GTIN coverage: 95%+ of branded products must have valid GTINs
Core attribute fill: 95%+ fill on title, price, availability, brand, category, condition, image, shipping
Price and availability lag: <15 minutes via Content API and real-time catalog updates
Image quality: High-resolution product images (1200x1200px minimum)
Description completeness: Clear, factual descriptions with key attributes (not marketing fluff)

ChatGPT won’t run ads for products with missing GTINs, empty descriptions, or stale pricing. It also won’t show products flagged as out of stock in your feed, even if your site says “in stock.”

Meta Muse

Meta Muse reads from Meta commerce feeds (Facebook/Instagram Shop) and Shopify Catalog API for Shopify merchants. Requirements:

Product and Offer schema: Every product page must include JSON-LD Product and Offer schema with name, brand, description, price, currency, availability, SKU, and aggregate rating where applicable
Variant-level offers: Each product variant must have its own Offer object with distinct SKU, price, and availability
Real-time inventory: Inventory must reflect reality within 15 minutes
Shipping and return policies: Structured MerchantReturnPolicy and shippingDetails in JSON-LD or feed attributes

Meta Muse will not recommend products with HTML-only data, no API or JSON-LD coverage, or incomplete variant information.

Shopify Agentic Storefronts (Gemini, Copilot)

Shopify agentic storefronts (Google Gemini, Microsoft Copilot) read product data via Shopify Catalog API and Universal Commerce Protocol (UCP). Requirements:

HTML-first data: Core product data (name, price, description, availability, key attributes) must exist in the initial HTML response, not rely on JavaScript
JSON-LD completeness: Every product page must include JSON-LD Product, Offer, AggregateRating, MerchantReturnPolicy, and shippingDetails
Variant-level data: Each variant must have its own Offer object with distinct SKU, price, and availability
Structured attributes in metafields: Materials, dimensions, allergens, fit, and other attributes must be stored in Shopify metafields, not in prose descriptions
GTINs and barcodes: All products must have GTINs or MPNs in the product data
FAQ content: 5-8 FAQs per product, either in Shopify metafields or a knowledge base app
robots.txt access: Ensure robots.txt allows GPTBot, ClaudeBot, PerplexityBot, Google-Extended, and GoogleAgent-Shopping (not blocked)

Shopify turned on agent visibility by default in June 2026. If your catalog doesn’t meet these standards, agents will surface incorrect information or skip your products entirely.

Alexa for Shopping

Alexa for Shopping monitors Amazon’s catalog and parts of the wider web for agent-initiated discovery. For Amazon sellers:

Product features: Clear, structured bullet points with key attributes
Pricing: Real-time pricing via Amazon seller API
Reviews: Aggregate rating and review count
Availability: Real-time inventory via Seller Central or FBA

For DTC/Shopify merchants, Alexa can compare products if:

Your site has Product schema with offers, reviews, and attributes
Your robots.txt allows Alexa’s user agent
Your pricing and inventory are updated in near real-time

How to Audit Your Catalog for Agent-Readiness

Before you optimize, you need to know where you stand. Here’s how to audit your catalog for agent-ready data.

Step 1: Check GTIN Coverage

Export your product catalog to a CSV. Count how many SKUs have a non-empty GTIN, UPC, EAN, or ISBN. Divide by total SKUs. If you’re below 95% for branded products, agents will skip your catalog.

Walmart Marketplace requires GTIN, UPC, EAN, or ISBN for all products. Amazon requires GTINs for most categories. Shopify agentic storefronts expect GTINs for all products.

If you’re missing GTINs:

Branded products: Contact your supplier or manufacturer for GTINs
Private label: Purchase GTINs from GS1 (the official GTIN authority)
Handmade or custom: Use MPNs (manufacturer part numbers) or SKUs as fallback identifiers

Step 2: Check Core Attribute Fill

Export your product catalog to a CSV. For each SKU, check if these fields are non-empty:

Title
Description
Price
Availability (in stock, out of stock, backorder)
Brand
Category or product type
Condition (new, refurbished, used)
Image URL
Product URL

Calculate fill rate for each field: (non-empty count / total SKUs). Target: 95%+ for all core fields.

If you’re below 95% for any field, agents won’t show those products or will show incorrect information.

Step 3: Check Variant-Level Data

If you sell products with variants (size, color, material), check if each variant has:

Distinct SKU
Distinct price (if prices vary by variant)
Distinct availability (if inventory varies by variant)
Distinct image (if appearance varies by variant)

Agents need variant-level data to answer questions like “Do you have this in size large?” or “How much is the red one?” If your variants are title hacks (“T-Shirt - Red” vs “T-Shirt - Blue” as separate products), agents will treat them as unrelated products.

Step 4: Check JSON-LD Schema

View the HTML source of 10 random product pages. Search for <script type="application/ld+json">. Check if you have:

Product schema with name, brand, description, image, offers
Offer schema with price, priceCurrency, availability, url, sku
AggregateRating schema (if you have reviews)
MerchantReturnPolicy schema (if you have a return policy)
shippingDetails schema (if you have shipping info)

If any of these are missing, agents can’t read your product data correctly. Shopify themes include Product and Offer schema by default, but you may need to add MerchantReturnPolicy and shippingDetails manually.

Step 5: Check Price and Inventory Lag

Make a test price change on one product. Wait 5 minutes. Check if the new price appears in:

Your Google Merchant Center feed
Your Meta commerce feed
Your Shopify Catalog API (if Shopify)
Your product page JSON-LD

If the new price doesn’t appear within 15 minutes, agents will show stale pricing. Real-time agents (ChatGPT Ads, Meta Muse) require <15-minute lag for price and inventory.

For Shopify merchants, enable real-time inventory updates in Settings → Markets → Preferences. For Amazon sellers, use Seller Central API or FBA for real-time inventory. For Google Merchant Center, use Content API for Shopping instead of scheduled feeds.

Step 6: Check robots.txt Access

View your site’s robots.txt file at yourdomain.com/robots.txt. Check if you have Disallow rules for:

GPTBot (OpenAI)
ClaudeBot (Anthropic)
PerplexityBot (Perplexity)
Google-Extended (Google)
GoogleAgent-Shopping (Google)
meta-externalagent (Meta)

If any of these are blocked, agents can’t discover your products. Remove the Disallow rules or add explicit Allow rules for these user agents.

As of September 9, 2026, amazon.com’s robots.txt blocks all major AI crawlers. Shopify merchants who allow agent access have a structural visibility advantage.

How to Optimize Your Catalog for Agent-Readiness

Once you’ve audited your catalog, here’s how to fix the gaps.

1. Fill Missing GTINs

For branded products, contact your supplier or manufacturer for GTINs. For private label products, purchase GTINs from GS1. For handmade or custom products, use MPNs or SKUs as fallback identifiers.

In Shopify, add GTINs to the Barcode field in product variants. In Google Merchant Center, map the barcode field to the gtin attribute. In Meta commerce feeds, map the barcode field to the gtin attribute.

2. Fill Missing Core Attributes

For each product, ensure these fields are non-empty:

Title: Clear, concise, includes brand and key attribute (e.g., “Nike Air Max 90 Sneakers - White/Black - Men’s Size 10”)
Description: Answer-first format (what it is, who it’s for, why it matters), 150-300 words, includes key attributes
Price: Current price in your store’s currency
Availability: In stock, out of stock, or backorder
Brand: Exact brand name (no typos, no abbreviations)
Category: Product type or category (use Google product taxonomy where possible)
Condition: New, refurbished, or used
Image URL: High-resolution product image (1200x1200px minimum)
Product URL: Canonical URL for the product page

For Tier 2 attributes (material, dimensions, weight, color, size, capacity), add them to:

Shopify: Custom metafields or product variants
Google Merchant Center: Additional attributes in your feed (material, size, color, age_group, gender)
Meta commerce feeds: Custom fields or variant attributes

3. Structure Variants Correctly

If you sell products with variants, structure them as a single product with multiple variants, not as separate products. Each variant should have:

Distinct SKU
Distinct price (if prices vary)
Distinct availability (if inventory varies)
Distinct image (if appearance varies)

In Shopify, use the built-in variant system. In Google Merchant Center, use item_group_id to link variants of the same product. In Meta commerce feeds, use item_group_id or the Shopify Catalog API variant structure.

4. Add JSON-LD Schema

If your product pages don’t include JSON-LD schema, add it. Most Shopify themes include Product and Offer schema by default. For custom themes or non-Shopify sites, add:

Product schema with name, brand, description, image, offers
Offer schema with price, priceCurrency, availability, url, sku
AggregateRating schema (if you have reviews)
MerchantReturnPolicy schema with returnPolicyCategory, returnWithin, returnFees
shippingDetails schema with shippingRate, deliveryTime

Example Product schema:

{ “@context”: “https://schema.org/”, “@type”: “Product”, “name”: “Nike Air Max 90 Sneakers”, “brand”: {“@type”: “Brand”, “name”: “Nike”}, “description”: “Classic Air Max 90 sneakers with visible Air unit.”, “image”: “https://example.com/images/nike-air-max-90.jpg”, “offers”: { “@type”: “Offer”, “url”: “https://example.com/products/nike-air-max-90”, “priceCurrency”: “USD”, “price”: “120.00”, “availability”: “https://schema.org/InStock”, “sku”: “NIKE-AM90-WHT-10” } }

For Shopify merchants, use the JSON-LD for SEO app or edit your theme’s product.liquid file to add schema.

5. Enable Real-Time Price and Inventory Updates

For Shopify merchants:

Enable real-time inventory updates in Settings → Markets → Preferences
Use Shopify’s Catalog API for agent access (enabled by default)
Install a real-time inventory sync app if you use external inventory systems

For Google Merchant Center:

Use Content API for Shopping instead of scheduled feeds
Enable automatic item updates for price and availability
Set up supplemental feeds for inventory-only updates

For Meta commerce feeds:

Use Facebook Catalog Manager API for real-time updates
Enable automatic item updates for price and availability

For Amazon sellers:

Use Seller Central API or FBA for real-time inventory
Enable automated pricing if you use repricing tools

6. Add FAQ Content

Agents use FAQ content to answer shopper questions without human intervention. Add 5-8 FAQs per product, covering:

Sizing and fit
Materials and care instructions
Shipping and delivery
Returns and exchanges
Compatibility and use cases

In Shopify, add FAQs to:

Product metafields (custom fields for FAQ question and answer)
Product description (FAQ section at the bottom)
Knowledge base app (free apps like HelpLab or HelpCenter)

In Google Merchant Center, add FAQs to the description attribute or use the custom_label attribute for structured Q&A.

For more on how agents use FAQ content, see Brand Visibility in ChatGPT, Perplexity & Gemini.

7. Update robots.txt

If your robots.txt blocks AI crawlers, remove the Disallow rules or add explicit Allow rules for:

GPTBot (OpenAI)
ClaudeBot (Anthropic)
PerplexityBot (Perplexity)
Google-Extended (Google)
GoogleAgent-Shopping (Google)
meta-externalagent (Meta)

Example robots.txt:

User-agent: GPTBot Allow: /

User-agent: ClaudeBot Allow: /

User-agent: PerplexityBot Allow: /

User-agent: Google-Extended Allow: /

User-agent: GoogleAgent-Shopping Allow: /

User-agent: meta-externalagent Allow: /

Do not block these agents if you want your products to appear in ChatGPT Ads, Meta Muse, Shopify agentic storefronts, or AI-powered search.

Agent-Ready Data as a Competitive Moat

Agent-ready product data is not just a compliance checklist. It’s a competitive moat. If your catalog is cleaner, more complete, and more up-to-date than your competitors’, agents will recommend you first.

The 5-phase Kaldon platform automates agent-ready data hygiene across Discover, Build, Create, Launch, and Grow. Instead of manually auditing GTINs, attribute fill, JSON-LD schema, and inventory lag, Kaldon surfaces gaps and recommends fixes in real-time. Start your free trial to see how agent-ready your catalog is today.

Common Agent-Ready Data Mistakes

Here are the most common mistakes that break agent workflows:

HTML-only data: If your product data only exists in HTML (not in feeds, APIs, or JSON-LD), agents can’t read it. Agents don’t scrape your site and guess. They read structured data.

Stale inventory: If your inventory is stale (more than 15 minutes behind reality), agents will show out-of-stock products or miss in-stock products. Real-time agents require <15-minute lag for price and inventory.

Missing GTINs: If you’re missing GTINs for branded products, agents will skip your catalog. Target: 95%+ GTIN coverage for branded products.

Variant title hacks: If you sell variants as separate products (“T-Shirt - Red” vs “T-Shirt - Blue”), agents will treat them as unrelated products. Use the built-in variant system in Shopify or item_group_id in Google Merchant Center.

Prose-only policies: If your shipping, return, and refund policies only exist in prose (not in structured JSON-LD or feed attributes), agents can’t parse them. Add MerchantReturnPolicy and shippingDetails schema to your product pages.

Blocked robots.txt: If your robots.txt blocks AI crawlers, agents can’t discover your products. Remove Disallow rules for GPTBot, ClaudeBot, PerplexityBot, Google-Extended, GoogleAgent-Shopping, and meta-externalagent.

Incomplete schema: If your JSON-LD schema is missing Offer, AggregateRating, MerchantReturnPolicy, or shippingDetails, agents can’t read your product data correctly. Add all five schema types to every product page.

Agent-Ready Data and Unmet Demand Discovery

Agent-ready product data is the flip side of unmet demand discovery. Instead of finding what shoppers want, you’re making sure agents can find what you’re shipping.

If agents can’t parse your catalog, they’ll recommend competitors instead. This is unmet demand at the agent layer: shoppers want your product, but agents can’t surface it, so the demand goes unmet.

The solution is the same as unmet demand discovery: data hygiene, structured fields, and policy documentation. The difference is that agents are more literal than humans. They don’t guess, they don’t infer, and they don’t scrape. They read structured data or they skip you.

Kaldon’s 5-phase platform treats agent-ready data as a core launch requirement, not an afterthought. In the Discover phase, Kaldon surfaces GTIN coverage, attribute fill, and schema completeness for your niche. In the Build phase, Kaldon recommends GTINs, attributes, and FAQ content for your product. In the Create phase, Kaldon generates JSON-LD schema and agent-ready descriptions. In the Launch phase, Kaldon audits your feed, API, and storefront for agent-readiness. In the Grow phase, Kaldon monitors price lag, inventory lag, and schema drift in real-time.

See how Kaldon optimizes your catalog for agent-readiness or start your free trial to audit your catalog today.

Frequently asked questions

What is agent-ready product data?

Agent-ready product data is structured, machine-parsable catalog information that AI shopping agents can query, interpret, and act on. It requires 95%+ GTIN coverage, <15-minute inventory lag, complete JSON-LD schema, and variant-level offers.

Which AI shopping agents need agent-ready data?

ChatGPT Ads, Meta Muse, Shopify agentic storefronts (Gemini, Copilot), and Alexa for Shopping all require agent-ready product data. Each agent reads from feeds, APIs, or JSON-LD schema, not HTML scraping.

How do I check if my catalog is agent-ready?

Export your catalog to CSV and check GTIN coverage (95%+ target), core attribute fill (95%+ target), variant-level data, JSON-LD schema completeness, price/inventory lag (<15 minutes), and robots.txt access for AI crawlers.

What happens if my catalog is not agent-ready?

If agents can’t parse your catalog, they’ll recommend competitors instead. Missing GTINs, stale inventory, HTML-only data, and blocked robots.txt all break agent workflows and make your products invisible.

Sources & citations

agent-ready product dataChatGPT AdsMeta MuseShopify agentic commerceAI shopping agentsproduct data optimizationJSON-LD schemaGTIN coverageeCommerce intelligence

Last updated Sep 19, 2026

Try Kaldon

See the pipeline for yourself.

Start with 2 free analyses. No credit card required.

Start Free