What Is WebMCP? How Websites Hand AI Agents Real Tools

For years the deal between websites and software was simple: humans get the interface, machines get the API. AI agents broke that deal. An agent arrives on your site like a visitor but reads it like a machine. It scrapes the DOM, infers which button probably submits the form, and breaks the moment you ship a redesign.

WebMCP is the proposal that ends the guessing. It lets a page hand an agent a short menu of things the page can actually do, each described in a form agents understand natively. And it stopped being a browser experiment in August 2026, when OpenAI shipped Site tools, ChatGPT's implementation of WebMCP, in the desktop app's built-in browser. Chrome has been running WebMCP as an origin trial since Chrome 149. Agents are calling tools on real websites today.

If your site captures leads, books meetings, or sells anything, this is worth twenty minutes of your attention now, while the standard is young. The sites that describe themselves clearly to agents get transacted with. The sites that stay illegible get summarized.

Key takeaways

• WebMCP is a proposed web standard that lets a website register named tools, with descriptions and input schemas, that AI agents can discover and call inside the user's own browser session.
• It is inspired by the Model Context Protocol and shares its vocabulary, but it is a web-native design, not an extension of the MCP spec.
• It is running now: ChatGPT's desktop browser ships Site tools, its implementation of WebMCP, and Chrome is running an origin trial from Chrome 149 through 156.
• The standard has two halves. Imperative tools are JavaScript functions an agent can call. Declarative annotations describe the forms you already have, and the submit click stays human unless you opt in.
• The real adoption work is deciding, action by action, what an agent may do versus what it may only understand.
• FraseCMS-hosted sites ship WebMCP automatically: annotated forms and CTAs, plus one read-only tool that lets an agent ask your site a question.

What is WebMCP?

WebMCP is a proposed web standard that lets a website register tools (named actions with descriptions and JSON Schema inputs) that AI agents can discover and call in the user's browser, instead of reverse-engineering the interface. It is incubated in the W3C Web Machine Learning Community Group, with authors from Google and Microsoft, and OpenAI has already shipped an implementation.

The name suggests it extends MCP, the Model Context Protocol that agents use to talk to external tools. The authors are careful to say it doesn't. The explainer describes WebMCP as taking "direct inspiration" and a common vocabulary from MCP (tools, schemas, parameters) while being designed natively for the web, with origins, browser permissions, and page lifecycles that MCP never had to think about. The mental model that works: a page with WebMCP behaves like an in-page MCP server, exposing your site's existing logic instead of a backend API.

Where WebMCP runs today

Two places, and they arrived from opposite directions.

ChatGPT. In August 2026, OpenAI turned on Site tools in the built-in browser of the ChatGPT desktop app. When a person browses a site that registers WebMCP tools, the agent can discover and call them on the same live page, in the same signed-in session the person is looking at. Every call gets a safety review before it runs, and consequential actions still require confirmation. This matters because it settles the biggest open question about WebMCP: whether anyone beyond the browser vendors would honor it. The most-used AI assistant now does.

Chrome. Google is running WebMCP as an origin trial covering Chrome 149 through 156, with a ship decision to follow. Any site can register for the trial and serve tools to real visitors today. For local testing, WebMCP sits behind a flag at chrome://flags/#enable-webmcp-testing, and once that flag is enabled you can install the Model Context Tool Inspector extension from the Chrome Web Store to watch an agent discover and call the tools on your own pages.

This is still the earliest stage of a standard, which is exactly when adopting it compounds. Every prior shift in how machines read the web rewarded the sites that moved before the spec was finished; early schema markup adopters owned rich results for years.

How does WebMCP work?

There are two halves, and the difference between them matters more than most write-ups admit.

Imperative tools: JavaScript an agent can call

A page registers a tool: a name, a description, a JSON Schema for inputs, and an execute function.

if (typeof document.modelContext?.registerTool === "function") {
  await document.modelContext.registerTool({
    name: "search_products",
    description: "Search the store's catalog",
    inputSchema: {
      type: "object",
      properties: { query: { type: "string" } },
      required: ["query"]
    },
    annotations: { readOnlyHint: true },
    execute: async ({ query }) => runExistingSearch(query)
  });
}

Two practical notes. First, feature-detect exactly like this: the API lives on document.modelContext, and early write-ups that reference navigator.modelContext are using an older name the current Chrome and ChatGPT docs have dropped. Second, the execute function runs in the visible tab, in the user's real authenticated session. The agent isn't a bot with separate credentials scraping from outside. It is acting inside the session the human is watching.

Declarative annotations: HTML that describes itself

The quieter half is declarative: annotating the forms you already have so the browser turns them into tools without you writing any JavaScript. A form declares what it does and what its fields mean, and an agent that calls it gets the form focused and filled in front of the user. The submit click stays human unless you explicitly opt into auto-submit. That default is the whole reason this half is the safe place to start.

One current asymmetry worth knowing: Chrome's trial supports both halves, while ChatGPT's browser calls imperative tools only. Declarative annotations still earn their keep everywhere, because any agent that parses your HTML can read what an annotated form does, whether or not it can invoke it as a tool.

Capability vs. consent: the choice WebMCP forces

Here is the design question every site owner will face: which of your site's actions should an agent be able to trigger, and which should it only be able to understand?

Reading is safe to expose as a callable tool. Searching is safe. But submitting a lead form, booking a meeting, placing an order: those are consequential, and the honest answer for most sites is that an agent should be able to see them, describe them, and help a human complete them, while the click that commits stays human. WebMCP supports both postures. Choosing between them, action by action, is the actual work of adopting it.

This split is exactly how Frase ships WebMCP on FraseCMS-hosted sites. Pages carry WebMCP descriptors on their forms and CTAs, so any agent reading the HTML knows what each page lets a visitor do: fill in this form, book this meeting, start this trial. The one callable tool Frase registers is read-only. ask_this_site lets an agent put a question to your site's own Answers widget, riding the same rate limits and safety checks as a human typing one. Nothing an agent can invoke submits a form or books a meeting; that click stays with the human. And if you'd rather sit this out, it switches off per site.

Not sure which category your own site falls into?

How to get your website ready for WebMCP

WebMCP lands on top of the agent-legibility work you should already be doing. The order that pays:

1. Be readable first. Clean HTML, real headings, working schema markup, a Markdown version of your content, an llms.txt. An agent that can't parse your pages has no use for your tools. (The full walkthrough: how to make your website agent-ready.)
2. Decide your action inventory. List what a visitor can do on your site. Mark each one: safe to expose as a callable tool, or describe-only with a human click to commit.
3. Annotate before you automate. Declarative annotations are the low-risk first step. The agent can fill your forms, and the submit stays with the human unless you opt in.
4. Register read-only tools first. Search, lookup, ask a question. Watch how agents use them before you consider anything that changes state.
5. Test with a real agent. Enable the local flag, install the inspector extension, and watch what an agent actually finds when it lands on your pages. Better yet, browse your own site in the ChatGPT desktop app and see whether your tools show up. The rollout there is gradual, so don't panic if they haven't appeared on your account yet.

How to ship WebMCP without building it yourself

Most of that list is real engineering work, unless your content already lives somewhere that does it for you. Frase publishes to WordPress, Sanity, Webflow, Wix, and FraseCMS, and FraseCMS-hosted sites come out agent-legible by default: clean HTML, per-post structured data, Markdown for every post, llms.txt for the site, and WebMCP annotations on every form and CTA, with the read-only ask-this-site tool on top. You write; the site explains itself to every agent that arrives.

Start a free 7-day trial (no credit card) and see what your content looks like when agents can actually read it, and call it.

FAQ

What is WebMCP?

WebMCP is a proposed web standard that lets a website declare structured tools (names, descriptions, and input schemas) that AI agents can discover and call in the user's browser, instead of inferring how the interface works by reading the page.

Is WebMCP live today?

Yes, in two places. ChatGPT's desktop app ships Site tools, its implementation of WebMCP, in the built-in browser. Chrome is running a public origin trial from Chrome 149 through 156, with a ship decision after the trial. The spec is still evolving, so implementations should feature-detect rather than assume support.

Which AI agents can use WebMCP tools?

Today, agents in ChatGPT's desktop browser can discover and call imperative WebMCP tools on the page a user is viewing, and sites enrolled in Chrome's origin trial can expose both the imperative and declarative APIs to agents that work with Chrome. The standard is written so any browser or agent platform can implement it.

How is WebMCP different from MCP?

MCP (Model Context Protocol) connects AI applications to external tools and data, typically server to server. WebMCP is inspired by MCP and shares its vocabulary, but its authors deliberately did not extend the MCP spec. It is a web-native API: the site registers tools in the page, and the agent calls them inside the user's own session.

Does WebMCP replace llms.txt and schema markup?

No. Schema markup and llms.txt make your content readable to agents, while WebMCP makes your functionality callable. They solve different problems, and the readable layer comes first, because an agent that cannot parse your pages has no use for your tools.

Can an AI agent submit forms or buy things through WebMCP?

Only if the site chooses to expose those actions as callable tools. Declarative annotations default to filling a form rather than sending it, so the agent does the typing and the committing click stays with the human. Agent platforms add their own layer on top: ChatGPT's browser reviews each tool call and confirms consequential actions with the user.

Does Frase support WebMCP?

Yes. FraseCMS-hosted sites carry WebMCP descriptors on forms and CTAs, and the Frase Answers widget registers a read-only ask-this-site tool that rides the same safety path as a visitor's typed question. It can be turned off per site.