# WebMCP: What It Is, How It Works and What It Means for Your Website

> WebMCP lets pages expose tools to AI agents via document.modelContext. How it differs from MCP, browser support in October 2026, and what it means for GEO.

**Published:** 2026-10-13 · **Category:** GEO

[Version HTML](https://www.citeme.io/ressources/webmcp)

---

WebMCP is a proposed browser API that lets a web page hand AI agents a list of "tools": named JavaScript functions with a plain-language description and a JSON Schema for their inputs. Instead of reading pixels and guessing which button does what, an agent running in the browser can call `search_flights` or `add_to_cart` directly, and the page runs its own code to do the job. The specification is incubated in the W3C Web Machine Learning Community Group, edited by engineers from Microsoft and Google, and as of October 12, 2026 it is in origin trial in Chrome and Edge, not shipped by default in any browser.

## What is WebMCP?

WebMCP is a JavaScript interface, `document.modelContext`, through which a page registers tools that agents can discover and invoke. The specification's own abstract is one sentence: the API "enables web applications to provide JavaScript-based tools to AI agents."

The [explainer in the official repository](https://github.com/webmachinelearning/webmcp) describes pages that use WebMCP as Model Context Protocol servers "that implement tools in client-side script instead of on the backend." The tools run inside the user's open tab, with the user's existing session, and the page updates its own interface as the agent works. The explainer was first published on August 13, 2025.

The problem it targets: general-purpose agents mostly operate websites by taking screenshots, reading the DOM and simulating clicks, which is slow and brittle. WebMCP lets the site owner say: here is the function that does this task, call it.

> **Key takeaway:** WebMCP turns a web page into a set of callable tools for an agent that is already in the browser with the user. It is about letting agents _act_ on your site, not about getting your site _cited_.

## WebMCP vs. a classic MCP server

The short answer: MCP connects an AI application to a server over a protocol; WebMCP connects a browser agent to the page the user has open, through a web API. They share vocabulary (tools, descriptions, input schemas) but not plumbing.

The [Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro) is an open-source standard for connecting AI applications such as Claude or ChatGPT to external data, tools and workflows. Its architecture is client-server: a host application opens one MCP client per MCP server, messages use JSON-RPC 2.0, and they travel over stdio for local servers or Streamable HTTP for remote ones, with OAuth recommended for authentication. Servers expose three primitives: tools, resources and prompts.

The WebMCP explainer says plainly that adopting MCP as-is in the browser was considered and rejected, because MCP "lacks native web concepts like origins, standard browser permissions, DOM integration, and tab-level lifecycle management." So WebMCP borrows the tool model and builds a web-native API around it.

| Aspect | Classic MCP server | WebMCP |
| --- | --- | --- |
| Where the code runs | On a server (local process or remote service) | In the web page, in the user's browser tab |
| Who calls it | An MCP host such as Claude, ChatGPT, VS Code or Cursor | An agent built into or hosted by the browser (including extensions), or an in-page agent |
| Transport | JSON-RPC 2.0 over stdio or Streamable HTTP | A JavaScript API: `document.modelContext` |
| Authentication | Handled by the server, OAuth recommended | Reuses the user's existing session on the site |
| Primitives | Tools, resources, prompts | Tools only (in the current spec) |
| Works without the site open | Yes | No; the page must be loaded (service worker support is only being explored) |
| Status | Published, versioned specification, widely supported | Community Group draft, origin trials in Chrome and Edge |

The two are complementary. The explainer lists "replacement of backend integrations" as an explicit non-goal. A company can run an MCP server for headless access to its data and also register WebMCP tools on its web app for agents working alongside a user in the browser.

## What a site exposes, and how

A site exposes tools. Each tool has a `name`, a `description` written for a language model, an optional `inputSchema` in JSON Schema, and an `execute` callback that does the work and returns a result. There are two ways to declare them.

### The imperative API (in the specification)

The specification defines `document.modelContext.registerTool()`. The shape below follows the spec's `ModelContextTool` dictionary:

```
await document.modelContext.registerTool({
  name: "filter-templates",
  description: "Filters the list of templates based on a natural language visual description.",
  inputSchema: {
    type: "object",
    properties: {
      description: { type: "string", description: "A visual description of templates to show." }
    },
    required: ["description"]
  },
  execute({ description }) {
    filterTemplatesInUI(description);
  }
});
```

A few details from the spec that matter in practice:

-   **It lives on `document`, not `navigator`.** Early drafts and many tutorials use `navigator.modelContext`. The editors moved the API to the Document in 2026 because tools need to be scoped to a document ([issue #173](https://github.com/webmachinelearning/webmcp/issues/173)). Older names such as `provideContext` are not in the current spec either.
-   **Annotations describe risk.** `readOnlyHint` marks a tool that only reads data; `consequentialHint` marks actions that are "significant, real-world, or non-reversible," such as booking a flight; `untrustedContentHint` flags output that contains untrusted data, such as user reviews.
-   **There is no `unregisterTool()`.** A tool is removed by aborting the `AbortSignal` passed in the registration options. Tools can be added and removed as the page state changes, for example a checkout tool that only appears once the cart is filled.
-   **Cross-origin exposure is opt-in.** An `exposedTo` list of origins controls which documents in the page's frame tree can see a tool. The API requires a secure context (HTTPS).

### The declarative API (Chrome, not yet in the spec)

Chrome's documentation also describes a declarative API: you annotate an existing HTML form and the browser derives the tool definition from its fields.

```
<form toolname="createSupportRequest" tooldescription="Submits a request for customer support.">
</form>
```

Chrome documents the attributes `toolname`, `tooldescription`, `toolparamdescription` on individual fields, and `toolautosubmit`. The repository is clear that this declarative counterpart "is not part of the specification at this time" and is being explored separately. If you build on it, treat it as Chrome-specific and subject to change.

## Current status and browser support

WebMCP is an experiment you can deploy to real users through origin trials, not a shipped web standard. Here is where things stand as of October 12, 2026, from primary sources:

-   **Specification:** a Draft Community Group Report of the W3C Web Machine Learning Community Group. Community Group reports are not W3C Standards and are not on the Standards Track.
-   **Chrome:** an early preview opened on [February 10, 2026](https://developer.chrome.com/blog/webmcp-epp), behind a flag from Chrome 146. The [origin trial started in Chrome 149](https://developer.chrome.com/blog/ai-webmcp-origin-trial) (announced June 9, 2026). Chrome Platform Status lists the trial through Chrome 156, with an extension request to Chrome 162 citing API improvements made after feedback. Locally, developers can enable `chrome://flags/#enable-webmcp-testing`.
-   **Edge:** the repository's implementation status page reports an origin trial live in Edge 150; Microsoft's origin trial page lists an expiry of March 30, 2027.
-   **Firefox and Safari:** standards-position requests are open with Mozilla and WebKit; Chrome Platform Status shows "No signal" for both.
-   **Agents:** this is the part that decides whether anything happens. At Google I/O 2026, Google said [Gemini in Chrome "will soon support WebMCP APIs"](https://developer.chrome.com/blog/chrome-at-io26). Chrome's docs point developers to extensions, including a Model Context Tool Inspector, to call tools today, and note these are separate from Gemini in Chrome. The repository's status page also lists ChatGPT Desktop support and experimental support in Brave's Leo assistant.

In other words: the API is testable, a few agents can call it, but no major browser exposes it to all users by default, and the declarative API is not yet standardized.

## What WebMCP means for agent-ready websites

For sites where users get things done (booking, buying, configuring, filing a request), WebMCP is the most direct route proposed so far to be reliably usable by browser agents. The practical reasons:

-   **Reliability.** An agent calling `order-prints` with `{ copies: 10 }` does not depend on your button labels, layout or A/B tests.
-   **Control.** You choose which actions are exposed, describe them in your own words, and flag consequential ones so the agent and browser can ask the user to confirm.
-   **Code reuse.** Tools call the same client-side functions your interface already uses, and the visible UI stays in sync with what the agent did.

It also brings real risks, which the specification documents in detail: a malicious site can hide instructions in tool descriptions (metadata poisoning), and tool output that contains user-generated content can carry prompt injections. If you expose tools, keep descriptions factual, mark risky actions with `consequentialHint`, flag user-generated output with `untrustedContentHint`, and never assume the agent is trustworthy because the user is.

Should you implement it now? For a transactional web app with engineering time, the origin trial is a cheap experiment: a few registered functions. For a marketing site or a blog, there is little to expose beyond a search box or a contact form. Clean basics (pages that render without heavy client-side JavaScript, clear forms, accessible markup) help every agent, with or without WebMCP. Our guide on [how AI browsers choose which brands to show](https://www.citeme.io/ressources/ai-browsers-2026-how-they-choose-which-brands-to-show) covers that side.

## WebMCP and visibility in AI answers (GEO)

WebMCP does not make an assistant more likely to cite or recommend your brand. Being cited and being operable are two different things, and it is worth keeping them apart.

**Being cited** happens when ChatGPT, Perplexity, Gemini or Google AI Overviews build an answer and pick sources and brands to mention. That depends on what those systems retrieve and trust: crawlable pages, clear and specific content, and mentions on third-party sources such as rankings, reviews and forums. Nothing in the WebMCP specification feeds into that process. Tools are registered by script in a live page for an agent in the browser; they are not a ranking signal, and no search or answer engine has said it reads them as one. This is the work of [generative engine optimization](https://www.citeme.io/ressources/generative-engine-optimization).

**Being operable** starts later in the journey: the user (or their agent) has already landed on your site and wants to complete a task. WebMCP makes that step faster and more reliable for agents that support it. That can matter for conversion once a brand has been recommended. It does nothing to earn the recommendation.

A site that is both cited and operable is better placed than one that is only cited. But for visibility, the priorities have not changed: make sure AI crawlers can reach your pages (you can check with our [AI crawler checker](https://www.citeme.io/tools/ai-crawler-checker)), publish content that answers the questions people ask assistants, and earn mentions on the sources those assistants cite.

> **Key takeaway:** GEO decides whether an assistant mentions you. WebMCP, if it ships widely, helps decide whether an agent can do something on your site once it gets there. Track both, but do not expect one to deliver the other.

## Where Citeme fits

Citeme is a GEO platform, and it uses the regular Model Context Protocol, not WebMCP. Citeme runs its own [MCP server](https://www.citeme.io/features/mcp) with 14 tools that let an assistant read your GEO data: audits, visibility across the 10 engines Citeme tracks, competitors, citations and recommendations. In Claude, you connect it with OAuth; in other MCP clients, you use a CLI key. You can ask your assistant which prompts your brand is missing from without opening a dashboard.

To be clear about the limits: Citeme does not offer WebMCP support, and it does not register WebMCP tools on your site. If WebMCP becomes widely supported, adding tools to your site will be a development task on your side, separate from your GEO work.

## FAQ

### What is WebMCP in simple terms?

WebMCP is a proposed browser API that lets a web page publish a list of tools, meaning JavaScript functions with a name, a description and an input schema, that an AI agent in the browser can call directly instead of clicking through the interface. It is specified by the W3C Web Machine Learning Community Group and is in origin trial in Chrome and Edge as of October 2026.

### Is WebMCP the same as MCP?

No. MCP (Model Context Protocol) is an open protocol that connects AI applications to servers over JSON-RPC, using stdio or Streamable HTTP. WebMCP borrows MCP's tool model but is a web API, document.modelContext, that runs inside the page in the user's browser and reuses the user's session. The WebMCP explainer describes the two as complementary, not competing.

### Is it navigator.modelContext or document.modelContext?

The current specification and Chrome's documentation use document.modelContext. Early drafts used navigator.modelContext, which is why many tutorials still show it. The editors moved the API to the Document in 2026 so that tools are scoped to a single document.

### Which browsers support WebMCP?

As of October 12, 2026, Chrome runs an origin trial that started in version 149, and Edge runs one from version 150. Developers can also test locally with a Chrome flag. Firefox and Safari have not signaled support. No browser enables WebMCP by default for all users, and Google has said Gemini in Chrome will support it soon without giving a date.

### Will WebMCP help my brand get cited by ChatGPT or Perplexity?

No, not directly. WebMCP helps agents perform actions on a site the user already has open. Whether an assistant cites or recommends a brand depends on crawlable content and third-party mentions, which is the scope of GEO. Nothing in the WebMCP specification acts as a citation or ranking signal.

## Sources

- [WebMCP (Draft Community Group Report)](https://webmachinelearning.github.io/webmcp/) · W3C Web Machine Learning Community Group
- [WebMCP explainer and repository](https://github.com/webmachinelearning/webmcp) · W3C Web Machine Learning Community Group (GitHub)
- [Browser and Agent Implementation Status](https://github.com/webmachinelearning/webmcp/blob/main/implementation-status.md) · W3C Web Machine Learning Community Group (GitHub)
- [Make tools Document-scoped instead of Window-scoped (issue #173)](https://github.com/webmachinelearning/webmcp/issues/173) · W3C Web Machine Learning Community Group (GitHub)
- [WebMCP is available for early preview](https://developer.chrome.com/blog/webmcp-epp) · Chrome for Developers
- [WebMCP origin trial](https://developer.chrome.com/blog/ai-webmcp-origin-trial) · Chrome for Developers
- [WebMCP declarative API](https://developer.chrome.com/docs/ai/webmcp/declarative-api) · Chrome for Developers
- [15 updates from Google I/O 2026](https://developer.chrome.com/blog/chrome-at-io26) · Chrome for Developers
- [WebMCP feature entry](https://chromestatus.com/feature/5117755740913664) · Chrome Platform Status
- [What is the Model Context Protocol (MCP)? / Architecture overview](https://modelcontextprotocol.io/docs/getting-started/intro) · Model Context Protocol