← Back to blog

WebMCP: how websites can offer tools to AI agents

AnuraCode

Pegboard with hand tools hung in their outlined places, one outline empty, and a large tropical leaf below

Today, an AI agent that works in a browser uses your website the way a person does. It looks at the page, finds the field that seems right, types and clicks. The WebMCP explainer describes it plainly: these agents observe the page “through a combination of screenshots, and DOM and accessibility tree snapshots”, and then simulate human input. That can work. It can also break when a form changes, a date picker is custom, or a button label is unclear.

WebMCP is a proposal for a more direct path. Chrome’s documentation calls it “a proposed web standard to help you build and expose structured tools for AI agents.” In practice, a site could say: here is a tool called “get a quote”, here are the inputs it needs, and here is the code that runs it. An agent could then call that tool instead of guessing its way through the form.

If you own a web app with bookings, quotes or a product search, you have probably heard that AI agents will soon use your site. This post explains what WebMCP is, what you can test today, and why it is still early. Every fact here is as of November 2026, and WebMCP is still changing.

The problem it tries to solve

There are two common ways for an agent to use a website today.

  • Act like a person. The agent reads the page and clicks. The explainer notes that even when agents succeed, “simple operations often require multiple steps and can be slow or unreliable.”
  • Skip the website. The business offers a separate server integration, such as an MCP server or a public API, and the agent talks to that instead. The explainer lists the costs: the agent bypasses your site’s interface, you must replicate the user’s session and sign-in on a separate server, and you have to build and run that server.

WebMCP proposes a third option. The tools live in the web page itself and run in the browser, in the user’s session, with the code your site already has. When the agent calls a tool, your page does the work and updates what the user sees. The explainer calls this a “cooperative interplay between a user, a web page, and an agent with shared context.”

Our earlier post on agent factories looked at the agent side: the tools that build and coordinate AI agents. This post is about the other side: the website those agents visit.

What WebMCP is, and what it is not

  • A draft, not a standard yet. The specification is a Community Group draft in the W3C Web Machine Learning Community Group, with editors from Google and Microsoft. A Community Group draft is not a W3C Standard.
  • A browser version of an existing idea. The name comes from the Model Context Protocol (MCP), “an open-source standard for connecting AI applications to external systems.” The explainer says pages that use WebMCP “can be thought of as in-page Model Context Protocol (MCP) servers”, and that WebMCP is meant “to complement, not replace” server-side protocols like MCP.
  • Built for a person in the loop. The explainer lists fully autonomous workflows as a non-goal. The user, the page and the agent work together in the same browser tab. Chrome’s documentation adds that tools may run in headless browsers, but the API is mainly designed for local browser workflows with a human present.
  • Not a replacement for your interface. In the explainer’s words, “The human web interface remains primary; agent tools augment rather than replace user interaction.” If a task has no tool, the agent can still fall back to reading and clicking.

What a tool looks like

The specification defines a JavaScript method, document.modelContext.registerTool(). A tool has a name, a plain-language description, an input schema (a JSON Schema that describes the inputs), and an execute function that does the work.

The example below is illustrative only. It follows the shape of the example in the WebMCP explainer, with a quote tool in place of the explainer’s to-do list. The API can still change.

// Illustrative only: WebMCP is experimental and may change.
await document.modelContext.registerTool({
  name: "get-quote",
  description: "Get a price estimate for a cleaning service",
  inputSchema: {
    type: "object",
    properties: {
      squareMeters: { type: "number", description: "Size of the space in square meters" }
    },
    required: ["squareMeters"]
  },
  async execute({ squareMeters }) {
    // Reuse the site's existing quote logic and update the page.
    const estimate = await calculateQuote(squareMeters);
    return {
      content: [{ type: "text", text: `Estimated price: ${estimate}` }]
    };
  }
});

The important line is the comment: the tool reuses code the site already has. One of WebMCP’s stated goals is that “any task that a user can accomplish through a page’s UI can be turned into a tool by reusing much of the page’s existing client-side code.”

You may also read about a second, simpler style. Chrome’s documentation describes a declarative API that adds annotations to normal HTML forms, next to the imperative JavaScript API above. The specification repository is clear that this part is not settled: WebMCP “is currently focused on the imperative document.modelContext.registerTool() API”, and the form-based version “is being explored separately” and “is not part of the specification at this time.” Turning a booking form into a tool with a few HTML attributes sounds attractive, but do not plan a project around it yet.

What you can test today

As of November 2026, WebMCP is available only in experimental ways. No browser turns it on by default for ordinary users.

  • Chrome origin trial. On June 9, 2026, Chrome announced an origin trial that starts in Chrome 149. In Chrome’s words, origin trials are “time-limited programs that offer early access to experimental platform features.” A site registers to try the feature, and Chrome notes there may be usage limits. The Chrome Status entry lists the trial for Chrome 149 to 156 on desktop.
  • Edge origin trial. The spec repository’s implementation status page lists an origin trial in Edge 150.
  • Local testing in Chrome. Developers can turn on the chrome://flags/#enable-webmcp-testing flag on their own machine. Chrome’s documentation also points to a Model Context Tool Inspector extension for testing tools, and says Chrome DevTools can help debug them.
  • Agents that can call tools. The same implementation status page lists WebMCP support in ChatGPT Desktop, experimental support in Brave’s Leo AI chat, and support for web apps on Meta Ray-Ban Display as “coming soon”.

For most businesses, testing today means a developer tries one or two tools on a local copy of the site. It does not mean your customers’ browsers will use them.

Why it is still early

  • It can change. Chrome’s documentation says WebMCP “is under active discussion and subject to change in the future.” Chrome Status lists the feature as “Proposed”.
  • Not every browser is on board. The implementation status page lists no implementation in Firefox or Safari. Mozilla’s standards-position issue for WebMCP is labeled “neutral”. WebKit’s, the engine behind Safari, is labeled “oppose”, with concerns that include privacy, security and API design.
  • The simple form version is not in the spec. As covered above, only the JavaScript API is specified today.
  • Agents have to find your tools. Chrome’s documentation notes that an agent learns whether a site has tools only by visiting it. There is no directory.
  • Security needs real thought. Chrome’s WebMCP tool security guide warns about prompt injection, where hidden instructions in content try to steer the agent. The spec lets a tool mark itself as read-only, as returning untrusted content, or as consequential. Chrome recommends the consequential hint for high-stakes or irreversible actions, such as booking travel or transferring money, so the agent or browser can ask the user to confirm. Your own code still has to check every input and permission.
  • Complex apps may need work. Chrome’s documentation notes that highly complex sites may need refactoring to manage application state.

What to do now if you own a web app

  • Do not rebuild for WebMCP. Nothing here is on by default for your customers, and the API can still change.
  • Keep your business logic reusable. WebMCP’s idea is to reuse the code behind your forms. If your quote, availability or search logic is a clear function with validated inputs, it will be easier to offer to an agent later, whatever the final standard looks like. It also makes the site easier to maintain today.
  • Try one safe tool, if you are curious. A read-only tool, such as a catalog search or a price estimate, is the lowest-risk place to start. Test it locally with the Chrome flag before you think about the origin trial.
  • Watch the status, not the headlines. The Chrome Status entry and the spec repository’s implementation status page show where things stand.

If you want to know whether any of this matters for your forms and self-service flows, get in touch.

Sources

Read on 2026-11-02. WebMCP changes quickly, so check the originals before you decide.