What is agent readiness?

Agent readiness is the measure of whether an AI shopping agent can reach your store, understand what you sell, and recommend or buy it without a human ever loading the page. It is a property of the machine-facing surface of your storefront: crawl permissions, discovery files, structured product data, and policy published in a form a machine can parse.

Put more bluntly, a store is agent ready when an agent that has never heard of your brand can answer four questions from your public pages alone. Am I allowed in? Where is the catalogue? What is this product, exactly, in fields I can compare against another shop? What happens if the customer sends it back? When one of those answers is missing, the agent does not email you for clarification. It recommends a store that answered.

This matters now because the traffic is real. AI-referred visits and AI-attributed orders grew sharply through 2025 and 2026, which is the shift I wrote about in the switch was flipped. The buying surface moved, and most storefronts were built for the old one.

Agent readiness is not SEO

SEO optimises for a human clicking a ranked link. Everything after the click is a persuasion problem: layout, photography, review widgets, urgency, trust badges. The page is the argument, and the human resolves ambiguity by scrolling.

Agent readiness optimises for a machine that reads, compares and sometimes transacts, and never renders the page for anyone. Same store, different consumer, different requirements. Concretely, what changes:

• A banner reading "free UK shipping over 50" is a strong signal to a shopper and no signal at all to an agent comparing OfferShippingDetails across three merchants. If the shipping cost is not a field, it is not a fact.
• "Hassle-free returns" is copy. MerchantReturnPolicy with a return window in days is data. An agent buying on a customer's behalf has to price the downside of a bad fit, and it will discount a merchant that will not state its terms.
• Ranking position is a ranked list of links. Agent selection is closer to a filter followed by a comparison. Being unparseable does not push you down the list, it removes you from the set. The constructive version is getting recommended.
• Rendering matters more. Prices painted into the DOM by a review app or a currency switcher after page load are not reliably part of what an agent reads.

The two overlap on fundamentals like a working sitemap and fast, reachable HTTPS pages. But an excellent SEO score tells you nothing about whether ClaudeBot is allowed to fetch your product pages.

The four things an agent needs, in order

The order matters, because each layer is worthless if the one before it fails.

1. Crawl access

The agent must be allowed in. This is decided in robots.txt, per crawler, by name. The five that matter for shopping are GPTBot (OpenAI, training and ChatGPT browsing), ClaudeBot (Anthropic, Claude retrieval), OAI-SearchBot (OpenAI, ChatGPT search results), PerplexityBot (Perplexity, answers and shopping) and Google-Extended (Google).

User-agent: GPTBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

Blocks here are usually inherited rather than chosen: a bot-mitigation rule, a theme template, or advice from a period when blocking AI crawlers looked like protecting your content. The mechanics and the common misfires are covered in robots.txt for AI crawlers.

2. Discovery

Being allowed in is not the same as knowing where to go. The agent needs a route to the catalogue: a valid sitemap that actually contains product URLs, not just pages and collections. On top of that sit the newer conventions, llms.txt and llms-full.txt, agents.md, and a Universal Commerce Protocol manifest at /.well-known/ucp. A store whose sitemap lists only its blog is technically crawlable and practically invisible, which is the failure mode described in why your Shopify store is invisible to AI.

3. Structured data

Once the agent has the page, it has to parse the product. That means Product JSON-LD with an Offer that carries price, currency and availability, plus an identifier and a rating.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Merino Base Layer, Long Sleeve",
  "sku": "ML-BASE-001",
  "gtin13": "5012345678900",
  "offers": {
    "@type": "Offer",
    "price": "89.00",
    "priceCurrency": "GBP",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "212"
  }
}

AI shopping agents select merchants partly on structured data completeness, in particular AggregateRating, MerchantReturnPolicy, OfferShippingDetails and FAQPage. Which fields carry the most weight, and why, is the subject of the schema fields AI agents actually read.

4. Machine-readable policy

The last layer is the one most stores skip, because it lives in a policy page written for humans. An agent completing a purchase has to price two risks: what shipping will cost and take, and what a return will cost the customer. Both belong in structured data, OfferShippingDetails and a hasMerchantReturnPolicy on the product or offer.

{
  "@type": "MerchantReturnPolicy",
  "applicableCountry": "GB",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn"
}

A thirty day free return stated as a field is a competitive advantage. The same policy stated only in a paragraph on /pages/returns is invisible.

Agent ready is a state you can measure

Every one of those four layers reduces to a check that either passes or fails. There is no partial credit for intent. Either robots.txt permits ClaudeBot or it does not. Either the sitemap contains product URLs or it does not. Either the Offer has a currency or it does not.

That is how Sextant models it: five weighted categories and forty checks, scored zero to 100 with a letter grade. Crawl access and product schema carry the most weight at 25 percent each, discovery 20 percent, merchant data and content quality 15 percent each. Individual failures are named, so a result is actionable rather than atmospheric: crawl.gptbot, discovery.sitemap_products, product.offer_price, merchant.return_policy. If you want the full sequence of what to inspect and in what order, see how to audit a store for agentic commerce.

Platform defaults now matter

Where you host is now a real variable.

Shopify enabled agentic storefronts for eligible merchants in March 2026, and as of May 2026 it ships llms.txt, agents.md and UCP support natively. That covers a good deal of the discovery layer without any work on your part. WooCommerce core, by contrast, emits no Product schema without a plugin, so a default Woo store fails the parsing layer before anyone has looked at policy.

Defaults are a floor, not a finish. Platform generated files can be overridden by a custom robots.txt, a theme edit or an app that rewrites your markup, and no platform can invent a return window you never entered. The only way to know which layer your store fails is to look at the store as an agent sees it.

If you want to find out which of these four your storefront currently misses, run a free scan. It reads only your public pages and takes about half a minute.