Google Chrome Previews WebMCP: Letting AI Agents Use Your Website

WebMCP is a new browser feature that lets your website tell AI agents exactly what it can do, so they don’t have to guess by clicking around. On 10 February 2026, the Chrome team opened an early preview of WebMCP for developers. It is not a ranking factor and it is not live for normal users yet. But it shows where agent traffic is heading.

If you run a website, you probably have three questions. What is it? Does it change anything for SEO right now? And should you do anything this week? I answer all three below, in plain words, based on what Google and the spec authors had published by 11 February 2026.

What Is WebMCP?

WebMCP stands for Web Model Context Protocol. It is a proposed web standard that lets a web page publish a list of “tools” for AI agents. An AI agent is a program that can plan steps and take actions for a person, such as searching for a flight or filling in a form.

A tool is simply an action your site offers, with a name, a short description and a list of inputs. For example, a hotel site could offer a tool called searchRooms that takes a city, a check-in date and a number of guests.

Today, agents use websites the hard way. They take screenshots, read the page code and guess which button does what. WebMCP gives them a menu instead. The agent reads the menu, picks the right tool and passes in the right values.

Google’s own short description of the idea is that by defining these tools, you tell agents how and where to interact with your site. I think that is the clearest way to put it.

What Google Announced on 10 February 2026

The Chrome team, in a post by André Cipriani Bandarra on the Chrome for Developers blog, said WebMCP is now available for early preview. Here is what that means in practice:

• It is a test build only. WebMCP runs in Chrome 146, which is in the Canary channel (Chrome’s nightly test version). You have to switch on a flag called “WebMCP for testing” to use it.
• It comes with two APIs. A declarative API for simple actions built from normal HTML forms, and an imperative API for more complex actions written in JavaScript.
• There is an early preview program. Developers can sign up to get documentation, demos and updates, and to send feedback that shapes the standard.
• It is a shared standard, not a Chrome-only trick. Engineers from Google and Microsoft are writing the spec together in the W3C Web Machine Learning Community Group.

The last point matters. A community group draft is not an official W3C standard yet. Names, methods and rules can still change before anything ships to everyday Chrome users.

How WebMCP Works: Tools Instead of Clicks

When an agent visits a page with WebMCP, the browser exposes the page’s tools to that agent. Each tool has three parts:

1. A name the agent uses to call it, like bookTable.
2. A description in plain language, written for the AI model to read.
3. An input list that says which values the tool needs and what type they are, using JSON Schema (a standard format for describing data).

The agent picks a tool, fills in the inputs and calls it. Your site runs the action and sends a result back. The person using the agent is still in the same browser tab, so they can see what happens.

That last detail is easy to miss. WebMCP works inside a page the user has open. It is not a back-door API that bots call from a server somewhere. In my view, that makes it closer to an accessibility feature than to a data feed.

The Declarative API: Turn a Form Into a Tool

The declarative API is the easy option. You add a few new attributes to a form you already have. The early preview uses three:

• toolname: the name of the tool.
• tooldescription: what the tool does, in a sentence.
• toolautosubmit (optional): lets the agent submit the form without the user clicking the button.

A simple site search form could look like this:

<form action="/search" toolname="site_search"
  tooldescription="Search this site's articles by keyword">
  <input type="text" name="q">
  <button type="submit">Search</button>
</form>

When an agent calls this tool, the browser fills in the form fields. Without toolautosubmit, the form stays on screen and the user clicks submit themselves. I like that default. It keeps a person in charge of anything that matters.

The preview also adds a few hooks for developers. A SubmitEvent.agentInvoked flag tells your code that an agent sent the form. There are also new events when a tool is activated or cancelled, and a way to send a result back to the agent instead of loading a new page.

The Imperative API: Tools Written in JavaScript

The imperative API is for actions that don’t fit in one form. Think of a multi-step checkout, a product filter or a dashboard report. Your developers register tools in JavaScript through a new browser object, navigator.modelContext.

A simplified example looks like this:

navigator.modelContext.registerTool({
  name: "searchProducts",
  description: "Search products by keyword and maximum price",
  inputSchema: {
    type: "object",
    properties: {
      query: { type: "string" },
      maxPrice: { type: "number" }
    },
    required: ["query"]
  },
  async execute(input) {
    const results = await findProducts(input.query, input.maxPrice);
    return { products: results };
  }
});

Here findProducts stands for your own site code. The point is that the tool reuses logic your site already has. Your developers are not building a second system just for agents.

WebMCP vs MCP: What Is the Difference?

MCP, the Model Context Protocol, is an open standard that Anthropic released in late 2024. It lets AI apps connect to outside tools and data through a separate server. Many companies now run MCP servers for their products.

WebMCP borrows the same idea of tools with names, descriptions and inputs. The difference is where the tools live:

For most small and medium sites, I think WebMCP will be the easier of the two. You already have the pages and forms. You don’t need to run a new server.

Why WebMCP Matters for SEO and Your Website

WebMCP does nothing for rankings in Google Search. It is not structured data, Googlebot does not use it, and Google has not said it will ever be a ranking signal. I want to be clear on that before anyone starts selling “WebMCP optimisation”.

So why should an SEO care? Because the way people reach websites is changing. AI agents now browse for users. OpenAI’s agent mode does it, and so do AI browsers. I covered what that looks like in my guide to ChatGPT agent browsing websites.

Those agents fail often. They misread buttons, get stuck on pop-ups and give up on long forms. When an agent gives up, the user often never reaches your conversion step. WebMCP is a way to make sure the agent can finish the task on your site, not on a competitor’s.

Here is how I see the link to SEO work:

• It is the next layer after structured data. Schema markup tells machines what a page is about. WebMCP tells them what a page can do.
• It moves the goal from clicks to completed tasks. Getting an agent to your site is only half the job. It also needs to book, buy or submit.
• Clear writing still wins. Tool descriptions are read by AI models. Vague descriptions will be picked less often or used wrongly, just like vague title tags.
• Chrome is where agents will live. Google is already putting Gemini into the browser, which I covered in what Gemini in Chrome means for SEO. A Chrome-built standard for agent actions fits that direction.

What WebMCP Is Not

There is a lot of excitement about this, so it helps to say what WebMCP does not do:

• It is not a ranking factor. Nothing Google has said links it to search results.
• It is not live for your visitors. Only people who turn on a test flag in Chrome Canary can use it.
• It does not let bots act without a browser. Tools run inside a page that a user has open.
• It is not a replacement for a good website. Your pages still need to work for people. Agents act on behalf of people.
• It is not final. The spec is a draft. I would not build anything critical on the current method names.

How to Try WebMCP in the Early Preview

If you or your developer want to test it, the steps are short. Do this on a test machine, not your main browser.

1. Install Chrome Canary. You need Chrome 146 or later, which in February 2026 means the Canary channel.
2. Turn on the flag. Go to chrome://flags, search for “WebMCP for testing”, enable it and relaunch the browser.
3. Join the early preview program. Sign up through the Chrome team’s preview program to get the full documentation and demos.
4. Pick one simple form. A site search, a contact form or a quote request is ideal. Add toolname and tooldescription on a staging copy of the page.
5. Check the tool registers. Google offers a Model Context Tool Inspector extension that lists the tools on a page and lets you run them by hand.
6. Test with an agent. Call the tool through an agent and check that the right fields are filled and the right result comes back.
7. Send feedback. The whole point of the preview is to shape the standard, so report anything confusing.

When I test something this early, I keep it off the live site. A staging copy is enough to learn how it behaves.

Which Sites Should Pay Attention First

Not every site needs to think about WebMCP this year. In my experience, these types of sites have the most to gain from agent-friendly actions:

• Travel and booking sites, where a search needs dates, places and numbers of people.
• Online shops, especially ones with filters, size choices and checkout steps. If agent shopping interests you, my article on ChatGPT Instant Checkout and the Agentic Commerce Protocol shows another route agents are taking.
• Service businesses with quote or booking forms, such as clinics, trades and agencies.
• Software and web apps, where users already do complex tasks inside the browser.
• Support portals, where a correctly filled ticket saves time on both sides.

A simple blog or brochure site has much less to do. Most of its value is in content, and agents can already read content without help.

Risks and Open Questions

WebMCP is promising, but it is early. These are the open questions I would watch:

• Security. Tool descriptions and results are read by AI models, so they could be used for prompt injection (hidden instructions that trick an AI). The spec authors list this as a known risk.
• Honest tools. Nothing forces a tool to do what its description says. Agents and browsers will need ways to deal with sites that lie.
• User control. Payments and bookings should not happen without the person agreeing. The declarative API’s default of waiting for the user to click submit is a good sign.
• Other browsers. Microsoft co-authors the spec, but no browser other than Chrome had a public preview when this was announced.
• Which agents will use it. Google has not said which agents will read WebMCP tools by default or when it will reach stable Chrome.
• Measurement. There is no standard way yet to report on tool calls in analytics. The agentInvoked flag at least lets developers tag those form submissions.

How I’d Prepare Without Writing Any New Code

You don’t need to add WebMCP today to get ready for it. Most of the work is making your site easy to use for any machine, which also helps people. This is what I would do first:

1. List your key actions. Write down the three to five things visitors come to do, such as search, book, get a quote or buy. These are your future tools.
2. Clean up your forms. Use real <form> elements, real buttons and a clear label on every field. Forms built from loose <div> tags are hard for both agents and screen readers.
3. Use clear field names. A field called checkin_date is easier to work with than field_7.
4. Remove blockers. Pop-ups, cookie walls that cover forms and surprise steps confuse agents. I usually see these on mobile first.
5. Draft tool descriptions now. Write one plain sentence for each key action. This is good practice for clear copy anyway.
6. Keep business data correct. Prices, stock, opening hours and policies must match across your site, because an agent will act on what it reads.

If your forms already follow good accessibility practice, adding WebMCP later should be a small job. If they don’t, fixing them pays off now, with or without agents.

Conclusion: What to Do About WebMCP Now

WebMCP is a Chrome early preview, announced on 10 February 2026, that lets websites offer clear tools to AI agents instead of leaving them to guess. It does not affect rankings, and normal Chrome users can’t use it yet.

My advice is simple. Don’t rush WebMCP onto your live site. Do ask your developer to try it on a staging page, and spend the time on clean forms and clear action descriptions. If you want to read the draft spec yourself, the WebMCP draft from the W3C Web Machine Learning Community Group is the primary source. Then review how agents already use your site with my ChatGPT agent guide as a starting point.