The Three Levels of an Agent-Ready Website

Why one bucket called “agent-ready” is too vague

Ask five site owners whether their website is “ready for AI agents” and you will get five different answers. One says yes because Google indexes every page. Another says yes because the pages have JSON-LD. A third says yes because the product has an API. Each is describing a different capability — and none of the three guarantees the other two.

The word “agent-ready” gets stretched across three very different jobs:

• Search — can an agent (or crawler, or answer engine) find and fetch the page at all?
• Understanding — once it has the page, can it interpret the content, entities, prices, conditions, and limits accurately?
• Execution — once it understands, can it actually do something on the site — place an order, book a slot, change a setting — without creating a mess?

Conflating these jobs produces predictable mistakes: a team ships schema markup and declares victory while the checkout flow would silently double-charge any agent that touched it. Or a team builds a careful API that no agent ever discovers because the documentation is uncrawlable.

This article defines a Learn Web4 framework that separates the three jobs into three levels. It is a working model for evaluating websites, not an industry standard. Implementation details live in How to Build an Agent-Ready Website; this pillar defines the levels and their boundaries.

Level 1 — Discoverable

Definition. Search engines, crawlers, and AI agents can find and fetch the page. This level covers crawlable HTML, robots.txt, sitemap.xml, internal links, canonical URLs, page status codes, and basic SEO.

Capability boundary. At Level 1 an agent can reach your content: follow a link, receive a 200 OK, read the HTML that comes back. That is all. A discoverable page can still be a wall of ambiguous marketing copy. A site that blocks AI crawlers in robots.txt, returns content only after JavaScript execution, or hides text inside images is not reliably discoverable, no matter how good the content is.

Evaluation criteria. Concrete checks that prove Level 1:

1. Key pages return HTTP 200 with meaningful content in the initial HTML response (verify with curl or a fetch with JavaScript disabled, not just a browser).
2. robots.txt exists and does not disallow the crawlers you want to reach — an official requirement for how Googlebot reads your crawl rules.
3. A sitemap is published and referenced, and the URLs in it match the canonical URLs of the pages.
4. Every important page is reachable through at least one internal link — no orphan pages.
5. Canonical tags resolve consistently (no chains, no conflicts between the canonical tag and redirects).

Common misconception. “Indexed by Google = agent-ready.” Indexing is evidence of Level 1 only. It says nothing about whether an agent can extract the right price or act safely — and nothing about other agents, many of which have their own fetch behavior and their own respect (or disregard) for your crawl rules.

Level 2 — Understandable

Definition. An agent can accurately interpret the content: what the page is about, which entities it mentions, how they relate, and which conditions and limits apply. This level covers clear headings, page summaries, explicit term definitions, structured content, JSON-LD / Schema.org markup, tables and lists, sources and update times, ambiguity reduction, and machine-readable metadata.

Capability boundary. At Level 2 an agent can answer questions about the site with some reliability: what this product costs, when this article was updated, what the refund terms are. The boundary is action. An agent that perfectly understands your pricing page still cannot safely upgrade a subscription unless Level 3 mechanisms exist. Understanding is read-only.

Evaluation criteria. Concrete checks that prove Level 2:

1. Each page has one descriptive H1 and headings that name the section’s actual content (“Refund policy,” not “Details”).
2. A short summary near the top states what the page is about and who it is for.
3. Key terms are defined explicitly instead of assumed — especially pricing, limits, and eligibility conditions.
4. Claims that matter (prices, dates, requirements) appear as text, not only inside images or widgets.
5. JSON-LD using Schema.org vocabulary marks up the page type, authorship, and dates — Google’s structured data introduction documents which markup Search can consume. Label: current recommendation, not a guarantee of rich results.
6. Articles show update dates and cite sources, so an agent can judge freshness.
7. A test agent (an LLM with fetch access) answers five factual questions about the page correctly. This last check is the real proof; the first six are inputs.

One optional input at this level is an llms.txt file — a proposed convention for pointing agents at your most useful pages. Support varies by tool and broad adoption should not be assumed; treat it as a supplement to good page structure, never a substitute (see What Is llms.txt?).

Common misconception. “Schema markup = understandable.” Schema is one signal among many. If the visible text contradicts the markup, you have added ambiguity rather than removed it. Conversely, a well-written page with no schema at all can be highly understandable — structure in prose beats markup that lies.

Level 3 — Actionable

Definition. An agent can safely perform actions on the site, not just read it. This level covers stable APIs, authentication, permission scopes, tool calls, action confirmation, idempotency, error handling, audit logs, undo and refunds, human handoff, and risk controls.

Capability boundary. At Level 3 an agent can change state on behalf of a user: create an order, book a time, update a record. The boundary runs in both directions. An actionable site must let legitimate agent actions through — an agent with valid credentials should not hit a CAPTCHA wall designed for bots — and it must contain bad ones: a malformed request gets a clear error, a retried request does not execute twice, a high-risk action waits for human confirmation. Level 3 is where mistakes stop being misreadings and start being transactions.

Evaluation criteria. Concrete checks that prove Level 3:

1. Actions are exposed through a stable, documented interface (API, MCP tool, or well-defined form endpoints) — not only through visual UI that requires scraping.
2. Authentication exists and permissions are scoped: an agent’s token can do what the task needs and no more.
3. Risky or irreversible actions require an explicit confirmation step before execution.
4. Mutations are idempotent: sending the same request twice (a retry, a timeout recovery) produces one order, not two.
5. Errors are structured and actionable — the response tells the agent what failed and what to do next, not just 400.
6. Every action is logged with who/what/when, so a human can audit what the agent did.
7. Undo paths exist: cancellation, refund, or rollback, plus a documented route to a human when the agent is stuck.

Common misconception. “Having an API = actionable.” A public API satisfies criterion 1 and nothing else. If that API lacks idempotency keys, returns opaque errors, or grants every token full account access, it is arguably less safe for agents than a plain web form with a confirmation page.

Misconception table

Belief	What it actually proves	What is still missing
”Google indexes us, so we’re agent-ready”	Level 1 for one crawler	Understanding (Level 2), safe action (Level 3), other agents’ access
”We have schema markup, so agents understand us”	One input to Level 2	Clear prose, definitions, freshness signals; markup matching visible content
”We have an API, so agents can act”	One input to Level 3	Auth scopes, confirmation, idempotency, error handling, audit logs, undo
”We added llms.txt, so we’re AI-friendly”	A hint file some tools may read	Everything — llms.txt is a proposed convention with uneven support
”Our chatbot makes the site agentic”	A conversational UI for humans	Machine-readable content and safe action interfaces underneath
”Agent-ready is just good SEO now”	Overlap at Level 1	Levels 2 and 3 have no SEO equivalent — see Agent-Ready Is Not AI SEO

Failure scenario: discoverable, understandable, and broken at Level 3

Consider a mid-sized online plant store. Its catalog pages are server-rendered and crawlable (Level 1 passes). Each product page has a clear H1, a care-requirements table, explicit pricing, and Product schema with accurate availability (Level 2 passes). The site even exposes a small JSON API for submitting orders, added last year for a mobile app.

An AI shopping agent is asked: “Order one fiddle-leaf fig, delivery to my address.” It finds the product page, parses the price and stock status correctly, and posts to the order endpoint with the user’s saved credentials.

Then three things go wrong:

1. No confirmation step. The endpoint executes immediately. The agent parsed the $45 price correctly but missed a sentence about a $12 oversized-delivery surcharge. The user never saw a final total, and there was no checkpoint to catch the gap.
2. No idempotency. The first POST times out at the network layer. The agent, doing exactly what a good agent should do, retries. The server creates a second order. Two figs, two charges.
3. No undo path. The user notices the duplicate charge. There is no self-serve cancel, the support inbox replies in two days, and the audit trail is a line in a server log nobody can query. The agent cannot fix its own mistake; neither can the user, quickly.

The site would score well on a typical “AI-friendliness” audit — crawlable, structured, even API-equipped. The failure only appears when you ask the Level 3 question: what happens when an agent actually acts? That is the question the single bucket “agent-ready” never forces you to ask.

How the levels fit together

The levels are cumulative but not interchangeable. Skipping ahead creates fragile systems: an actionable API on an undiscoverable site serves no agents; an actionable API on an ununderstandable site serves agents acting on wrong information — the worst outcome of all.

The canonical claim of this framework:

Agent-ready is not the same as AI SEO. A site that agents can find is not necessarily a site agents can understand, and a site agents can understand is not necessarily a site they can safely act on.

This framework sits inside a broader view of where the web is heading. Learn Web4 uses a practical working definition of Web4 focused on AI agents, agent-readable information, and agent-mediated actions. Other definitions of Web4 may emphasize spatial computing, virtual worlds, digital twins, decentralized systems, or physical-digital integration. Under this working definition, the three levels measure the distance between today’s web and a genuinely agentic web.

When this framework does not apply

Label: limitation. The three levels are a website-evaluation model; some situations fall outside it:

• Pure content sites. A blog or docs site has nothing for an agent to execute. Level 3 is not “failed” — it is absent. Evaluate Levels 1 and 2 and stop.
• Actions that should stay agent-free. Medical decisions, legal filings, large transfers: some sites deliberately require a verified human at every step. Low Level 3 support there is a design choice, not a deficiency.
• Agent-to-agent systems. Internal services built for known, contracted agents follow different rules than the open web, where any agent might arrive.
• Ranking and citation outcomes. The framework describes capabilities, not results. Reaching a level does not guarantee rankings, traffic, or citations in AI answer systems.

Using the framework

Evaluate in order, fix in order. Run the Level 1 checks first — they are cheap and mechanical. Then test Level 2 by asking a real agent factual questions about your pages and scoring the answers. Only then audit Level 3, action by action, asking for each one: confirmation, idempotency, error clarity, audit, undo.

For the step-by-step implementation work, continue to How to Build an Agent-Ready Website. To score your site against a condensed version of these criteria, use the Agent-Ready Website Checklist. For the distinction between this framework and search optimization, read Agent-Ready Is Not AI SEO.

Further reading

• Google Search Central: Introduction to robots.txt
• Google Search Central: Introduction to structured data
• Schema.org
• llms.txt proposal

FAQ

Is a website agent-ready if Google indexes it?

Indexing only covers Level 1, Discoverable. An agent may still be unable to interpret the page's content accurately (Level 2) or act on it safely (Level 3).

Does having an API make a site Actionable?

Not by itself. Level 3 also requires authentication, scoped permissions, confirmation for risky actions, idempotency, error handling, audit logs, and a path to a human.

Can a site be Understandable without being Discoverable?

In theory yes — a page can be perfectly structured while robots.txt blocks all crawlers — but in practice the levels build on each other, so evaluate them in order.

Do small content sites need Level 3?

Usually no. A blog or documentation site has nothing for an agent to execute, so Levels 1 and 2 are the whole job. Level 3 applies when a site offers actions like ordering, booking, or account changes.

Changelog

• Jul 26, 2026: Rewritten as the pillar article for the three-level agent-ready framework: added per-level capability boundaries, evaluation checklists, a misconception table, and a Level 3 failure scenario.
• May 2, 2026: Initial publication.