WebMCP: The Standard That Lets AI Agents Call Website Functions Directly

Chrome 146 has introduced an early preview of WebMCP behind a flag. WebMCP (Web Model Context Protocol) is a proposed web standard that exposes structured tools on websites, showing AI agents exactly what actions they can take and how to execute them.

Here’s some context around what that actually means.

The internet was originally built for humans. We designed buttons, dropdowns, and forms for people to read, understand, and use. But now there’s a new type of user emerging: AI agents. Soon they’ll be able to complete registrations, buy tickets, and take any action needed to complete a goal on a website.

Right now, AI agents face a major challenge. They must crawl websites and reverse-engineer how everything works. For example, to book a flight, an agent needs to identify the right input fields, guess the correct data format, and hope nothing breaks in the process. It’s inefficient.

The WebMCP standard will solve this issue by exposing the structure of these tools so AI agents can understand and perform better.

A Deeper Understanding of WebMCP

Let’s say you need to book a flight.

Without WebMCP: An AI agent would crawl the page looking for a button that would say something like “Book a Flight” or “Search Flights.” The agent reads the screen, guesses which fields need what information, and hopes the form accepts its input.

With WebMCP: Instead of thinking “I need to find a ‘Book a Flight’ button,” the agent thinks “I need to call the bookFlight() function with clear parameters (date, origin/destination, passengers) and receive a structured result. The agent doesn’t search for visual elements. It calls a function, just like developers do when working with APIs.

WebMCP is a joint effort between Google and Microsoft, with engineers from the Chrome and Edge teams driving the spec. Its roots go back to MCPB, a project Alex Nahas built at Amazon in early 2025 to handle the auth challenges of running internal services as MCP servers. The W3C Web Machine Learning Community Group formally accepted the WebMCP specification in September 2025, with native browser support across Chrome and Edge targeted for the back half of 2026. Lighthouse 13.3.0 now ships the agentic-browsing audit in its default config.

How WebMCP Works

WebMCP provides JavaScript APIs and HTML form annotations so AI agents know exactly how to interact with the page’s tools. It works using basically three steps:

1. Discovery: What tools does this page support? Checkout, BookFlight, searchProducts.
2. JSON Schemas: The exact definitions of what inputs are expected and what outputs come back.
   • For example, a bookFlight tool might expect:
     • Input: {origin: “LON”, destination: “NYC”, outboundDate: “2026-06-10”, passengers: 2}
     • Output: {confirmationNumber: “ABC123”, totalPrice: “$850”, status: “confirmed”}
3. State: Tools can be registered and unregistered based on the current page state. For example, a checkout tool only appears when items are in the cart, or a bookFlight tool becomes available after a user selects dates. This ensures agents only see relevant actions for the current situation.

Your website exposes a list of actions, each one describing what it does, what inputs it accepts, what outputs it returns, and what permissions it requires.

Why This New Standard Matters

AI agents are quickly becoming part of our daily workflows. Soon we won’t book our own flights, fill out forms, or publish content — we’ll ask an AI to do it for us.

But right now, AI agents struggle to interact with websites reliably. They currently use two imperfect approaches:

Automation (Fragile and Unreliable): In this approach, the AI agent reads the screen, clicks buttons, and types into fields, just like a human would. However, websites are constantly updated. Button colors change. Field names change. Classes change. A/B tests create different versions of the same page. What worked yesterday may not work today.

APIs (Limited Availability): APIs provide a direct, structured way for agents to interact with websites. The problem is that most websites don’t have public APIs, and those that do are often missing key features or data that’s available through the user interface.

WebMCP: The Missing Middle Ground

WebMCP fills the gap between those two approaches. It lets websites expose actions in a way that matches how the web actually works. Think of it as making your existing web interface readable by AI agents — without the fragility of UI automation or the overhead of maintaining a separate API.

The Speed Gap: A WebMCP tool call completes in a single round trip. The agent reads the schema, sends the structured inputs, and gets back a typed response. A conventional browser agent doing the same task has to load the page, screenshot the DOM, interpret the UI, identify each element, click, wait, and screenshot again at every step. Every loop costs wall-clock seconds and tokens. WebMCP collapses that into one call.

The Growth Opportunity

Just as websites optimized for search engines in the 2000s, WebMCP represents the next evolution: optimization for AI agents. Early adopters who implement WebMCP could gain a competitive advantage as AI-powered search and commerce become mainstream.

But this isn’t just about SEO anymore. It’s about seizing a broader growth opportunity. SEO, AEO (AI Engine Optimization), and agentic optimization are all knowledge areas with one common goal: improving revenue. WebMCP opens the door to being not just discoverable, but directly actionable by the agents your future customers will use.

Real-World Examples

To make this more concrete, here are some scenarios where WebMCP changes the game:

B2B Scenarios

• Quote and Proposal Requests: Industrial suppliers expose a request_quote tool. A buyer’s agent can submit identical RFQs across multiple vendors without adapting to each site’s unique form.
• Vendor Qualification Filtering: Service providers expose a search_capabilities tool. Before making contact, a procurement agent can query multiple vendors to filter for specific certifications or geographic coverage.
• Freight and Logistics Rate Shopping: Carriers expose get_shipping_rate and schedule_pickup tools. A logistics agent can query multiple carriers and book the best option without navigating unique quoting interfaces.
• Commercial Insurance Quoting: Insurance carriers expose request_policy_quote tools. A broker’s agent can submit the same business information across multiple carriers to compare coverage options without re-entering details on each insurer’s portal.
• Wholesale and Distribution Ordering: Distributors expose check_inventory and get_volume_pricing tools. A purchasing agent can query stock levels and pricing across multiple distributors and place an order with whichever offers the best combination of availability and price.

B2C Scenarios

• Multi-Retailer Price Comparison: Retailers expose search_products and check_price tools. A consumer’s agent can query multiple stores, compare options, and add items to the cart at whichever retailer offers the best deal — all in seconds.
• Restaurant Discovery and Booking: Restaurants expose browse_menu and reserve_table tools. An agent can find availability and search menus across multiple restaurants before booking a table at the best match for your preferences.
• Local Service Provider Quoting: Service businesses expose check_availability and request_quote tools. If you need a plumber or electrician, for example, an agent can collect quotes from multiple providers without you having to fill out intake forms on each company’s website.
• Travel Planning Across Providers: Airlines, hotels, and car rentals expose search_availability and book_reservation tools. An agent can query multiple providers directly and assemble a complete itinerary without an aggregator like Expedia or Kayak.
• Real Estate Search and Tour Scheduling: Listing sites expose search_properties and schedule_showing tools. A buyer’s agent can search across different platforms and book property tours without navigating unique forms.

How to Implement WebMCP

WebMCP gives developers two ways to make their websites agent-ready:

• Imperative API
• Declarative API

The Imperative API

The Imperative API lets developers define tools programmatically through a new browser interface called navigator.modelContext. You register a tool by giving it a name, a description, an input schema, and an execute function.

Here’s a simplified example of an E-commerce Product Search Tool:

The agent sees the tool, understands what it does, knows what input it needs, and can call it directly.

Developers can register tools one at a time with registerTool(), replace the full set with provideContext() (useful when your app’s state changes significantly), or remove them with unregisterTool() and clearContext().

The Declarative API

The Declarative API transforms standard HTML forms into agent-compatible tools by adding a few HTML attributes.

Here’s a simplified example of a Restaurant Reservation Form:

By adding toolname and tooldescription to a form, the browser automatically translates its fields into a structured schema that AI agents can interpret. When an agent calls the tool, the browser populates the fields and, if toolautosubmit is set, it submits the form automatically.

The Big Takeaway: Existing websites with standard HTML forms can become agent-compatible with minimal code changes.

A Third Path: Edge-Deployed WebMCP

If you don’t want to hand-wire WebMCP into every page, edge-based implementations exist. cf-webmcp is an MIT-licensed Cloudflare Worker that publishes the full WebMCP discovery stack from a single TOML file. No origin code changes required.

It serves the manifest at /.well-known/webmcp.json, auto-injects the bootstrap script into HTML responses, stamps declarative attributes onto matching forms, and publishes llms.txt, AGENTS.md, an RFC 9727 API catalog, and a Cloudflare-spec Agent Skill at the conventional paths.

The project ships three templates: default, WordPress, and WooCommerce. For most sites already on Cloudflare, this is a two-minute deploy. See the live demo or the repo for full setup steps.

Implementation Best Practices from Google’s Documentation

Google’s early preview documentation includes some practical guidance on designing good WebMCP tools. A few highlights worth noting:

• Use Specific Action Verbs: Name tools based on what they actually do. Use create-event if the tool immediately creates an event. Use start-event-creation-process if it redirects the user to a UI form. Clear naming helps agents choose the right tool for the task.
• Accept Raw User Input: Don’t ask the agent to perform calculations or transformations. If a user says “11:00 to 15:00,” the tool should accept those strings, not require the agent to convert them to minutes-from-midnight.
• Validate in Code, Not Just in Schema: Schema constraints provide guidance, but they’re not foolproof. When validation fails, return descriptive error messages so the agent can self-correct and retry.
• Keep Tools Atomic and Composable: Each tool should do one specific thing. Avoid creating overlapping tools with subtle differences. Let the agent handle the workflow logic.
• Return After the UI Updates: When a tool completes an action, make sure the UI reflects that change before returning. Agents often verify success by checking the updated interface, then use that information to plan their next step.

How to Measure Your WebMCP Readiness

Chrome Canary 150+ now ships Lighthouse 13.3.0 with a new agentic-browsing audit category. It tells you exactly what an AI agent would see when it visits your site.

What the audit checks:

• whether the page exposes a clean accessibility tree
• which WebMCP tools are registered (imperative and declarative)
• whether input schemas validate
• form coverage (annotated vs invisible to agents)
• whether llms.txt follows the recommendations

How to run it:

1. Install Chrome Canary 150 or higher.
2. Open Lighthouse in DevTools and select the agentic-browsing category.
3. Run the audit and review the score.

Lighthouse’s new agentic-browsing audit category, available in Chrome Canary 150+

This is the fastest way to see where your site sits on the readiness curve.

How to Try WebMCP Today

WebMCP is currently available as an early preview behind a feature flag in Chrome 146. It’s not production-ready yet, but developers and curious teams can already experiment with it.

Requirements

• Chrome version 146.0.7672.0 or higher
• Basic familiarity with Chrome flags 

Setup Steps

1. Open Chrome and navigate to chrome://flags/#enable-webmcp-testing
2. Find the “WebMCP for testing” flag and set it to Enabled
3. Relaunch Chrome to apply the changes

Once the flag is enabled, you can install the Model Context Tool Inspector Extension to see WebMCP in action. The extension lets you inspect registered tools on any page, execute them manually with custom parameters, or test them with an AI agent using Gemini API support. Google also has a live travel demo where you can see the full flow, from discovering tools to invoking them with natural language.

Beyond Chrome’s Preview: The MCP-B Ecosystem

Chrome’s flag isn’t the only way to experiment with WebMCP. The MCP-B project offers a polyfill that runs in any modern browser, even without native support. Their @mcp-b/webmcp-local-relay package goes one step further, bridging WebMCP tools into Claude Desktop and other MCP-aware clients.
Together, these tools let you build agent workflows on WebMCP today, until native support lands in the second half of 2026.

What All This Means Going Forward

In the same way that mobile-first design changed how we build websites, agent-ready design could define the next generation of web applications.

Think of WebMCP the same way you thought about responsive design in 2012. You did not rebuild your site for mobile. You added breakpoints, adjusted layouts, and let the same HTML serve both audiences. WebMCP is the same kind of annotation layer. Existing HTML forms become agent-ready by adding two attributes. Existing JavaScript becomes agent-callable by registering a tool. The work is incremental, not a rebuild. The sites that move first compound their lead as agentic browsers go mainstream.

That said, WebMCP is still in early preview. The final version will likely change. The Chrome team is actively discussing rolling back parts of what they’ve been building with the embedded LLM API (like summarization and other features). So what we’re seeing now is a starting point, not the finished product.

Current Limitations

WebMCP is still in early preview, and that shows in three specific places worth flagging before you commit to a roadmap.

Security: Cross-tab isolation is still maturing. If an agent operates across two tabs at once, there is no enforced boundary yet to stop sensitive context from leaking. Expect a CORS-style policy framework to land before WebMCP is safe for high-trust workflows like banking or healthcare.

Scope: WebMCP today is the tool-calling layer. Resources and prompts, two other primitives in the full MCP spec, are not part of WebMCP yet. If your agent workflow needs to read documents or pull from structured data sources, run a parallel MCP server for that side of the job.

Tooling: Consumer-facing tooling is limited. Most testing today happens through the Model Context Tool Inspector extension or MCP-B’s polyfill. Expect this to expand significantly once native support lands in mid-to-late 2026.

Visibility Precedes Execution

Agents don’t start their journey on your site. They start with an LLM answer. If your brand isn’t cited in those answers, you’re not in the consideration set, no matter how well-optimized your WebMCP layer is.

That makes the AI visibility work we’ve been doing over the past year the prerequisite, not the alternative. The LLM citation is the entry point. WebMCP is what happens once the agent arrives.

Same goal, two layers: be cited, then be usable. The pieces we’ve written this past year build the first layer. WebMCP extends it into the second.

If you’ve been following our work on AI and search, WebMCP represents the natural evolution of our thinking. Over the past year, we’ve explored: 

• How AI bots differ from traditional search engine bots
• The types of AI bots and whether to block them from your site
• New SEO strategies like query fan-out for AI-powered search
• How to optimize content for AI search engines 
• How to get your brand cited by LLMs through strategic seeding

WebMCP is simply the next chapter in AI optimization. While aiming for discoverability and citation is still essential, WebMCP opens up a new opportunity for brands — making entire web experiences and functionality accessible to AI agents. It’s not just about being found or cited. It’s about being usable by the next generation of web users.

Frequently Asked Questions

A few of the questions that come up most often when teams start evaluating WebMCP:

1. Is WebMCP the same as MCP?
   No. MCP runs as a separate server. WebMCP runs inside the browser tab and inherits the user’s authenticated session. They’re complementary. A real B2B product will usually want MCP for anything that runs without a user present, and WebMCP for anything that needs the user’s permissions and the current page state.
2. Do I need WebMCP if I already have a public API?
   Yes, if you have a customer-facing UI. APIs cover backend operations, but they typically miss the UI-driven flows your users actually rely on. WebMCP exposes those flows directly, with the user’s existing session and permissions already attached.
3. When will WebMCP be production-ready?
   Native browser support is expected across Chrome and Edge in the second half of 2026. Until then, polyfills like MCP-B let you experiment and prototype with current browsers.
4. Does WebMCP replace SEO?
   No. Agents discover brands through LLM citations first, then act once they arrive. That makes SEO and AI visibility the prerequisite, not the alternative. WebMCP is the execution layer on top of the visibility foundation you’ve already built.
5. How is WebMCP different from Playwright or browser automation?
   Playwright and similar tools simulate a human user, clicking buttons and filling fields. WebMCP exposes structured functions directly. The agent calls the function and gets a typed response, instead of inferring intent from pixels and DOM nodes.
6. Can I test my site’s readiness today?
   Yes. Lighthouse 13.3.0 ships in Chrome Canary 150+ with a new agentic-browsing audit category. Run it against your site and you’ll get a score plus a breakdown of what an AI agent would actually find.