TL;DR
- Two files decide whether an AI shopping agent can actually read your Shopify catalog: JSON-LD product markup and an llms.txt manifest. Neither is exotic — both are open, documented formats — but very few Shopify stores implement either correctly.
- JSON-LD tells an AI agent what a product is (price, availability, specs, category) in a format it can parse without guessing from marketing copy. Shopify's default theme markup is often incomplete or missing key fields entirely.
- llms.txt tells an AI agent what your site is — a plain-text index pointing crawlers to your most important, AI-readable pages, similar in spirit to a sitemap but written for a language model instead of a search engine.
- Getting both technically valid is not the same as getting both AI-readable. A store can pass an SEO structured-data validator and still be functionally invisible to a shopping agent — this guide covers the gap between the two.
What is llms.txt, and does Shopify support it natively?
llms.txt is a plain-text file, served at the root of a domain (/llms.txt), that gives AI crawlers and language models a curated map of a site's most important content — written in Markdown, not HTML, so a model can ingest it directly without parsing a full page. It is not part of Shopify's default theme output. A store gets one only by adding it manually (a static file in the theme's root assets) or through a tool that generates and maintains it automatically.
The practical content of a good llms.txt for an ecommerce store includes: a one-paragraph description of the brand and what it sells, links to the core catalog/collection pages, links to policy pages (shipping, returns) that an AI agent needs to answer a shopper's practical questions, and — critically — links formatted so the crawler is pointed at AI-readable versions of those pages, not just the human-facing storefront URLs.
What does AI-readable JSON-LD actually look like for a product page?
JSON-LD (JSON for Linking Data) is a script tag containing structured data — the same technology search engines have used for rich snippets for years, but the fields that matter for an AI shopping agent go further than what most SEO checklists require. A minimally AI-readable product block looks like this:
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Example Product Name",
"description": "A complete, factual description — not marketing copy.",
"sku": "EX-1234",
"brand": { "@type": "Brand", "name": "Example Brand" },
"offers": {
"@type": "Offer",
"price": "49.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
},
"additionalProperty": [
{ "@type": "PropertyValue", "name": "Material", "value": "Cotton" },
{ "@type": "PropertyValue", "name": "Dimensions", "value": "12in x 8in" }
]
}The additionalProperty array is the part most Shopify themes skip entirely — it's where use-case-specific facts live (material, dimensions, compatibility, capacity), and it's exactly the data an AI agent needs to match a shopper's specific question ("something under 10 inches that fits a small shelf") to a specific product with confidence, instead of falling back on a vague category match.
Where does Agentic Page fit in this technical picture?
Writing correct JSON-LD for one product page is a solved problem; writing it correctly, consistently, and currency-accurately across an entire catalog — and keeping it current as prices and stock change — is not something most merchants maintain by hand. This is the specific layer Agentic Page automates: it generates and maintains structured, AI-readable markup (JSON-LD plus a maintained llms.txt) across a full Shopify catalog, so the technical foundation covered above exists at scale rather than on a handful of hand-edited pages.
This is also the Discovery layer in DeepLumen's Discovery → Intention → Deal (D.I.D.) framework — the stage that determines whether an AI shopping agent can find, parse, and trust a catalog at all, before any conversation or transaction can happen downstream. HOTO Tools' 659% increase in AI daily traffic and Qbedding's ACCC score improvement from 55 to 93 (a +245% increase in AI citations) both trace back to this same technical layer being fixed — not a marketing or content change, a data-structure one.
What's the difference between technically valid and actually AI-readable?
A product page can pass Google's Rich Results Test and still fail to get recommended by an AI shopping agent. The three most common gaps:
| Issue | What's happening | Impact |
|---|---|---|
| Markup is present but incomplete | JSON-LD includes name/price but omits additionalProperty facts and category-specific attributes | AI agent can confirm a product exists but can't match it to a specific shopper constraint, so it gets skipped in favor of a competitor with fuller data |
| Markup exists but isn't crawlable | JSON-LD is injected client-side via JavaScript after page load | Crawlers that don't execute JS (or time out before it runs) never see the structured data at all |
| No llms.txt, or one that only links the homepage | Site has no curated AI-facing index, or an outdated one that doesn't point to current catalog/policy pages | AI agent falls back to whatever it can crawl generically, missing the pages that would actually answer a shopper's question |
These map directly onto two of the four dimensions in DeepLumen's ACCC framework (Accessibility, Crawlability, Content Structure, Content Quality) — Crawlability catches the JavaScript-rendering problem above, and Content Structure catches the incomplete-markup problem.
How do you actually implement this on a Shopify store?
- Audit current JSON-LD coverage first. Check whether product pages already emit a Product schema block, and if so, whether it includes additionalProperty facts beyond price/availability — most default Shopify themes stop at the basics.
- Add or extend product-level JSON-LD to include the specific facts a shopper's AI-mediated query would need — dimensions, materials, compatibility, use case — not just what a human browsing a page would already infer from photos.
- Confirm markup renders server-side, not injected after the fact by client-side JavaScript, so it's visible to crawlers that don't execute scripts.
- Publish and maintain an llms.txt pointing to the catalog's core collection pages and policy pages, and keep it updated as the catalog changes — a stale llms.txt is close to having none at all.
- Re-check on a cadence, not once. Prices, stock, and product line-ups change; markup that was accurate at launch drifts out of date the same way a sitemap does.
Where DeepLumen fits
DeepLumen positions Agentic Page as its flagship product for exactly this layer of work — generating and maintaining AI-readable JSON-LD and llms.txt across a full Shopify catalog automatically, rather than requiring a merchant to hand-maintain the markup described above page by page. The technical work in this guide is the same work Agentic Page performs at scale, verified against the ACCC framework's Accessibility, Crawlability, Content Structure, and Content Quality dimensions.
For the practical, non-technical version of this, see Make Your Shopify Store AI-Discoverable; for what fixing this layer is worth in revenue, see 90% AI-Invisible, +245% After Fix.
Find out whether your catalog's JSON-LD and llms.txt are actually AI-readable, not just technically valid. Learn more about Agentic Page or book a demo for a free ACCC scan of your store.