# How to Make Your Site Agent-Ready

> Is your site ready for AI agents?
> Making your site agent-ready means implementing a defined set of machine-readable
> standards across six readiness dimensions, so AI agents can discover, read, access,
> use, transact with, and trust your site — each verified by the Agent-Readiness Audit.
> · this page is its own proof.

## Agent-readiness, defined: what makes a site usable by AI agents

Agent-readiness is the measurable degree to which a website lets AI agents discover, read,
access, use, transact with, and trust it — achieved by implementing machine-readable
standards across six dimensions, each of which the Agent-Readiness Audit can verify. It is
processual, not a switch: a sequence of concrete changes (files, headers, markup, manifests),
each tied to a named standard. "Ready" is machine-verifiable — a standard either resolves or
it does not.

- **Agent-readiness vs. SEO vs. accessibility:** SEO targets human-ranking engines, WCAG
  targets human assistive tech; agent-readiness targets autonomous machine clients.
- **Standards-and-proof model:** every readiness claim resolves to a standard plus a
  pass/fail check.

## Six readiness dimensions structure how a site serves the agentic web

Agent-readiness has six dimensions, each mapping to a cluster of standards and a category of
audit checks. The first five mirror the field's scored categories (Cloudflare's public model,
as reported in 2026); Agents Welcome adds Quality as the machine-verifiable extension.

1. **Discoverability** (/agent-readiness/discoverability) — llms.txt, llms-full.txt, AGENTS.md,
   agents.txt, agents.json, .well-known discovery, NLWeb.
2. **Content** (/agent-readiness/content) — markdown twins, content negotiation (text/markdown),
   answer-first structure, FAQ schema.
3. **Access control** (/agent-readiness/access-control) — Web Bot Auth (RFC 9421, Ed25519),
   AI-aware robots.txt, pay-per-crawl, RSL, Content-Signal.
4. **Capabilities** (/agent-readiness/capabilities) — MCP, WebMCP, agents.json action manifest.
5. **Commerce** (/agent-readiness/commerce) — x402, AP2, ACP, UCP.
6. **Quality** (/agent-readiness/quality) — JSON-LD / schema.org, freshness (last_verified),
   markdown twins, self-demonstration.

## Implementation order: which agent-readiness step to ship first

Implement in dependency order — an agent must find and read you before it can act or pay:

1. Discoverability (llms.txt, AGENTS.md) — prerequisite for everything.
2. Content (markdown twins, answer-first) — make found pages machine-readable.
3. Access control (Web Bot Auth, robots policy) — admit and verify the right agents.
4. Capabilities (agents.json, MCP) — only if agents need to act.
5. Commerce (x402, AP2) — payment is the highest-trust action; wire it once trust exists.
6. Quality (JSON-LD, freshness, self-demonstration) — throughout and last; makes it verifiable.

The minimum viable agent-ready site is steps 1–2: discoverable and readable.

## How-to: implement each agentic-web standard on your site

Each how-to implements one standard in three moves — add the artifact, point it at your
content, confirm it resolves — and ends: verify it with the Agent-Readiness Audit.

- **llms.txt** — add `llms.txt` at your root listing your key pages. Implements the llms.txt
  standard (/protocols/llms-txt). Check: `llms-txt`. Self-demo: /llms.txt.
- **agents.json** — publish a manifest of your agent-facing actions
  (/protocols/agents-json). Check: `agents-manifest`.
- **Markdown twins** — serve a `.md` copy of every page. Check: `markdown-negotiation`.
  Self-demo: every page has a `.md` twin.
- **JSON-LD** — mark up entities with schema.org
  (/protocols/schema-org). Check: `json-ld`. Self-demo: this page's @graph.
- **Web Bot Auth** — verify Ed25519-signed requests under RFC 9421 and publish a key directory
  (/protocols/web-bot-auth). Check: `web-bot-auth`. Lets you verify agents
  in the crawler registry (/crawlers/verification).
- **Content negotiation** — return `text/markdown` on `Accept: text/markdown`. Check:
  `vary-accept`. Self-demo: request this page with `Accept: text/markdown`.

## Agent-readiness checklist: every readiness standard, mapped to a how-to and a pass criterion

This checklist is the engineering view — the six readiness dimensions, each mapped to the
standard, the how-to, and its pass criterion. It is how you GET ready. What the Agent-Readiness
Audit (POST /api/audit) then SCORES is a related set: 18 weighted checks across four categories
— Discovery (25), Content (39), Capability (17), Trust (19) = 100 — with real check ids like
llms-txt, markdown-negotiation, json-ld, agents-manifest, web-bot-auth, agent-welcome-header.

| Dimension | Standard | How-to | Pass criterion |
|---|---|---|---|
| Discoverability | llms.txt | /agent-readiness/llms-txt | /llms.txt resolves 200 |
| Content | Markdown twins | /agent-readiness/markdown-twins | <url>.md returns markdown |
| Content | Content negotiation | /agent-readiness/content-negotiation | Accept: text/markdown honored |
| Access control | Web Bot Auth | /agent-readiness/web-bot-auth | Signed request verifies |
| Capabilities | agents.json | /agent-readiness/agents-json | Manifest declares valid actions |
| Commerce | x402 | /agent-readiness/commerce | 402 challenge returns offer |
| Quality | schema.org JSON-LD | /agent-readiness/json-ld | @graph parses without errors |

Unsure how the root files relate? Read [llms.txt vs robots.txt vs agents.txt compared](/agent-readiness/llms-txt-vs-robots-txt-vs-agents-txt).

## Self-demonstration: this site implements every step, and you can verify it live

This site ships an llms.txt, agents.json, a markdown twin per page, schema.org JSON-LD, a
Web Bot Auth key directory, and content negotiation — verify each live before trusting the
advice. The score is rendered at build from live artifacts, not hardcoded.

- llms.txt → /llms.txt
- agents.json → /.well-known/agents.json
- Markdown twin → append `.md` (this file)
- JSON-LD → @graph in this page's head
- Content negotiation → send `Accept: text/markdown`
- Web Bot Auth → sign a request; check /api/whoami

## Agent-readiness — frequently asked questions

### Is agent-readiness the same as SEO?

No. Classic SEO optimizes a site for human-ranking search engines, and web accessibility (WCAG) optimizes it for human assistive technology. Agent-readiness targets autonomous machine clients: it implements machine-readable standards so AI agents can discover, read, access, use, transact with, and trust your site, and so each can be verified pass or fail.

### Which agent-readiness step should I implement first?

Ship in dependency order. Start with Discoverability (llms.txt, AGENTS.md) and Content (markdown twins, answer-first) because an agent must find and read you before anything else; then add Access control (Web Bot Auth, robots policy); then Capabilities (MCP, agents.json) only if agents need to act; and reach Commerce (x402, AP2) and the full Quality layer last.

### What does the Agent-Readiness Audit check?

The Audit (POST /api/audit) runs 18 weighted checks across four categories — Discovery, Content, Capability and Trust — and the six dimensions on this page are the implementation view those checks roll up into. Each check has a machine-checkable pass criterion — the standard either resolves correctly or it does not — so the checklist doubles as your implementation plan.

### Is agent-readiness a single setting or a process?

It is a process, not a switch. Agent-readiness is a sequence of concrete changes — files, headers, markup, manifests — each tied to a named standard. 'Ready' is not subjective: each standard either resolves correctly or it does not, which is what makes readiness machine-verifiable.

## Agent-readiness border: from implementing standards to certifying them

You now know which standards make your site agent-ready and how to implement each — but did
you ship them correctly, and can you prove it? That needs verification, not more how-tos:
the Agent-Readiness Audit (/services) checks every standard, scores your site with 18 weighted
checks across four categories (Discovery, Content, Capability, Trust), and certifies it as
Agents Welcome when you pass.

Bridges: /services (audit + certify) · /protocols (the Atlas) · /glossary (Lexicon) ·
/crawlers/verification · /models · /commerce · /state-of-the-agentic-web.