Google just shipped an official "agent-ready" toolkit. Here's the one thing it can't measure.

For most of 2026, "is my website agent-ready?" was a question you answered with vibes and a blog post. As of last week, Chrome answers it with a toolkit.

On June 22, the Chrome team shipped the Agent-Ready Toolkit — a first-party set of tools for checking and fixing how your site behaves when an AI agent, not a human, is driving. It bundles:

• a new Agentic browsing category in Lighthouse (available starting from M150, currently "informational and unbenchmarked"),
• Chrome DevTools for Agents,
• Modern Web Guidance (including a webmcp skill), and
• WebMCP itself as the mechanism for exposing your site's actions to agents.

The quiet significance isn't any single tool. It's that "agent-ready" just stopped being a think-piece and became a measured, first-party concern that ships in the same browser as most of your traffic. When the platform vendor builds the ruler, the thing being measured becomes a real engineering line item.

If you've read my earlier walkthrough of the Lighthouse Agentic Browsing checks, the remediation advice still holds. I don't want to re-run it here. I want to talk about the one thing this toolkit — by design — cannot tell you.

What the toolkit measures

The WebMCP portion of the audit, per the blog, "checks for the availability of registered WebMCP tools, forms missing declarative WebMCP, and schema validity." In plain terms it asks three questions:

1. Did your page register any tools via navigator.modelContext (or declarative form annotations)?
2. Are there forms that should be exposed as tools but aren't?
3. Are the input/output schemas valid?

That's a genuinely useful static check. It tells you whether you've done the work of exposing your site's logic. Pass it and an agent that shows up has a clean, structured way to call your search, your cart, your booking form — instead of screenshotting the page and guessing where to click.

The thing it can't measure

Here's the gap. Every check in that toolkit is about exposure: have you offered the tools? None of them — and none of them can, because they run at audit time in your own browser — tell you whether a real agent, in production, ever called one.

Exposure and invocation are two different facts:

• Exposure is a property of your code. Static. Auditable. Pass/fail. The toolkit nails it.
• Invocation is a property of the world. It's "on Tuesday at 14:03, something calling itself Gemini-in-Chrome invoked searchProducts({query:'waterproof'}) and got 8 results back." No static audit can know that, because it hasn't happened yet when the audit runs.

For most of this year the honest knock on WebMCP was "no mainstream agent calls navigator.modelContext anyway." That's changing — Google has named the first consumer: "Gemini in Chrome will soon support WebMCP APIs." Which means the interesting question is shifting from "did I expose tools?" (the toolkit now answers this for you) to "is anything actually using them, and what is it trying to do?"

That second question is where the value is. The first agent call to your site is a signal: it tells you which intent agents reach for first, whether your schema matched what they expected, and whether the call succeeded or threw. If you can't see it, you find out months later in an aggregate analytics wobble — long after you could have fixed the schema that made every agent call fail.

How to close the gap (honestly)

You don't need anything fancy. The move is to instrument every tool call the day you register the tool, so the first real invocation isn't invisible:

function instrument(name, handler) {
  return async (args) => {
    const t0 = performance.now();
    try {
      const result = await handler(args);
      report({ tool: name, ok: true, ms: performance.now() - t0 });
      return result;
    } catch (err) {
      report({ tool: name, ok: false, ms: performance.now() - t0, error: String(err) });
      throw err;
    }
  };
}

// register the *wrapped* handler with navigator.modelContext
navigator.modelContext?.registerTool({
  name: "searchProducts",
  // ...inputSchema...
  execute: instrument("searchProducts", searchProducts),
});

report() can be a fetch to your own endpoint, a log line, whatever. The point is: pass the Lighthouse audit to prove you exposed the tools, and add invocation logging to learn whether agents use them — because the toolkit only does the first half.

Disclosure

I work on Latch, a one-line script that does both halves: it exposes your existing search/cart/forms as WebMCP tools (so you pass the new audit), and its hosted tier records which agents call which tools and whether the calls succeed — the invocation layer a static audit can't see. The free, MIT client is on GitHub; you can wire up the same logging by hand with the snippet above if you'd rather.

Either way, the takeaway stands on its own: Chrome now grades you on whether you offer tools to agents. Whether agents actually take them is a separate fact — and right now, almost nobody is watching it. The day Gemini-in-Chrome makes its first call to your site is worth seeing happen. Make sure you can.