What "invisible to AI agents" actually means
A human shopper forgives a lot. They read a price off a banner image, wait for a page to finish loading, and click through a slow checkout because they already want the product. An AI shopping agent forgives nothing. It reads what is machine-readable, it verifies what it can verify, and when a field is missing or ambiguous it does not guess. It moves on to a store where the answer is unambiguous.
So the question is not whether your storefront looks good to people. It is whether an agent can find your product, confirm the price and availability, trust that the item it is buying is the item you listed, and complete a purchase without a person stepping in. When any of those break, your catalogue is effectively invisible, no matter how much traffic it gets from human browsers today.
Below are twelve concrete signs that agents cannot read or trust your catalogue. Each one is something you can check yourself. For every sign you will find what it looks like, why an agent fails on it, and the fix in a single line. Start with the summary table, then read the detail for the signs that apply to you.
The 12 signs at a glance
| Sign | Why agents fail on it | The fix |
|---|---|---|
| 1. No schema.org Product or Offer markup | Nothing tells the agent this page is a product or what it costs | Add valid Product and Offer JSON-LD to every product page. |
| 2. No machine-readable feed | The agent must scrape page by page instead of reading the catalogue at once | Publish a structured product feed and keep it in sync. |
| 3. Images with no alt text or structured attributes | Colour, size, and material live only in pixels the agent cannot parse | Add alt text and expose variant attributes as data, not just images. |
| 4. Price only in rendered JavaScript | The price is absent until a browser executes scripts the agent may not run | Put price in server-rendered HTML and in Offer markup. |
| 5. robots.txt blocks AI crawlers | The agent is refused at the door before it reads a single product | Allow the agent user-agents you want to sell to. |
| 6. No llms.txt | The agent has no map of what matters and wastes effort or gives up | Publish an llms.txt pointing to your feed and key pages. |
| 7. Account required before checkout | A forced signup wall stops an autonomous purchase cold | Offer a guest or programmatic checkout path. |
| 8. Unclear stock or availability | The agent cannot tell if the item can actually be bought right now | Expose availability in Offer markup and the feed. |
| 9. Policies not machine-readable | Returns, shipping, and warranty are buried in prose the agent will not trust | Structure policy facts as data the agent can read. |
| 10. Slow pages | The agent times out or deprioritises a store that responds slowly | Meet Core Web Vitals and serve fast, cacheable pages. |
| 11. No canonical URL | Duplicate URLs split trust and confuse which page is the real product | Set one canonical URL per product. |
| 12. Inconsistent product identifiers | The agent cannot match, compare, or reorder an item it cannot identify | Use stable GTIN, MPN, and SKU across every surface. |
1. No schema.org Product or Offer markup
What it looks like: your product pages are plain HTML with headings, paragraphs, and an add to cart button, and nothing else. View the source and there is no application/ld+json block describing the item.
Why an agent fails: without schema.org Product and Offer markup, the agent has no reliable signal that the page is a product at all, let alone what it costs or whether it is in stock. It has to infer everything from layout, which is fragile and easy to get wrong. Google documents Product structured data as the way to make product details explicit to machines, and the same markup is what shopping agents lean on. See Google's product structured data guidance.
The fix: add valid Product and Offer JSON-LD, including name, price, currency, and availability, to every product page.
2. No machine-readable feed
What it looks like: the only way to see your full range is to click through category pages. There is no single file or endpoint that lists every product with its attributes.
Why an agent fails: forcing an agent to crawl page by page is slow, error prone, and easy to rate limit. A structured feed lets the agent ingest your whole catalogue in one pass and keep a fresh copy, which is exactly what the product feed agents can read is for. Without it, comparison and reorder flows either miss products or fall back to stale data.
The fix: publish a structured product feed covering the full catalogue and keep it in sync with your live stock and prices.
3. Images with no alt text or structured attributes
What it looks like: a beautiful gallery where the colour, size, material, and even the model name only appear inside the photos. The alt attributes are empty or say "image1".
Why an agent fails: an agent reads text and structured data far more reliably than it reads pixels. If "midnight blue", "organic cotton", and "size 42" live only in an image, the agent cannot filter, match, or confirm the variant a shopper asked for. Alt text is also a long standing accessibility requirement, so the fix helps human users too.
The fix: write meaningful alt text and expose every variant attribute as structured data, not only inside images.
4. Price only in rendered JavaScript
What it looks like: the price is blank in the raw HTML and only appears after the page runs its scripts. Disable JavaScript in your browser and the price disappears.
Why an agent fails: many agents fetch the server response and do not fully execute client-side JavaScript, or they execute it inconsistently. If the price is injected late, the agent may read no price, an old price, or a placeholder, and a purchase built on an uncertain price is one it will refuse to complete.
The fix: render the price in the server response and mirror it in Offer markup so it is present without script execution.
5. robots.txt blocks AI crawlers
What it looks like: your robots.txt disallows the user-agents that AI systems use to crawl, either explicitly or through a broad rule copied from an old template.
Why an agent fails: the agent is turned away before it can read anything. Blocking AI crawlers is a legitimate choice for some publishers, but for a merchant who wants to sell through agents it is self-defeating. Review the robots.txt specification and decide deliberately which agents you allow.
The fix: allow the AI agent user-agents you want to sell to, and block only the ones you have a real reason to exclude.
6. No llms.txt
What it looks like: there is no /llms.txt file at your root. An agent arriving at your domain has no concise map of what your site offers or where the important data lives.
Why an agent fails: without a signpost, the agent either crawls broadly and wastes its budget or gives up on the parts that matter. The llms.txt proposal is an emerging convention for giving language model based agents a clean, prioritised entry point. It is not yet a universal standard, so treat it as a low cost signal rather than a guarantee.
The fix: publish an llms.txt at your root that points to your product feed, key category pages, and policies.
7. Account required before checkout
What it looks like: an agent cannot get past a signup or login wall. There is no guest checkout, and every purchase demands a human to create and verify an account.
Why an agent fails: an autonomous purchase stops the moment it hits a step only a human can clear. Emerging checkout standards such as the Agentic Commerce Protocol assume a path the agent can complete on the shopper's behalf, with the shopper's mandate, not a manual signup detour.
The fix: offer a guest or programmatic checkout path that an authorised agent can complete end to end.
8. Unclear stock or availability
What it looks like: availability is a coloured badge or a sentence like "usually ships soon", with nothing an agent can read as a definite yes or no.
Why an agent fails: the agent needs to know whether the item can actually be bought right now before it commits a shopper's money. Vague or image based availability forces it to guess, and it will not guess with someone else's budget. Ambiguous stock is one of the fastest ways to lose an agent-driven sale.
The fix: expose availability as a defined value in Offer markup and in your feed, and keep it accurate.
9. Policies not machine-readable
What it looks like: returns, shipping times, and warranty terms live in long prose pages written for people, with the key facts scattered through paragraphs.
Why an agent fails: an agent acting for a cautious shopper wants to confirm that returns are free for thirty days or that shipping is included before it buys. If those facts are only in prose, the agent either misreads them or declines to rely on them, and a purchase it cannot justify is one it will not make.
The fix: structure the concrete policy facts, return window, shipping cost, and warranty, as data an agent can read directly.
10. Slow pages
What it looks like: pages that take several seconds to become usable, heavy scripts, and large uncompressed images.
Why an agent fails: an agent working through many candidate products will time out or deprioritise a store that responds slowly, the same way a search engine does. Google's Largest Contentful Paint guidance treats 2.5 seconds as the threshold for a good experience, and that is a reasonable bar to hold your product pages to for agents as well.
The fix: meet Core Web Vitals and serve fast, cacheable product pages.
11. No canonical URL
What it looks like: the same product is reachable through several URLs, with tracking parameters, filter states, or session ids, and none of them is marked as the canonical one.
Why an agent fails: duplicate URLs split the signals an agent uses to decide which page is the real product, and it may index the wrong one, store a link that breaks, or count the same item twice. A single canonical URL removes that ambiguity.
The fix: set one canonical URL per product and point every variant of the link at it.
12. Inconsistent product identifiers
What it looks like: the same product carries different SKUs across your feed, your product page, and your checkout, and standard identifiers like GTIN or MPN are missing or wrong.
Why an agent fails: an agent matches, compares, and reorders products by their identifiers. If the identity drifts between surfaces, the agent cannot confirm it is buying the item it selected, cannot compare it against alternatives, and cannot reliably reorder it later. Stable identifiers are the backbone of trust.
The fix: use consistent GTIN, MPN, and SKU values across your feed, pages, and checkout.
How to turn this list into a fix
Read together, these twelve signs describe one underlying problem. A catalogue built only for human eyes leaves the facts an agent needs, price, availability, identity, and policy, locked inside layout, images, and scripts. The fix is not a rebuild. It is exposing what you already have in a form a machine can read and trust, and confirming that an agent can actually complete a purchase.
This is the work behind agentic commerce readiness. At Saturnia Labs we take an existing catalogue and expose it as a clean, agent-ready feed. We add an MCP interface over your store API, aligned with the Agentic Commerce Protocol checkout standard, so an authorised agent can read and buy through a defined path. And we add guardrails around that access, a spend cap, an approval gate, and an audited mandate, so autonomy stays inside limits you set. We do this as a member of the Claude Partner Network.
If you want to know which of these twelve signs apply to your store today, run the free scan. It checks your live pages against this list and tells you exactly what an agent can and cannot read.