WebMCP Explained: How to Make Your Website Ready for AI Agents (2026) | CrawlReady AI

A new Lighthouse audit category called Agentic Browsing appeared in May 2026. It scores how well your website works for AI agents — not just search crawlers, but autonomous browser agents that can navigate, fill forms, and take actions on your behalf. At the centre of this is WebMCP, a proposed web standard that gives AI agents a clear API for your site. This guide explains what it is and how to implement it.

What is WebMCP?

WebMCP (Web Model Context Protocol) is an open web standard jointly developed by Google and Microsoft that lets websites expose structured, callable tools to AI agents running inside the browser. Think of it as writing an API that lives in your HTML — instead of an agent scraping the DOM and guessing what to click, you declare exactly what it can do and how.

WebMCP was accepted by the W3C Web Machine Learning Community Group in late 2025. Chrome 146 shipped an early preview in February 2026, and the public origin trial launched in Chrome 149 in May 2026.

The Lighthouse Agentic Browsing audit

Google's Lighthouse 13.4 introduced a new Agentic Browsing category alongside the existing Performance, Accessibility, Best Practices, and SEO categories. It currently checks three areas:

• Agent Accessibility — Is your accessibility tree well-formed? Broken ARIA attributes and focusable elements inside aria-hidden containers block AI agents just as they block screen readers.
• llms.txt — Does your /llms.txt file follow the spec? It must be valid Markdown with at least one H1 heading and properly formatted [label](url) links.
• WebMCP — Are your forms annotated? Are tools registered? Are schemas valid? These three sub-checks are currently unscored but will be tracked as agent-readiness signals.

A perfect Agentic Browsing score requires all three areas to pass. Fixing them also tends to improve your core Accessibility score.

How to implement WebMCP: the declarative API

The easiest way to expose tools is the declarative API — HTML attributes you add directly to your <form> elements. No JavaScript required. The browser reads these attributes and makes the form available to AI agents as a callable function.

Form-level attributes

Field-level attribute

Example: URL audit form

<form toolname="auditWebsite"
      tooldescription="Runs a free AI and SEO crawl readiness audit on a website URL."
      toolautosubmit>
  <input type="url"
         name="url"
         required
         toolparamdescription="Full URL of the website to audit (e.g. https://example.com)">
  <button type="submit">Run Free Audit</button>
</form>

Removing either toolname or tooldescription unregisters the tool entirely — both are required.

Example: contact form

<form toolname="sendContactMessage"
      tooldescription="Sends an inquiry to the support team.">
  <input type="text" name="name" required
         toolparamdescription="Full name of the sender">
  <input type="email" name="email" required
         toolparamdescription="Reply-to email address">
  <textarea name="message" required
            toolparamdescription="The message or question"></textarea>
  <button type="submit">Send</button>
</form>

Note the missing toolautosubmit on the contact form — you generally want users to review messages before they are sent on their behalf.

How to implement WebMCP: the imperative API

For actions that are not tied to a form — navigation, fetching data, toggling UI state — use the imperative API. This requires Chrome 149+ and may need an origin trial token in production.

if ('modelContext' in document) {
  document.modelContext.registerTool({
    name: 'navigate_to_audit',
    description: 'Go to the free audit page to check a website for AI crawl readiness.',
    inputSchema: {
      type: 'object',
      properties: {}
    },
    execute: async () => {
      window.location.href = '/audit';
      return 'Navigating to the audit page.';
    },
    annotations: { readOnlyHint: true }
  });
}

Key points about the imperative API:

• Always guard with if ('modelContext' in document) — the API does not exist in older browsers
• readOnlyHint: true tells agents the tool does not modify data
• Tools must be registered before Lighthouse takes its snapshot — register them early in a non-deferred script if you want Lighthouse to detect them
• Use const controller = new AbortController() and pass { signal: controller.signal } as the second argument if you need to unregister a tool later

Common implementation mistakes

• Missing name on inputs — the browser's JSON Schema generator reads the name attribute to name each parameter. Inputs without name may be omitted from the schema.
• Registering tools in deferred scripts — Lighthouse snapshots tools at page load. A <script defer> or late-registering DOMContentLoaded listener may miss the window. Use a non-deferred inline script for imperative registrations.
• Omitting toolautosubmit on search/lookup forms — without it, agents fill the form but wait for a submit action. Add it to any form where immediate submission is safe.
• Vague descriptions — tooldescription="Search form" is not useful. Describe what the tool returns: "Runs a crawl readiness audit and returns AI crawler access, robots.txt, llms.txt, and indexability results."

WebMCP and your llms.txt

WebMCP and llms.txt serve complementary purposes. llms.txt is a static file that tells AI systems what your site contains and links to important pages. WebMCP exposes dynamic, callable tools that agents can invoke at runtime. Both are checked by the Lighthouse Agentic Browsing audit and both contribute to agent readiness.

If you have not published an llms.txt yet, the Lighthouse audit will flag it. The file must be valid Markdown, contain at least one H1 heading (# Site Name), and link to your key pages using [label](url) syntax — plain Label: URL strings are not recognised as links.

What to check first

1. Run the CrawlReady AI free audit on your homepage — it will flag accessibility tree issues, llms.txt problems, and (where supported) WebMCP coverage
2. Add toolname and tooldescription to every <form> on your site
3. Add toolparamdescription to all <input>, <select>, and <textarea> elements inside those forms
4. Register navigation tools with the imperative API in a non-deferred script
5. Publish or fix your /llms.txt using proper Markdown link format
6. Fix any ARIA violations flagged by the accessibility tree audit — these block agents the same way they block screen readers

The Agentic Browsing category is still marked experimental and will evolve as the WebMCP spec matures. Start with the declarative form annotations — they require no JavaScript and degrade gracefully in all browsers — then layer in imperative tools as browser support grows.