# How to Make Your Site Agent-Ready

> 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/discovery/llms-txt). Check: `discoverability.llms_txt`. Self-demo: /llms.txt.
- **agents.json** — publish a manifest of your agent-facing actions
  (/protocols/discovery/agents-json). Check: `capabilities.agents_json`.
- **Markdown twins** — serve a `.md` copy of every page. Check: `content.markdown_twin`.
  Self-demo: every page has a `.md` twin.
- **JSON-LD** — mark up entities with schema.org
  (/protocols/discovery/schema-org). Check: `quality.json_ld`. Self-demo: this page's @graph.
- **Web Bot Auth** — verify Ed25519-signed requests under RFC 9421 and publish a key directory
  (/protocols/identity/web-bot-auth). Check: `access_control.web_bot_auth`. Lets you verify agents
  in the crawler registry (/crawlers/verification).
- **Content negotiation** — return `text/markdown` on `Accept: text/markdown`. Check:
  `content.content_negotiation`. Self-demo: request this page with `Accept: text/markdown`.

## Agent-readiness checklist: every check the Audit runs, mapped to a standard

The Audit runs one check per standard across six dimensions; every check maps to one how-to.
Every check is what the Agent-Readiness Audit verifies — POST /api/audit returns it scored.

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

## 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 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 across the six
dimensions, 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.