WebMCP: What the New Browser Standard Means for Your Website

The internet is learning a new language

Ask an AI assistant to book a flight, find a product, or submit a support ticket today, and most agents do it the hard way: they take a screenshot of the page, try to figure out where the button is, move a virtual mouse, click — and guess again every time the site's design changes by a pixel. It's slow, expensive, and fragile.

Now imagine the website simply tells the agent: "I have a tool called searchProducts(destination, date). Call it, and I'll handle the rest." That's what WebMCP makes possible.

WebMCP (Web Model Context Protocol) is a browser standard, developed by Google and Microsoft and currently incubated as a proposed standard in the W3C WebML Community Group. It lets AI agents interact with websites through structured tools rather than screenshots and guesswork. Think of it as a restaurant menu: instead of a waiter guessing what you might want, you point, and the meal happens. WebMCP is the menu your website hands to AI agents.

If you run a website with real traffic — a marketing team, a web manager, or an e-commerce shop — this matters now, because it changes how AI will find, use, and act on your site.

Niche today, mainstream tomorrow

Here's the honest part: WebMCP is, right now, a niche technology for a niche audience. Practically nobody's site uses it yet, and most of the conversations about it happen among early-adopting developers and AI-search optimizers. If you haven't heard of it until this post, you're in the majority — and that's precisely the point.

What changes the calculus is the browser vendors themselves. WebMCP sections are already appearing in the tooling most developers and marketers use every day: Chrome DevTools and Lighthouse now include dedicated WebMCP sections. That's a strong signal. When a browser's built-in developer tools and its performance auditing suite ship first-class support for a protocol, it stops being an experiment and becomes part of the platform's roadmap. Browser support going mainstream — across Chrome, Edge, and the Chromium family — is no longer a question of if but when.

That timing matters for a business. The sites that structure their actions early are the ones agents will choose when usage crosses the threshold. As with structured data (Schema.org) before it, the early movers get the attention; the rest get left out. Getting ready now — even while the audience is still narrow — means you're not scrambling when it becomes table stakes.

WebMCP and MCP: two protocols, one direction

If WebMCP sounds familiar, it's because you've heard of MCP. Anthropic's Model Context Protocol has been the standard for connecting AI applications to external systems since late 2024: a client-server protocol over JSON-RPC that connects AI to databases, search engines, calendars, and SaaS tools. It's the "USB-C port for AI" — one standardized way to plug any AI app into any tool or data source.

WebMCP is related but different. It runs on the frontend, inside the browser, rather than on backend servers. Where MCP connects an AI to your APIs and data, WebMCP connects AI agents to your website itself — the forms, searches, filters, and booking flows visitors use every day. They're complementary, not competing: one manages your backend, the other makes your frontend agent-ready.

How WebMCP works: two ways a site can talk to an agent

WebMCP introduces two browser APIs a website can use to expose its capabilities:

1. The Declarative API — the easy, no-code path. If your site already has clean HTML forms, you add two attributes — toolname="login" and tooldescription="Log in with email and password" — and the form becomes an AI-accessible tool. Well-structured forms get you most of the way there already.
2. The Imperative API — for complex, dynamic actions. For richer flows like filtering a product catalog, running a search, or completing a booking, developers register tools in JavaScript with full parameter descriptions. Instead of an agent clicking through dropdowns and scrolling pages, it makes one structured call and gets clean data back.

Under the hood, the standard is built on three ideas: context (giving the agent the full picture, including content not currently on screen), capabilities (the specific actions an agent can take on the user's behalf), and coordination (a human-in-the-loop handoff — the user stays in control, especially for sensitive actions).

How branchly fits: webMCP as a headless interface

Here's where this stops being abstract. branchly is the AI layer for your website — the thing that sits inside your property and handles your visitors: chat, search, navigation, forms, and the insight engine behind them. When we talk about how your website becomes agent-ready, branchly already does the heavy lifting for you.

On branchly, webMCP is one of the headless interfaces we provide — alongside the public API (for WhatsApp and similar channels) and voice/telephony. Headless means the AI capability isn't tied to a particular user interface; it's exposed as a programmable surface that any client can call. webMCP is the headless interface for browser agents: external AI assistants that arrive on your site and need to actually do things.

Here's the part that matters for you: you don't write any code. No scraper, no registerTool calls, no dev backlog. branchly handles the registration automatically — it's a setting in the branchly platform.

Practically, this is how it works: when you configure an AI agent in your branchly platform — its knowledge sources, its prompts, its guardrails (including whether it may take actions or only answer) — branchly automatically registers that agent as a webMCP tool on your page. Enable the webMCP interface in the platform, and every configured agent is exposed as a structured, documented tool that browser agents can call. You flip a setting; branchly does the rest.

This applies to every industry where visitors get things done on your website — whether a tourism region, travel & hospitality, a public institution, or an educational institution. Exactly these actions become webMCP tools.

For the technically curious, this is what branchly registers for you behind the scenes:

// Registered automatically by branchly — no customer code needed
// Feature-detect: navigator.modelContext (older) || document.modelContext (current spec)
const mc = document.modelContext ?? navigator.modelContext;
mc.registerTool({
  name: "search_knowledge",
  description: "Search live website content & services",
  inputSchema: { type: "object", properties: { query: { type: "string" } } },
  execute: async ({ query }) => branchly.search(query),
});

The agent becomes a structured, documented tool that a browser agent — or a user's AI assistant — can call reliably. Because execution flows through branchly, it inherits everything the platform already provides: your knowledge base as the source of truth, your configured safety rules, and full visibility into every call. That's the difference between "an agent guessing at your website" and "an agent using a tool your platform offers, safely — without you touching the browser API."

What this means for your website

AI discoverability. As AI assistants increasingly browse on behalf of users, agents will favor websites that clearly expose what they can do. A site with webMCP tools is structured, self-describing, and easy to act on. A static site leaves the agent to scrape and guess.

The shift from "find this page" to "complete this task." Traditional search answers "which page should I read?" The agentic web answers "help me get this done." Exposing your agents as webMCP tools lets your website participate — a product searched, a booking made, a ticket logged — instead of watching the agent bounce to a competitor that registered its tools.

Better experiences for the humans who arrive anyway. Fewer roundtrips and no fragile guessing means faster, more reliable interactions — visible as higher satisfaction and lower abandonment, the same signals of a healthy, high-trust site.

What to do about it now (without overreacting)

WebMCP is early, and you don't need to run to implement a custom browser API tonight. But the trajectory is clear, and the moves that future-proof are cheap:

1. Know what your site can do. Document your key actions — search, product queries, bookings, contact. If you already run an AI layer, that documentation largely exists: it's your configured agents.
2. Let your platform expose them. If you're on branchly, you don't build the webMCP integration yourself. Your configured AI agents are already registered as webMCP tools and execute safely through the platform, with your knowledge base and guardrails intact.
3. Watch the browser tooling. DevTools and Lighthouse carrying webMCP sections is your early indicator. When full Chromium support lands, agent-ready sites become the default expectation — and you'll already be set up.
4. Keep humans in control. The standard is designed for cooperative, human-in-the-loop workflows. Design for the user approving and steering, and you're aligned with where the web is heading anyway.

The browser is becoming agent-native

For thirty years the web was built for eyeballs. The next version is being built for agents and people together — and for the first time, there's a real standard for doing that reliably. Right now the audience using it is niche. But with WebMCP inside the standard developer tooling and browser support going mainstream, that's a matter of time, not possibility.

Sites that decide now to surface what they can do — and pair that with a genuine on-site AI layer that does the work — won't just survive the agentic shift. They'll be the ones agents choose, and the ones visitors actually get help from.

Whether an assistant books your flight or finds your product, the rule is the same: make it easy for the agent, and the human who asked gets exactly what they wanted. With branchly, that ease is already a configured AI chatbot on your platform — ready to be a webMCP tool the moment your visitors' AI comes knocking.

FAQ

What is WebMCP?

WebMCP (Web Model Context Protocol) is a browser standard, developed by Google and Microsoft and currently incubated as a proposed standard in the W3C WebML Community Group. It lets AI agents interact with websites through structured tools instead of screenshots and guesswork. A website publishes the actions it can perform — search, filter, book, submit — and an AI agent calls them as documented tools, the way a waiter would use a restaurant menu rather than guessing what's on it.

How is WebMCP different from MCP?

MCP (Model Context Protocol) was created by Anthropic and connects AI applications to external systems — databases, search engines, SaaS tools — over a client-server protocol. WebMCP runs in the browser and connects AI agents to a website's own interface. They're complementary: one manages your backend integrations, the other makes your frontend agent-ready.

Does WebMCP actually work in Chrome today?

It's early. WebMCP is a proposed standard, and today you need an experimental flag — Early Preview in Chromium with #enable-webmcp-testing, or an Origin Trial from Chrome 149 — rather than out-of-the-box support. What makes it worth watching is the browser vendors' momentum: Chrome DevTools and Lighthouse now include dedicated WebMCP sections, and browser support going mainstream across the Chromium family is a matter of time. Getting ready now means you're not scrambling when it becomes table stakes.

What does WebMCP mean for my website's AI?

WebMCP is the headless interface for browser agents: external AI assistants arriving on your site that need to actually do things. If you run branchly, every AI agent you configure in the platform is registered as a webMCP tool, so external agents can call your chat, search, or navigation capabilities through structured, documented tools — executed safely through the platform with your knowledge base and guardrails intact.

Do I need to build the webMCP integration myself?

No. If you're on branchly, you don't hand-roll a list of tools or maintain fragile scraping logic. You configure your agents in the platform — with their knowledge sources, prompts, and guardrails — and branchly exposes them as webMCP tools that execute safely. You get agent-readiness without building a browser API from scratch.

How do I make my website agent-ready?

Ask two questions: what can my site do that a visitor would want done, and which of those actions should an agent be allowed to perform? Document the actions — search, product query, booking, contact — and expose them as structured, documented tools. On branchly, this means enabling the webMCP headless interface and configuring your AI agents with knowledge sources and guardrails; branchly registers them as webMCP tools on your page automatically. It's a checklist, not a rewrite.

Want a concrete walkthrough for your site? Book a demo.

Is WebMCP secure?

Security and human control are first-class concerns in the standard. It's built around coordination — a human-in-the-loop handoff where the user stays in control, especially for sensitive actions like payments or account changes. When execution flows through a platform like branchly, it inherits your configured safety rules and full visibility into every call.

Should I implement WebMCP now?

You don't need to rush a custom implementation tonight, but the future-proofing is cheap: know what your site can do, let an AI layer expose those actions, watch the browser tooling for adoption signals, and keep humans in control. Sites that structure their actions early are the ones agents will choose once usage crosses the threshold.