WebMCP explained: Inside Chrome 146’s agent-ready web preview

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.

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:

Discovery: What tools does this page support? Checkout, BookFlight, searchProducts.
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”}
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.

Your customers search everywhere. Make sure your brand shows up.

The SEO toolkit you know, plus the AI visibility data you need.

Start Free Trial

Get started with

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 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.

Get the newsletter search marketers rely on.

See terms.

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 ecommerce 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.

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 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

Open Chrome and navigate to chrome://flags/#enable-webmcp-testing
Find the “WebMCP for testing” flag and set it to “Enabled”
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.

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.

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.

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.

See the complete picture of your search visibility.

Track, optimize, and win in Google and AI search from one platform.