WebMCP: The New SEO? How to Prepare Your Website for AI Agents
Before WebMCP There Was MCP
In November 2024, Anthropic — one of my favorite AI companies for the quality of their models and the values they stand for — released the Model Context Protocol (MCP), an open standard for connecting AI assistants to external data sources and tools.
The idea was simple but ambitious: instead of every integration between an AI and an external service requiring a custom implementation, MCP proposes a universal protocol. A common language.
MCP defines a client-server architecture where the AI model acts as the client and external systems act as MCP servers. Communication happens via JSON-RPC, with SDKs available in TypeScript, Python, Java, Kotlin, C#, Go, PHP, Ruby, Rust, and Swift.
The protocol is open. Any developer can create MCP servers for their software, and any AI model can consume them without provider-specific adaptations.
How MCP Has Evolved Since Launch
From November 2024 to today, MCP has evolved rapidly and significantly.
Anthropic released the code, documentation, and tooling on GitHub. The community started building connectors for Google Drive, Slack, GitHub, Postgres, and many more. SDKs were added in multiple languages, lowering the barrier to entry, and thousands of MCP servers are already running in production.
The most relevant development is that MCP stopped being an Anthropic-only initiative. OpenAI, Google, and Microsoft announced compatibility or integration with the protocol. And the definitive step: Anthropic donated MCP to the Linux Foundation as part of the new Agentic AI Foundation (AAIF), backed by AWS, Google, Microsoft, Block, and Bloomberg. The goal is to keep it neutral, open, and community-driven.
In parallel, there’s already academic research on MCP server security, techniques for auto-generating servers from OpenAPI specifications, and proposals for shared context across multiple agents.
MCP is now a de facto standard for AI integration with the outside world. But it operates on the backend. What about the web?
WebMCP: MCP Comes to the Browser
This is where WebMCP enters the picture.
WebMCP is a proposal from the W3C Web Machine Learning Community Group that extends MCP’s philosophy to the frontend. It allows websites to expose structured tools directly to AI agents from the browser, without relying on dedicated backend APIs.
The specification is edited by Brandon Walderman (Microsoft), Khushal Sagar and Dominic Farolino (Google). A draft was published on February 12, 2026, and Google released an early preview in Chrome 146 that same month.
The core idea is that a web page can function as an MCP server, but implementing tools in client-side JavaScript instead of on a backend.
Why This Matters for Web Developers
Until now, AI agents interact with websites in two ways, and both have serious problems.
The first is via screenshots: the agent receives an image of the page and has to visually interpret where to click. It’s slow, fragile, and burns through tokens. The second is via DOM inspection: the agent reads raw HTML and tries to extract structure from markup. But HTML was designed for rendering, not for machine comprehension.
WebMCP eliminates both of those interpretation layers. Instead of the agent guessing how to use your site, you tell it exactly what it can do.
How the API Works
WebMCP exposes an API through navigator.modelContext. A website registers tools — JavaScript functions with a name, natural language description, and input schema — that agents can discover and invoke directly.
A conceptual example would look something like this:
navigator.modelContext.provideContext({
tools: [
{
name: "searchProducts",
description: "Search products by category and price range",
inputSchema: {
type: "object",
properties: {
category: { type: "string" },
maxPrice: { type: "number" }
},
required: ["category"]
},
execute: async (input) => {
const results = await searchAPI(input.category, input.maxPrice);
return results;
}
}
]
});There’s also a declarative API based on HTML forms that requires no JavaScript at all:
<form toolname="searchFlights" tooldescription="Search available flights">
<input name="origin" type="text" required pattern="[A-Z]{3}">
<input name="destination" type="text" required pattern="[A-Z]{3}">
<input name="date" type="date" required>
<button type="submit">Search</button>
</form>This lowers the barrier to entry dramatically. If your website already has well-structured forms, the path to WebMCP is very short.
WebMCP vs MCP: What’s the Difference?
It’s important to understand that WebMCP doesn’t replace MCP. It complements it.
MCP operates on the backend, with servers communicating via JSON-RPC. WebMCP operates in the browser, exposing tools through a standard JavaScript API. The browser acts as an intermediary, translating the tools you define into MCP format when communicating with agents.
MCP connects AI models to external services and data. WebMCP lets AI agents interact with web interfaces in a deterministic and secure way, within the user’s session, reusing their authentication and context.
Security and User Control
One of the most interesting aspects of WebMCP is its permission model. The specification includes requestUserInteraction, which lets tools request user confirmation before executing actions.
This is key. An agent can’t send an email or make a purchase without the user confirming it. Control remains human. This is what the ecosystem calls human-in-the-loop, and WebMCP has it baked into the design.
Compared to browser extensions or bookmarklets that operate with broad permissions, WebMCP enables granular control: the site decides which tools to expose and which to withhold.
The New SEO?
Here’s the reflection I find most relevant for the future.
Today we optimize our websites for search engines to understand them. Tomorrow we’ll need to optimize them for AI agents to interact with them.
If your site doesn’t expose tools to agents, you simply won’t exist in that new interaction channel. Agents will skip right past you, just like Google skips sites with no sitemap or semantic HTML.
I’m not saying WebMCP will replace SEO. I’m saying it will add a new optimization layer. A layer where you’re not optimizing for a crawler that indexes text, but for an agent that wants to execute actions on your site.
And those who implement it first will have an advantage, as always happens with emerging standards.
Current Status and What to Do Today
Let’s be clear: WebMCP is in a very early stage. It’s a Community Group draft at the W3C, not a final standard. There’s only an early preview in Chrome 146 Canary. Firefox and Safari haven’t announced support yet.
Don’t ship it in production right now.
But there are things you can do today to prepare for when it arrives.
First, structure your HTML forms properly. Use correct semantics, clear attributes, validation patterns. When WebMCP stabilizes, converting well-built forms into tools will be almost immediate with the declarative API.
Second, implement llms.txt on your site to make it discoverable by AI systems. It’s the immediate, stable standard for agent visibility.
Third, follow the specification. The W3C Web Machine Learning Community Group GitHub repository has all the documentation and is updated frequently.
And fourth, get familiar with MCP. If you already know how to create MCP servers, the jump to WebMCP will be natural.
Conclusion
WebMCP is one of those technologies you can’t use in production yet but should understand now.
The direction is clear: browsers will be the bridge between user intent and AI capability. And web developers are the ones who will build that bridge, tool by tool, form by form.
MCP gave us the universal protocol for the backend. WebMCP brings it to the frontend. And when both mature, the web as we know it will change fundamentally.
My advice: don’t wait for it to become a standard to understand it. Start reading the spec, experiment with the Chrome preview, and design your frontend with the understanding that an agent will want to use it.
Because if SEO was about preparing your site for machines to read it, WebMCP is about preparing it for machines to use it.
Useful links: