What Is WebMCP? How Websites Give AI Agents Tools

Suppose you ask a browser assistant to find the return policy on a store’s help page. It might have to work out which search box to use, type a query, and read the results. With WebMCP, the page can offer a named help search tool that accepts the query and returns matching answers. The assistant has a defined action to call and a result it can interpret.

WebMCP is a proposed browser API that lets websites offer structured tools to compatible AI agents. A tool can look up information, filter a list, or help fill a form. The website describes the action, and the browser gives a supported agent a way to discover and invoke it in the page’s context.

How a WebMCP tool works

When a web page registers a tool, it describes what the tool does and which inputs it expects. This description gives an agent a way to choose an action based on what the user asked for.

Part	What it does	Help search example
Name	Identifies the action	find_help_answers
Description	Explains when to use it	Find answers in the public help centre
Input schema	Describes the fields the tool accepts	A required query string
Implementation	Carries out the action on the page	Search the FAQ entries
Result	Tells the agent what happened	Matching answers or an empty list

An input schema is a machine-readable description of the expected arguments. A compatible agent can pass a query such as returns in the named field. The website then runs its own search logic and returns the result. The schema gives the agent a guide to the inputs. The tool still needs to validate what it receives.

The page controls which actions it offers. A search tool can return public help entries, while a form tool can guide the user through a workflow. To discover a site’s tools, the browser or agent needs to visit the site. Tool availability can vary with the page, the browser, and the agent.

WebMCP and MCP

Both use the idea of tools with structured inputs. They connect those tools to an assistant in different ways.

	WebMCP	Model Context Protocol (MCP)
Where the tools come from	A web page registers actions in its browser context	An MCP server exposes capabilities to a connected client
What makes a tool available	The relevant page offers it and the browser and agent support it	The client connects to the server through a supported transport
Typical example	Filter results on the site open in a browser	Query a service through an MCP server connected to an AI application

A site can use WebMCP for an interaction on an open page and offer a separate MCP server for clients that connect directly to its service. The WebMCP Community Group draft describes the browser API and leaves the browser free to choose how it presents those tools to its agent. The draft is published by the W3C Web Machine Learning Community Group.

Two ways to expose a tool

Describe an existing HTML form

In Chrome’s experiment, the declarative API uses attributes on an HTML form. toolname identifies the action and tooldescription describes its purpose. The browser uses named form fields to represent the tool’s parameters. A help centre with a working search form can add those descriptions while preserving the input, label, and submit button people already use.

For example, a form can offer a search_help tool with a named query field. The agent can fill the field, and the user can review it and submit the form. Chrome also experiments with automatic submission through the toolautosubmit attribute. Choose the submission behaviour based on the action and what the person needs to review. Standard HTML form labels and structure still matter for people using the page directly.

Register an action in JavaScript

The imperative API lets a script register a tool through document.modelContext.registerTool(). This fits actions that need application logic, such as searching a list already loaded on the page or applying several filters together. The action can call the same logic the visible interface uses.

Consider this read-only FAQ search. Save the example as faq-tool.js and load it on a test page with <script type="module" src="./faq-tool.js"></script>. The example searches two sample entries. If the API is unavailable, the page skips registration and keeps its ordinary controls.

const answers = [
  {
    question: 'Where can I find the returns policy?',
    answer: 'Open Returns in the help centre.',
  },
  {
    question: 'How can I track an order?',
    answer: 'Open Orders and select the order you want to track.',
  },
]

if (document.modelContext?.registerTool) {
  await document.modelContext.registerTool({
    name: 'find_help_answers',
    description: 'Finds answers in the public help centre.',
    inputSchema: {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: 'Words from the question the visitor wants answered.',
          minLength: 2,
          maxLength: 80,
        },
      },
      required: ['query'],
    },
    annotations: { readOnlyHint: true },
    execute(input) {
      const query = typeof input?.query === 'string' ? input.query.trim() : ''
      if (query.length < 2 || query.length > 80) {
        return { error: 'Enter a query between 2 and 80 characters.' }
      }
      const term = query.toLowerCase()
      const matches = answers.filter(entry =>
        entry.question.toLowerCase().includes(term),
      )
      return { matches }
    },
  })
}

The execute function checks the input before it searches. A query such as returns produces one matching entry in this example, and a valid query with no matches produces an empty array. The readOnlyHint describes the tool to consumers. The implementation itself determines whether it changes any data.

How to try WebMCP in Chrome

As of November 2026, Chrome documents WebMCP as an experiment with an origin trial that began in Chrome 149. An origin trial gives participating sites a way to opt in for testing in supported browser versions. Chrome also documents a local testing flag. Chrome WebMCP documentation

1. In a compatible test browser, enable the WebMCP testing flag at chrome://flags/#enable-webmcp-testing and relaunch Chrome.
2. Open the test page on localhost or HTTPS. Keep a normal search interface available for visitors.
3. Open Chrome DevTools and look for Application → WebMCP. In builds with that pane, select find_help_answers under Available tools to inspect its inputs and run it manually.
4. Try returns, a query with no matches, and an invalid input. Check that the result is understandable in each case. If your build lacks the pane, Chrome’s documentation describes other testing tools.
5. Load the page again with WebMCP unavailable and check that the ordinary controls still work.

The API is tied to the document. For a site that changes views without loading a new document, manage which tools remain available as the user moves between views. The registration API accepts an abort signal so the site can remove a tool that no longer applies to the current view.

What should a website offer first?

Start with one action that has a clear purpose and a result the visitor can verify. Public help search, product filtering, or checking public availability are reasonable starting points. A useful tool description tells an agent when the action fits the user’s request. A useful result makes it clear whether the action found something, changed the visible page, or needs more information.

Reuse existing permissions and business rules. For tools that update account information, place orders, or send messages, keep the relevant server checks and give the person a clear chance to review consequential changes. Return only the data the task needs. Check how an interrupted or repeated call behaves before offering an action that makes changes.

What WebMCP means for SEO

WebMCP concerns interactions on a page that a compatible browser agent has reached. Search visibility depends on the search engine’s own discovery, indexing, and ranking systems. Google’s published eligibility guidance for AI Overviews and AI Mode still focuses on indexed pages that are eligible to appear with a snippet.

If a help centre offers a WebMCP search tool, keep the useful articles available at their own URLs with regular internal links. Check that search crawlers can find the pages and access their important content, including when the site depends on JavaScript rendering. The tool gives a supported assistant another way to help someone use the site once it is open.

Start with a task people already do

Pick an existing task such as looking up a help answer. Give it a clear name, a small input schema, and a result you can check. Test it with a compatible browser and through the ordinary site interface. That gives you a concrete basis for deciding whether to offer more actions as WebMCP develops.