WebMCP answers a simple question: how should an AI agent use a website without guessing? Today agents scrape HTML, read screenshots, and simulate clicks, and they break the moment a developer renames a CSS class. WebMCP gives sites a way to say, in a machine-readable format, "here is what you can do here." This guide covers the protocol itself: architecture, implementation paths, and where the spec stands.
WebMCP (Web Model Context Protocol) is a proposed browser protocol that lets a website register structured tools that AI agents can discover and call directly, inside the user's session and with the user's consent. Instead of inferring what a page does, the agent reads a declared list of actions and executes them with exact parameters.
What problem does WebMCP solve?
Current agents fly blind. To buy a ticket or check availability they parse the DOM, interpret screenshots with vision models, or click through interfaces by trial and error. Each of those methods is slow and fragile, and every UI redesign breaks them.
The waste is enormous. An agent burns thousands of tokens reconstructing what a simple form already knows about itself. WebMCP removes the reconstruction step: the site states its capabilities, the agent uses them.
How does the protocol work?
WebMCP follows a client-server model, described by the Chrome team as a structured communication layer between models and live web applications:
- The client is the LLM application, the part that interprets the user's goal and decides which tool to call.
- The server is the web application, which exposes tools and data.
Communication runs on a JSON request and response pattern. The model sends a tool call, such as "check flight availability" with structured parameters, and the site returns a structured result. The channel is bidirectional and designed for low latency, which keeps agent-driven interactions responsive.
This is the same plumbing that powers tool-augmented answering. If you want the background on how models pull in live data, our explainer on retrieval-augmented generation (RAG) covers the retrieval side of the stack.
Dynamic discovery: the real shift for developers
Before protocols like this, every integration between a model and a service was hardcoded. Developers wired specific API calls into prompts, and each change on either side meant rework.
WebMCP inverts the relationship. The site declares its capabilities and their schemas; the model discovers them at runtime and picks the right tool for the current goal. You can update tools, rename parameters, or add capabilities without touching the agent's prompt. This decoupling is what makes the approach maintainable at web scale.
How do you implement WebMCP today?
Google Chrome Labs published webmcp-tools, a repository with the scaffolding to turn a website into a client-side MCP server, including React and vanilla TypeScript demos.
There are two paths to expose functionality:
- Declarative, HTML-based. You annotate existing form elements with tool name and tool description attributes. The browser translates them into machine-readable schemas automatically. Lowest effort, best for standard forms.
- Imperative, JavaScript-based. You call the registerTool() function on the navigator.modelContext API and define custom logic with your own JSON schemas. More work, full control.
A reasonable first project looks like this:
- List the user actions on your site that an agent could plausibly perform, such as search, availability checks, or quote requests.
- Annotate the forms behind those actions, or register them as tools in JavaScript.
- Test the flow through the tab transport, inside a normal authenticated session.
- Log every agent call, so you learn which tools get used and where they fail.
Is it safe to let agents act on a site?
The spec builds consent in. The toolkit ships tab and extension transports, which means agents operate inside the user's own authenticated session rather than through an external backdoor. Actions follow a human-in-the-loop philosophy: the user sees what the agent wants to do and approves it.
That design choice matters for adoption. Site owners keep their existing auth and permissions, and users keep the final word on anything the agent executes.
Where does the spec stand?
WebMCP is young, and it is worth being precise about maturity. Documented today: the Chrome team's early preview program, the public tooling, and working demos. Not documented: a finalized standard, or meaningful production adoption numbers. We think the protocol, or something shaped like it, becomes part of the default web stack, but that part is forecast rather than fact.
What the shift means for search, SEO, and business models is a separate discussion. We wrote it up in our analysis of the agentic web and its impact on AI SEO. And if you want to know whether AI engines already find and cite your site, before any agent tries to use it, RankWit measure exactly that across ChatGPT, Perplexity, Gemini, AI Overviews, Claude and Grok.
FAQ
What is WebMCP in one sentence?
WebMCP is a proposed browser protocol that lets a website declare structured tools, such as search or checkout actions, that AI agents can discover and call directly, with the user approving what runs. It replaces screen scraping and simulated clicks with explicit, machine-readable capabilities.
Does WebMCP replace my public API?
No. An API serves developers who integrate with you deliberately. WebMCP serves agents that arrive through the browser, inside a user's session, and need to act on the interface itself. Many sites will end up offering both, often backed by the same business logic.
What is the difference between WebMCP and MCP?
MCP connects models to backend tools and data sources, typically server to server. WebMCP applies the same idea to the frontend: the website itself becomes the tool provider, and the browser is the transport. They are complementary layers of one stack.
Can I try WebMCP now?
Yes, experimentally. The webmcp-tools repository from Google Chrome Labs includes scaffolding and demos in React and vanilla TypeScript, and Chrome runs an early preview program for developers. Expect details to change; the spec is not final.