What Is Agent Readiness? Preparing Your Site for AI That Acts

What agent readiness actually means

Break it into four layers. They are sequential in the same way security layers are — a failure low down makes everything above it irrelevant.

The pleasant surprise for anyone who has done accessibility work: layer two is almost entirely a re-run of it. Google's guidance for agent-friendly sites says as much — everything that makes a site usable by an agent also makes it usable by a person with a screen reader. If you have an accessibility budget, you already have an agent-readiness budget.

How agents actually see your site

An agent does not look at your design. It operates on a machine-readable representation, and there are three of them:

• Screenshots. A vision model reads the rendered page and infers what elements are. It picks up visual cues — a large red button reads as consequential, a small grey link as secondary. It is slow and token-expensive, so it tends to be the fallback when structure is unclear.
• The DOM. The agent reads your HTML: nesting, hierarchy, ids and classes, and the raw strings that carry your actual data. This is how it works out that a Buy now button belongs to this product rather than the one next to it.
• The accessibility tree. A browser-native distillation of the DOM into roles, names and states of interactive elements. For an agent it is the highest-fidelity map available: it strips the visual noise and states the function of every control.

Modern agents combine all three, because any one alone leaves a semantic gap. A styled <div> that behaves like a button appears in the screenshot as something clickable but appears in the DOM as nothing in particular. The agent has to guess, and guessing is where automated journeys break.

The build rules that follow from this are unglamorous and specific:

• Use real <button> and <a> elements for anything actionable. If a framework forces a <div>, give it an explicit role and a tabindex.
• Bind every input to its label with a for attribute, so the agent can tie the field to the words describing it.
• Set cursor: pointer on clickable things — it is read as a strong actionability signal.
• Keep interactive elements above roughly eight square pixels of visible area; smaller controls get filtered out during visual analysis.
• Keep layouts stable across similar pages. An add-to-cart button that moves position by product category defeats screenshot-based navigation.
• Remove transparent overlays and ghost elements. An agent may discard a covered node even when the covering layer is invisible.
• Make sure every action a human can take is actually reflected in the interface, rather than living in a hover state or a gesture.

None of that requires a new file, a new protocol or a vendor. It requires the front-end discipline most teams already claim to have.

Layer 1: identity, or how to tell a real agent from a scraper

The first objection every operator raises is fair: if I open the doors to agents, I open them to everyone pretending to be one. User-agent strings are trivially spoofable, and IP allowlists rot.

The answer taking shape is cryptographic. Web Bot Auth lets a bot sign its HTTP requests so the origin can verify who is calling. It builds on HTTP Message Signatures (RFC 9421): the operator publishes a key directory, signs requests with an Ed25519 key, and attaches a Signature-Agent header alongside the signature and its inputs. It is progressing through the IETF as a directory draft plus a protocol draft, with Cloudflare, OpenAI and other large operators shipping support ahead of final publication.

Cloudflare has built the classification on top of it. Its verified-bots programme now distinguishes a verified bot — an automated crawler that identifies itself honestly and behaves — from a signed agent, an agent acting under someone's direction. Since 1 July 2026 the distinction is tracked as direct versus intermediary access: who is actually operating the bot. That gives you a policy vocabulary you did not have in 2024, where the only options were allow or block by user-agent string.

The same plumbing carries the commercial option. Cloudflare's pay-per-crawl mechanism answers a request for protected content with HTTP 402 Payment Required and a crawler-price header; a crawler willing to pay retries with an agreed price header included in its signed request. Whatever you think of the model, it settles an architectural question: agent access is becoming a negotiated, priced, authenticated relationship rather than a binary in a text file.

Practically, for most sites today: keep robots.txt accurate, do not block the retrieval and user-directed fetchers you want business from, and be aware that verified-only policies would currently shut out plenty of legitimate traffic that has not adopted signing yet. The agent-by-agent robots.txt guide covers who is who.

Layer 3: giving agents something to call instead of click

Clicking through a UI is the fallback. It is slow, expensive in tokens and fragile. The interface layer is about offering a cheaper path — and this is where most of the acronyms live. Here is what each is actually for.

Two of these have full write-ups in this cluster already: serving Markdown to AI agents covers content negotiation and which agents actually request it, and does llms.txt help SEO covers the server-log evidence on who reads that file. If you want a first draft of one to judge the format rather than the idea, our free llms.txt generator scaffolds it from your existing pages.

The judgement to apply across the whole table: an interface only earns its place if an agent has a reason to call it. A marketing site with five pages does not need an MCP server. A documentation site, an API product or a catalogue with thousands of SKUs does.

Layer 4: transactions, and the lesson of 2026

The transaction layer is where the money and the noise are. Two open protocols matter, and they are not the same shape.

Now the part that should shape your roadmap more than either spec. In September 2025 OpenAI launched Instant Checkout, letting shoppers buy inside ChatGPT. Six months later, on 24 March 2026, OpenAI ended it, saying the initial version did not offer the flexibility it aspired to and that merchants would use their own checkout experiences while OpenAI focused on product discovery. Adoption had been thin — reporting at the time put live Shopify merchants in the dozens — and the reasons were operational rather than philosophical: feed accuracy, inventory sync, and merchants' reluctance to hand over the post-purchase relationship.

The durable pattern that emerged is worth writing on the wall: discover in AI, buy on your own site. For nearly every business below enterprise scale, that means the highest-return agentic-commerce work in 2026 is not implementing a checkout protocol. It is making sure your catalogue data is accurate wherever agents read it, and that an agent arriving at your own site can actually complete the purchase.

How to test your own site in an afternoon

Five checks, in order of how often they find something. The first two are where the failures cluster.

1. Fetch your key pages as an agent, from outside your network. A 200 with real HTML is a pass. A challenge page, a 403, or a shell that needs JavaScript to fill in is a fail that no amount of content work will fix.
2. Read the page with JavaScript disabled. Prices, stock status, specifications and variant data that only appear after hydration are invisible to a large share of agents.
3. Open the accessibility tree in DevTools and walk your main conversion path. If controls appear as generic nodes with no role or name, an agent is guessing at them.
4. Complete your own checkout with the keyboard only. If you cannot, an agent probably cannot either. This single test catches more than any protocol adoption.
5. Check what your feeds say against what your site says. Divergent price, availability or shipping data is the most common reason an agent-sourced recommendation is wrong about you.

For check one, the request matters more than the tool. Ask for a page the way an agent would, from a machine that is not on your allowlist:

#!/usr/bin/env bash
# Compare how your origin answers a browser, a retrieval agent,
# and a user-directed fetcher. Anything other than 200 + real HTML
# on the last two lines is an agent-readiness failure.

URL='https://example.com/your-key-page'

for UA in \
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36' \
  'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot' \
  'Mozilla/5.0 (compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)'
do
  CODE=$(curl -s -o /tmp/agent-body -w '%{http_code}' -A "$UA" "$URL")
  BYTES=$(wc -c < /tmp/agent-body)
  # crude but effective: how much visible text survives tag stripping
  TEXT=$(sed -e 's/<[^>]*>//g' /tmp/agent-body | tr -s '[:space:]' ' ' | wc -c)
  printf '%s | status %s | %s bytes html | %s bytes text\n' \
    "${UA:0:40}" "$CODE" "$BYTES" "$TEXT"
done

A browser row with 90,000 bytes of HTML and an agent row with 4,000 tells you everything. So does a 200 that returns a challenge page, which is why the script reports text volume rather than just the status code.

What agent readiness is not

• It is not a ranking tactic. None of this makes you rank higher or get cited more. Citation is governed by a different set of factors, which we rank by evidence strength in what decides whether AI cites your site.
• It is not one file. No single document makes a site agent-ready, and any pitch that starts with one is selling the easiest deliverable rather than the useful one.
• It is not urgent for everyone. If no agent has a reason to transact with you, the honest advice is to do the accessibility work — which pays for itself in human terms — and revisit the protocol layer in six months.
• It is not finished. WebMCP is an origin trial, Web Bot Auth is in draft, and one of the two commerce protocols already retracted its flagship feature. Build on the stable parts — semantic HTML, accurate data, crawl access — and prototype the rest.

Where agent readiness fits alongside SEO, AEO and GEO is mapped in our pillar guide to AI search visibility. It is the layer that makes the other three worth anything: being recommended by an assistant is of limited value if the agent that follows the recommendation cannot complete the journey.

If you want this assessed and implemented rather than added to a backlog — agent access rules, render-side visibility, accessibility-tree cleanup, feed accuracy and the interface layer that fits your business — that is the engineering half of our SEO, AEO and GEO work, priced to scope.