Google Tests WebMCP in Chrome to Replace Screen Scraping by AI Agents

The agent-ready web: Simplify user actions with WebMCP — Tara Agyemang, Google — AI Engineer

AI Engineer

Exposing structured in-browser tools via HTML and JavaScript eliminates layout-shift failures and token waste from visual scraping, turning live web pages into direct APIs for autonomous agents.

AI-assisted summary of The agent-ready web: Simplify user actions with WebMCP — Tara Agyemang, Google — original source. Check the original for full context.

Source published:

Key ideas

  • Google Chrome developer Tara Agyemang introduced WebMCP, a proposed web standard enabling sites to expose structured, typed client-side tools directly to in-browser AI agents instead of forcing them to rely on fragile DOM scraping and coordinate-based clicks. (2:30)
  • WebMCP offers two integration pathways: a declarative API that auto-generates JSON schemas from annotated HTML forms, and an imperative JavaScript API (`registerTool`) with an `execute` block that runs normal DOM code for complex multi-step workflows. (12:30)
  • Unlike standard MCP which connects AI agents to backend servers arbitrarily, WebMCP executes exclusively within active browser sessions against live client DOMs while keeping user interfaces visually synchronized. (10:00)
  • WebMCP is currently in an experimental early preview starting in Chrome 146, supported by an open-source evaluation CLI, six reference applications, and a Model Context Tool Inspector extension on the Chrome Web Store. (18:00)

Detailed notes

## Background Published by the AI Engineer channel on YouTube on June 11, 2026, this presentation features Tara Agyemang from the Google Chrome team introducing WebMCP. According to the page description, WebMCP is a proposed web standard designed to replace fragile pixel math, full DOM parsing, and layout-shift-prone agent clicks with structured, typed tool calls exposed directly to in-browser AI assistants.

## TL;DR Tara Agyemang outlines the operational friction autonomous AI agents face when navigating modern websites built exclusively for human visual interaction, such as layout shifts and token-heavy DOM parsing. She introduces WebMCP (Web Model Context Protocol), often called the 'USB-C of AI agent interactions,' which lets developers expose client-side capabilities via declarative HTML form annotations or an imperative JavaScript `registerTool` API. Across live demonstrations featuring a browser maze game and a three-step concert ticketing workflow, she illustrates how WebMCP keeps DOM state synchronized while dramatically cutting token consumption. Currently available as an early preview in Chrome 146 Canary with an inspector extension and evals CLI, WebMCP is positioned as a foundation for turning the web into a high-performance, deterministic API for agents while preserving intuitive human control.

## Atmosphere & style The presentation carries an energetic, pragmatic, and approachable tone typical of front-line developer advocacy, blending technical candor with lighthearted humor about vibe-coding and company credit cards. Agyemang guides the audience through live Chrome extension side-panel demos with unhurried confidence, letting the models navigate the UI in real time while candidly acknowledging early preview quirks and weekly API shifts. Watching the session feels like sitting in on an intimate, forward-looking engineering workshop where an emerging web primitive is demoed live before the broader standard solidifies.

## Bulletin - [02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) Google Chrome developer Tara Agyemang introduced WebMCP, a proposed web standard enabling sites to expose structured, typed client-side tools directly to in-browser AI agents instead of forcing them to rely on fragile DOM scraping and coordinate-based clicks. - [12:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=750s) WebMCP offers two integration pathways: a declarative API that auto-generates JSON schemas from annotated HTML forms, and an imperative JavaScript API (`registerTool`) with an `execute` block that runs normal DOM code for complex multi-step workflows. - [10:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=600s) Unlike standard MCP which connects AI agents to backend servers arbitrarily, WebMCP executes exclusively within active browser sessions against live client DOMs while keeping user interfaces visually synchronized. - [18:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1080s) WebMCP is currently in an experimental early preview starting in Chrome 146, supported by an open-source evaluation CLI, six reference applications, and a Model Context Tool Inspector extension on the Chrome Web Store.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=0s) Current AI web navigation is fragile because agents must parse the entire DOM, traverse accessibility trees, take viewport screenshots, and calculate exact pixel coordinates that fail when late-loading ads shift page layouts. - [02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) Sound web fundamentals like semantic HTML, ARIA attributes, fast load times, and minimal layout shift provide essential baseline accessibility for both human users and AI models before adding specialized protocols. - [02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) WebMCP acts as the 'USB-C of AI agent interactions' by giving models a menu of named, typed, and described tools instead of forcing them to guess website structure. - [04:55](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=295s) The Chrome DevRel team's Model Context Tool Inspector extension detects registered WebMCP tools on active pages and allows both conversational and manual execution via browser side panels. - [04:55](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=295s) Tools can be scoped dynamically based on application lifecycle, exposing new actions and removing irrelevant ones as page states transition. - [08:35](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=515s) Structured tool returns allow AI agents to enter autonomous execution loops, querying state and invoking actions iteratively to achieve multi-step objectives. - [08:35](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=515s) WebMCP fosters a hybrid browsing model where users retain direct visual control, delegate repetitive subtasks to browser agents, and resume manual navigation seamlessly. - [10:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=600s) While MCP operates on the server side, WebMCP brings the tools component of the protocol directly into open browser tabs to manipulate client-side sessions. - [12:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=750s) The declarative WebMCP API lets developers annotate existing HTML forms with attributes like tool-name and tool-description, allowing the browser to construct JSON schemas automatically. - [12:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=750s) Declarative form submissions include contextual metadata such as an agent-invoked boolean to help backend systems distinguish between automated agents and human users. - [12:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=750s) The imperative API (`registerTool`) requires clear natural-language descriptions so agent models understand precisely when and how to invoke each capability. - [15:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=900s) A live concert ticketing demonstration completed a search, page navigation, and ticket purchase in three deterministic tool calls using Gemini 3.1. - [15:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=900s) Tool implementations must maintain tight visual synchronization with the underlying DOM so users can clearly observe programmatic changes and manually confirm sensitive actions like financial payments. - [18:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1080s) Developers can test WebMCP in Chrome Canary version 146 or higher by enabling experimental browser flags and utilizing the project's GitHub evaluation tools. - [20:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1200s) WebMCP aims to transform websites into high-performance APIs for autonomous agents while preserving rich, intuitive experiences for human visitors.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=0s) The Fragility of Agent Interactions on the Human Web

Tara Agyemang, a Developer Relations Engineer on the Google Chrome team, opens her talk by surveying the room to see who has already experimented with WebMCP. Noting that only a handful of attendees raise their hands, she remarks that those few have a head start, but the rest of the audience will get a comprehensive look at the background, mechanics, and purpose of the protocol. Agyemang introduces herself and mentions that several of her colleagues from Google Chrome and Google DeepMind are in attendance and available at the DeepMind booth to discuss the intersection of web platforms and artificial intelligence.

Setting the stage for why WebMCP is needed, Agyemang reflects on how web development has evolved over the past few decades. Websites have traditionally been engineered exclusively for human eyes and human interactions. Today, however, an increasing number of autonomous AI agents are navigating and operating the web on behalf of human users. The fundamental friction is that these sites were never designed for non-human operators. As Agyemang summarizes: “The problem is... the agents are having to do so much work to do simple actions on the sites that we've built.”

To illustrate this inefficiency, she presents a concert ticketing website she coded, paired with a Gemini side panel in Chrome. If a user asks the agent to purchase two tickets to an Afrobeats festival with specific details, the agent must execute an exhausting, fragile multi-step inspection routine: 1. Parse the entire HTML DOM just to deduce what is happening on the page. 2. Traverse the accessibility tree to infer structural hierarchy and relationships. 3. Take a visual screenshot of the viewport to inspect visual elements omitted from the DOM or accessibility trees. 4. Calculate exact pixel coordinates—measuring how far down and across to target the click target. 5. Dispatch a synthetic click event to those coordinates.

This pipeline consumes immense token budgets and breaks easily. A late-loading banner advertisement at the top of the page can instantly shift the visual layout down, causing the agent’s calculated pixel click to miss its target completely.

```mermaid flowchart TD accTitle: Fragile Agent Pipeline vs Layout Shifts accDescr: Diagram showing how an AI agent inspects a page using DOM, accessibility tree, and screenshots, and fails when ads shift layout.

subgraph Inspection["Page Inspection & Coordinate Math"] A["Agent receives user prompt"] --> B["Parse entire HTML DOM"] B --> C["Inspect accessibility tree"] C --> D["Take viewport screenshot"] D --> E["Calculate pixel coordinates"] end

subgraph Execution["Interaction Failure"] E --> F["Attempt coordinate click"] G["Banner ad loads late & shifts layout"] -.->|"Moves target element"| F F --> H["Click misses target / Action fails"] end ```

---

[02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) Web Foundations and WebMCP: The USB-C of Agent Actions

Before diving into WebMCP as a technical specification, Agyemang emphasizes that standard web hygiene remains the critical first step for any developer aiming to make their site agent-friendly. Good web fundamentals naturally benefit AI models without requiring bespoke tooling. As Agyemang points out: “So making your site accessible for everyone makes it accessible to AI agents by default.” Developers who establish semantic HTML, maintain robust accessibility standards, optimize page performance, safeguard Core Web Vitals, and design clear user flows have already done half the work required for agent readiness.

Only once those foundations are established does WebMCP enter the architecture. The Web Model Context Protocol (WebMCP) is a proposed web standard that allows web developers to formally expose their site’s functional capabilities as structured, typed tools for AI agents. Rather than forcing models to guess intent by scraping markup, WebMCP equips the agent with an explicit operational contract. Agyemang highlights that industry observers often refer to the protocol as the "USB-C of AI agent interactions." As Agyemang puts it: “And that's because instead of any agent guessing what your website does, you're kind of giving the AI agent a menu of tools that it can use and actions that it can take.” By standardizing this interface, WebMCP dramatically improves execution reliability and reduces latency and token waste.

- **Prerequisites for Agent Readiness**: - Semantic HTML markup and native element usage. - Comprehensive accessibility tree coverage (ARIA attributes, roles, and labels). - Fast load performance and stable Core Web Vitals (minimizing Cumulative Layout Shift). - Intuitive, frictionless user experience flows. - **WebMCP Value Proposition**: - Replaces heuristic visual and DOM scraping with explicit, structured API tools. - Drastically cuts model token consumption during web navigation. - Immune to visual layout shifts caused by dynamic content or late-loading ads.

---

[04:55](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=295s) Live Demo: Navigating a Maze with the Model Context Tool Inspector

Agyemang transitions to a live demonstration using a browser-based maze escape game developed by the Chrome Developer Relations team. To interact with WebMCP tools on the page, she utilizes the Model Context Tool Inspector, a standard Chrome extension that operates within the browser’s side panel. The extension automatically detects and lists all WebMCP tools exposed by the active webpage. It also provides two execution interfaces at the bottom of the panel: a conversational prompt field for natural-language agent instructions, and an interface for triggering tools directly via raw parameter inputs.

```mermaid flowchart LR accTitle: Model Context Tool Inspector Architecture accDescr: Flow of user prompt through Gemini agent and Model Context Tool Inspector to execute tools on the webpage.

U["User Prompt in Side Panel"] --> G["Gemini 2.5 Model"] G -->|"Selects tool & arguments"| I["Tool Inspector Extension"] I -->|"Invokes registered tool"| P["Webpage WebMCP Registry"] P -->|"Executes logic & returns state"| G G -->|"Displays response"| U ```

Agyemang points out that this particular maze game cannot be navigated by clicking around the traditional user interface; it can only be explored through AI tooling. On the landing page, the inspector discovers only one tool available in scope: `start_maze_game`. Selecting Gemini 2.5 as her driving model, Agyemang issues the prompt: `"start a new maze game"`. The agent inspects the available schema, invokes `start_maze_game`, receives the initial state payload from the page, and loads the active maze environment.

Once the maze initializes, the tool inspector immediately reflects a dynamic change in scope: the initial `start_maze_game` tool disappears, replaced by a suite of contextual gameplay actions: - **`move`**: Accepts cardinal directions (north, south, east, west) to traverse open pathways. - **`look`**: Queries current tile coordinates and inspects which surrounding directions are unobstructed. - **Item interaction tools**: `pick_up`, `drop`, and `use` for manipulating items discovered throughout the labyrinth.

To test movement, Agyemang enters: `"Move down. Then right."` Gemini maps the conversational concepts of "down" and "right" to the formal cardinal parameters expected by the registered `move` tool, executes the calls sequentially against the page, and advances the player token. She demonstrates that the agent handles concise shorthand just as reliably; typing `"R, up, right"` causes the agent to interpret `"R"` as east, call the `move` tool accordingly, and execute the subsequent steps without hesitation.

---

[08:35](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=515s) Autonomous Tool Loops and the Hybrid User-Agent Workflow

Expanding beyond single-step commands, Agyemang demonstrates autonomous execution loops by issuing a high-level goal: `"complete the maze"`. Because all necessary affordances—movement, inspection, and item management—are exposed through explicit tools with structured returns, the agent can enter an iterative cycle: querying state, selecting actions, inspecting outcomes, and repeating until it satisfies the objective.

While the agent can navigate autonomously, Agyemang observes that naive prompts can produce suboptimal wandering, with the model occasionally backtracking to the entrance before resuming forward progress. However, providing domain hints immediately optimizes execution paths; telling the agent that `"the exit is in the bottom right corner"` allows it to calculate far more direct navigational sequences toward the goal.

Concluding the demonstration, Agyemang highlights that the Model Context Tool Inspector extension used during the talk was built by the Chrome DevRel team and is publicly available on the Chrome Web Store for developers to evaluate their own sites. More broadly, WebMCP establishes a flexible, hybrid human-agent paradigm for using the web. Users are not forced into an all-or-nothing dichotomy between manual clicking and full autonomous delegation. Instead, users can browse visually, delegate complex or tedious intermediate steps to an agent, and resume manual control at any point. As Agyemang explains: “Essentially, WebMCP kind of unlocks this new approach to using the web where your users don't have to spend a lot of time trying to figure out how to use more complicated sites.”

- **Agent Autonomous Looping**: - The model repeatedly invokes navigation and inventory tools based on runtime state returns until it reaches the exit. - Performance and path efficiency scale with prompt specificity (e.g., providing spatial hints like exit location). - **The Hybrid Browsing Model**: - **Human-driven**: Users navigate websites conventionally when they want direct visual control. - **Agent-delegated**: Users invoke browser agents via WebMCP tools to handle repetitive or intricate operational workflows. - **Interoperable**: Control can pass back and forth seamlessly without desynchronizing application state.

[10:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=600s) WebMCP vs. MCP and Client-Side Use Cases

To explain why this new standard has drawn significant attention, Tara pauses to clarify a foundational question: how WebMCP differs from the original Model Context Protocol (MCP). While MCP enables agents to connect to backend applications on the server side—requiring developers to host a server that agents query independently at any time—WebMCP is focused purely on client-side execution. Tara compares the relationship to how JavaScript was inspired by Java: “WoMCP is the implementation of the tools part of the MCP.” It gives developers a standard way to expose tools directly to in-browser AI agents, meaning the browser tab must actually be open and the execution environment lives entirely within the client session.

This client-centric model unlocks websites that are notoriously tedious for humans to navigate manually. Rather than forcing a user through rigid, multi-step flows like flight booking engines, intricate healthcare questionnaires, tax and financial forms, or hunting down hidden interface elements, an agent can perform the legwork directly in the active session. Tara shares a relatable e-commerce scenario: trying to find a specific black faux-leather clutch bag large enough to hold a mobile phone. Instead of manually clicking through dozens of faceted filter dropdowns and checkboxes, the user simply delegates the query to their AI agent, which executes the required browser interactions on their behalf.

- **MCP vs. WebMCP architecture**: MCP connects agents to server-side applications at arbitrary times; WebMCP runs exclusively inside an active browser session where all tools execute client-side against the live DOM. - **Form and filter automation**: Eliminates manual input entry and multi-checkbox filtering on high-friction sites such as travel aggregators, financial portals, and shopping catalogs.

---

[12:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=750s) Declarative vs. Imperative APIs

```mermaid flowchart TD accTitle: WebMCP Implementation Pathways accDescr: Flowchart contrasting the declarative HTML form approach against the imperative JavaScript registerTool method.

subgraph Declarative["Declarative Path (HTML Forms)"] A["Standard HTML Form"] --> B["Add Attributes:<br/>tool-name, tool-description"] B --> C["Browser generates<br/>JSON Schema automatically"] C --> D["Agent executes form submit<br/>(agent-invoked boolean set)"] end

subgraph Imperative["Imperative Path (JavaScript)"] E["Complex UI Flow"] --> F["Define Custom JSON Schema"] F --> G["Call registerTool() with<br/>name, description & schema"] G --> H["execute() Block runs DOM code<br/>& returns state to agent"] end ```

WebMCP introduces two distinct implementation paths depending on the complexity of the interaction: a declarative API and an imperative API. The declarative approach caters to standard HTML form elements. A developer simply annotates existing HTML forms with attributes such as `tool-name` and `tool-description`. The browser then inspects the input fields and automatically constructs the corresponding JSON schema that the agent reads to understand input parameters. The declarative spec also incorporates contextual metadata, such as an `agent-invoked` boolean attribute that lets backend systems discern whether a form was submitted by an automated agent or an actual human user.

For intricate, multi-step flows that go beyond basic forms, developers rely on the imperative API, which Tara notes is the variant most engineers will end up using. Through a client-side `registerTool` function, developers register custom tools by providing a manually authored JSON schema, a tool name, and a rich natural-language description. Tara emphasizes the necessity of writing explicit, high-quality descriptions: “You want to make sure you have really descriptive descriptions that enable the AI agent to know when it should be calling this tool.” The registration includes an `execute` block containing standard JavaScript. This function can run existing helper logic, validate and sanitize text inputs, manipulate DOM elements or create new nodes, and finally return structured execution results to the agent so it has the state information required for subsequent actions.

- **Declarative API**: Ideal for basic forms; browser infers the JSON schema from input elements and supports agent-detection attributes like `agent-invoked`. - **Imperative API**: Uses `registerTool()` with explicit schemas and descriptive metadata to handle complex UI workflows. - **The `execute` block**: Contains normal client-side JavaScript that validates parameters, modifies DOM nodes, and passes structured feedback back to the agent.

---

[15:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=900s) Live Demo: Three-Step Ticket Purchase Flow

Tara transitions to a live demonstration using a concert ticketing web app she describes as "vibe-coded." Running the agent on Gemini 3.1—which she finds handles tool calling significantly better—she instructs the assistant to buy two VIP tickets to the "Summer Vibes Festival," joking, “let's see, two VIP tickets because it's VIP only for me.” The agent immediately inspects the available tools on the home page, identifies `search_concerts`, and runs it with the festival name to retrieve the event's unique identifier.

Using that concert ID, the agent triggers a second tool, `open_concert_page`, navigating the active browser tab to the dedicated festival listing. Once on the new URL, the agent discovers page-specific tools and initiates a third call to `purchase_ticket`, passing `{ quantity: 2, section: "VIP" }`. The browser updates to display a confirmation message indicating the tickets were booked for £356, prompting Tara to joke, “Great, I'll put that on the Google's credit card.” Crucially, Tara highlights that every tool call visibly adjusted the underlying user interface—selecting the VIP tier button and picking the quantity in real time. She stresses that maintaining tight visual synchronization between tool execution and UI state is non-negotiable, and recommends that real applications pause before payment: “You'll probably want your user to manually do that step so they know that they're spending real money.”

- **Model selection**: Gemini 3.1 demonstrated the highest reliability when sequencing these multi-step tool calls. - **Three-step execution sequence**: 1. `search_concerts(name)` returns concert metadata and unique ID. 2. `open_concert_page(concertId)` transitions the client to the targeted event URL. 3. `purchase_ticket(quantity, section)` executes checkout on the dynamic page-level tool set. - **UI state synchronization**: Every programmatic action updates the visible DOM controls so users retain visual visibility into the agent's work.

---

[18:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1080s) Developer Setup, Tooling, and Early Preview Status

Tara gives a realistic assessment of the standard's current readiness, warning that WebMCP remains in an experimental early preview. The API has shifted significantly week over week as the Chrome team gathers community feedback, meaning code written today will likely evolve. For developers eager to experiment, WebMCP is supported in Chrome version 146 and newer. Tara strongly advises installing Chrome Canary rather than modifying flags on a daily driver: “I recommend using Chrome Canary just so you can keep things separate otherwise in the normal Chrome, you have to enable experimental flags.”

Once Canary is installed, developers must activate the dedicated WebMCP testing flag via the URL flags configuration page and install the Model Context Tool Inspector extension from the Chrome Web Store, which allows live debugging and inspection of registered tools. Tara directs developers to two primary resources: the official Google early preview blog post—which provides sign-ups, foundational documentation, implementation guidelines, and API references—and the project's GitHub repository. The repository contains the inspector source code, an evaluation CLI tool for benchmarking WebMCP on existing websites, and roughly six or seven interactive reference applications, including the maze demonstration.

- **Browser requirements**: Chrome version 146 or higher; Chrome Canary is recommended to isolate experimental flags. - **Required settings and tools**: Enable the WebMCP testing flag in the browser configuration and install the Model Context Tool Inspector extension for client-side tool debugging. - **Ecosystem resources**: Google early preview program blog post with documentation; GitHub repository featuring 6–7 demo implementations and an evals CLI tool for testing custom sites.

---

[20:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1200s) Transforming the Web into an Agent-Ready API

Tara closes by reiterating that the Chrome team needs real-world developer feedback during this early preview phase to uncover friction points, identify bugs, and refine the API before broader rollout. AI agents are fundamentally here to stay and are already actively navigating the web, but the industry does not need to rely indefinitely on brittle, expensive visual scraping: “Instead, we can use WebMCP tools to turn every website into a high-performance API for agents, and at the same time, build incredible user experiences for the users of our sites.” By equipping sites with explicit, typed tool declarations, developers can streamline automated workflows while keeping human users firmly in control of their browsing experiences.

- **Moving beyond fragile scraping**: WebMCP eliminates pixel-based computer vision math, DOM dumps, and layout-shift failures in favor of structured, deterministic execution. - **Dual benefit**: Transforms web interfaces into fast, typed endpoints for autonomous systems while preserving human usability and visual state awareness.

## Notable quotes > [20:00](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=1200s) we can use WebMCP tools to turn every website into a high-performance API for agents, and at the same time, build incredible user experiences for the users of our sites. — Tara Agyemang

> [02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) So making your site accessible for everyone makes it accessible to AI agents by default. — Tara Agyemang

> [02:30](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=150s) instead of any agent guessing what your website does, you're kind of giving the AI agent a menu of tools that it can use and actions that it can take. — Tara Agyemang

> [08:35](https://www.youtube.com/watch?v=ghJmWQCIHRM&t=515s) Essentially, WebMCP kind of unlocks this new approach to using the web where your users don't have to spend a lot of time trying to figure out how to use more complicated sites. — Tara Agyemang

## Mentioned Tara Agyemang, Google, Google Chrome, Google DeepMind, WebMCP, Model Context Protocol (MCP), Gemini, Gemini 2.5, Gemini 3.1, Model Context Tool Inspector, Chrome Canary, Chrome Web Store, HTML DOM, JSON Schema, Core Web Vitals, JavaScript

## Video description Buying two concert tickets costs an AI agent the entire DOM, the accessibility tree, a screenshot, pixel coordinate math, and then a click that might miss because an ad just loaded and shifted the layout. Tara Agyemang from the Google Chrome team introduces WebMCP, a proposed web standard that replaces that process with structured tools: instead of guessing what your site does, agents get a menu of named, typed, described actions they can call directly.

The talk covers two implementation paths. The declarative API adds a few HTML attributes to existing forms and the browser generates the JSON schema automatically. The imperative API lets you register custom tools in JavaScript for complex multi step flows, with an execute block that runs normal DOM code and returns state back to the agent. The live demo completes a concert ticket purchase in three tool calls: search by name, open the concert page, call purchase with quantity and section. Still experimental and in early preview on Chrome 146, but an eval CLI and inspector extension are available now for testing your own sites.

Speaker info: - https://x.com/tara_ojo - https://uk.linkedin.com/in/taraojo - https://github.com/taraojo

---

Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/ghJmWQCIHRM-the-agent-ready-web-simplify-user-actions-with-webmcp

Join our upcoming AI Engineer conferences (see https://ai.engineer landing page):

- AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney

---

[Source](https://www.youtube.com/watch?v=ghJmWQCIHRM)

Reading summary

According to Google Chrome Developer Relations Engineer Tara Agyemang, forcing AI agents to parse raw HTML and calculate pixel coordinates makes web automation fragile and computationally wasteful. The proposed Web Model Context Protocol (WebMCP) addresses this by enabling client-side web applications to expose structured, typed tools directly to in-browser models. Fragility of Visual and DOM Scraping (0:00) Autonomous agents interacting with human-centric websites typically parse the entire HTML DOM, traverse accessibility trees, take viewport screenshots, and calculate exact pixel coordinates to dispatch synthetic clicks. Agyemang highlights that this multi-step pipeline consumes substantial token budgets and fails easily when dynamic elements intervene, such as a late-loading banner advertisement shifting layout coordinates and causing clicks to miss. While robust web fundamentals—such as semantic markup, ARIA accessibility attributes, and stable Core Web Vitals—provide an essential foundation by making sites naturally more legible to AI, visual scraping heuristics remain inadequate. WebMCP addresses this gap by offering an explicit operational contract that exposes site capabilities as deterministic tools rather than visual guessing games. Client-Side Architecture and Hybrid Workflows (10:00) Unlike the standard Model Context Protocol (MCP), which connects agents to server-side applications, WebMCP operates entirely client-side within an active browser session. Comparing the naming relationship to how JavaScript relates to Java, Agyemang notes that WebMCP implements the tools component of MCP directly against the live DOM. This client-centric design enables a hybrid browsing workflow rather than complete delegation. Users can navigate visually, delegate high-friction multi-step tasks—such as airline booking forms, complex questionnaires, or faceted e-commerce filtering—to an in-browser agent, and resume manual control at any time without desynchronizing the application state. Declarative and Imperative Implementation Methods (12:30) WebMCP provides two integration paths depending on interaction complexity. The declarative approach allows developers to annotate standard HTML forms with attributes such as `tool-name` and `tool-description`. The browser then automatically constructs the corresponding JSON schema and provides execution metadata, including an `agent-invoked` boolean flag indicating whether submission came from an automated agent or a human. For complex interfaces, the imperative JavaScript API uses a `registerTool` function. Developers define a tool name, natural-language descriptions explaining when the model should invoke the action, and a manual JSON schema. The accompanying `execute` block runs client-side JavaScript to validate parameters, mutate DOM nodes, and return structured state to the agent while visibly updating the UI controls in real time. Demonstrations, Model Reliability, and Tooling Prerequisites (4:55) Agyemang demonstrated WebMCP using a maze navigation game running on Gemini 2.5, where available tools shifted dynamically based on state from game initialization (`start_maze_game`) to movement (`move`, `look`), showing that prompt specificity significantly improves agent pathfinding. A second demonstration on a ticketing app showed Gemini 3.1 chaining `search_concerts`, `open_concert_page`, and `purchase_ticket` to complete a checkout flow. Agyemang emphasized that tool execution must visibly synchronize with the user interface, and recommended that production applications require manual user confirmation before final financial transactions. WebMCP is currently in an experimental early preview supported in Chrome version 146 and newer. Developers testing the protocol must use Chrome Canary with the WebMCP testing flag enabled and debug tools via the Model Context Tool Inspector extension. WebMCP remains an experimental standard undergoing active API iteration as the Chrome team gathers developer feedback. While it aims to transform client-side websites into high-performance APIs for AI agents, widespread adoption will depend on broader browser standardization, developer willingness to author explicit tool schemas, and maintaining visual synchronization between automated actions and live UI state.

Source quotes

[20:00] Tara Agyemang: we can use WebMCP tools to turn every website into a high-performance API for agents, and at the same time, build incredible user experiences for the users of our sites. [2:30] Tara Agyemang: So making your site accessible for everyone makes it accessible to AI agents by default. [2:30] Tara Agyemang: instead of any agent guessing what your website does, you're kind of giving the AI agent a menu of tools that it can use and actions that it can take. [8:35] Tara Agyemang: Essentially, WebMCP kind of unlocks this new approach to using the web where your users don't have to spend a lot of time trying to figure out how to use more complicated sites.

Original transcript

[0:00] *music* Hello, hello? Hello, can you hear me okay? Okay, let's get started. So, We are going to be talking a little bit about WebMCP. Has anybody, just out of curiosity, has anybody already played around with WebMCP? Only a few people? Okay, great. Those few people, you have a bit of a head start. But for everyone else, we're going into a bit more of the background, how it works, what it does. So my name is Tara. I am part of the Google Chrome team. I'm a developer relations engineer. and I'm here with a few of my colleagues from Google Chrome alongside the DeepMind team too, so we'd be really interested in talking to you afterwards. around the DeepMind booth, if you have thoughts around web and AI and the intersection between the two, That is. where my focus is. these days. So let's get into it. THE let's say past few decades We have been building the web for human actions and human eyes and we've been trying to optimize for that but these days It's not just humans that are using the web. We have agents using the web on human behalf too. And we are seeing an increasing number of agents using the web. MS. The problem is... the agents are having to do so much work to do simple actions on the sites that we've built. And just to give you a bit of an example of this, this is a website that I've biocoded. And it's a concert website for selling tickets for concerts. And we have Gemini and Chrome panel on the side here. And let's say you've come along to this website? and you've typed this prompt, you want to buy two tickets to the Afrobeats festival, you've given it the details. The AI agent has to do so much work to make this happen. It'll probably look at the HTML because usually the agents will pass the entire DOM just to understand what's happening on your page. Then it will look into the accessibility tree just to understand the structure of your HTML page. Then maybe it will take a screenshot of the page, analyze all the different elements that it couldn't see in the HTML and the accessibility tree. And then maybe it will measure how far down, need to click how far across. where the exact element that it needs to click and then It will click that element. And as you can see, this process is quite long. It can be brittle and I don't even want to guess at how many tokens you probably just use trying to do this. It's probably a lot. And then after all that, maybe your ad has loaded at the top of the page, pushed all your content down, and your AI agent couldn't even click the right place in the end. Thank you. So there's so much to think about, but before we go into this proposed web standard, it's worth mentioning that You can do so much by improving web foundations first. So making your site accessible. for everyone. makes it accessible to AI agents by default. Thank you. So if you improve your semantic HTML, If you focus on robust accessibility standards, and if you improve your page performance, make it load really quickly, think about those core web vitals and then improve really good user experience flows through your site, you're already halfway to getting an agent ready website. And it's only once you have those in place that it makes sense to start thinking about WebMCP. So if you're not already aware, the Web Model Context Protocol is a proposed web standard, and that gives you the ability to define your site's capabilities. as structured tools for your AI agents to use. And so you might have heard references to this as the USB-C of AI agent interactions. And that's because instead of Any agent guessing? what your website does. You're kind of giving the AI agent a menu of tools that it can use and actions that it can take. Thank you. And so because of this, we're seeing that WebMCP significantly improves the performance and the reliability of agents navigating your website. So, Let's see it in action. Hopefully. Gemini treats me well today. So this is the maze escape game built by our team in Chrome DevRel and Just on the side here, we have a Chrome extension [5:00] I'll show you a link to that afterwards. But this is the model context tool inspector and so we're using this This is a standard chroma stitch. extension that lives in your side panel and it. list out all the tools that it finds on your website. So at the moment it can only see one tool and that's the start maze game tool. And then at the bottom down here, it gives you two options to interact with the page. So. You can interact via a prompt like a user would prompt normally by the AI agent, or you can call tools directly at the bottom, but we won't be looking at that one today. So this specific maze game, is actually more unique in that you actually can't browse it by clicking around the UI. You can only use this with the AI tooling. Thank you. So let's start a new maze game here. You can also choose your model on the side, so let's stick with the Gemini 2.5. So you'll see that at the bottom when you send a prompt it gives you all the information. So the new prompt is start a new maze game, And the AI agent, Gemini in our case, has called that tool Start Game. The tool itself has returned this information and then the AI has read that and given me this response. And so now we have our maze. And you'll notice that on this page, we have a bunch of new tools in the scope of this page, whereas the previous page only had that one tool. This page, we've got a bunch of tools to help us navigate the maze. So in this maze, you can move around with the north, south, east, west directions. You can look to see where you are in the maze and which directions are open. and then you can pick up items, drop items, use items as you navigate this maze. And Thank you. If I pop in some prompts, I can see that I can Move down. THEN MAYBE AFTER THAT. Then write. The AI agent should use my prompt match it to the specific tools, so in this case the Move tool, It's taken my direction of down and right. map that to the north-south-east direction and sent that off to the tool that we have. registered on this page and then it's moved it down and right. And so you can do And because it's an AI agent, it can understand a whole bunch of different things. So I could just say, right. up. Might be right again. Let's try that. Thank you. And so... The AI agent has seen that R stands for right, mapped that to the direction, and then called the move tool with those information. And because it's an AI agent, it can just keep repeating the same tool calls until it thinks that it's done what needs to be done. So I could even say complete the maize. Thank you. And then the AI agent should use all the tools available to just keep moving around the maze, to pick up items, to use the items when it needs to, because it has all the information in the tools available. This specific prompt was not the most efficient, so sometimes you'll see it'll go backwards all the way to the start and then go forwards again. But the more that you refine the prompt, the better the agent knows how to complete the maze in the most efficient way. For example, if you just say that... Exit is in the bottom right corner. it'll be more efficient in its instructions to get to that. that direction. So I won't-- I won't continue this because it can take quite a while to complete this maze. But if we go back, to the slides. here. So this is the model context tool inspector that I mentioned. So this is the web extension that our team in Chrome DevRel built. THE CURRENT CARD THAT IS is if you want to see where that is in the Chrome web store, but anyone can use that and grab it from the web store. Essentially, WebMCP kind of unlocks this new approach to using the web where your users don't have to spend a lot of time trying to figure out how to use more complicated sites. and they can figure out their own workflow. So they can choose to browse your website the normal way for a bit, then they can hand over control to their AI agent and the AI agent take steps on their behalf. and then your user can come in at any time to take control again and browse your site again. the way they normally would. And so that ability [10:00] to simplify user journeys. and make those user journeys FOR PEOPLE. easier has been a large part of the reason we've seen interest and excitement in this new standard. So I want to pause for a minute just to address the question that some people have, and that's what is the difference between WebMCP and MCP. but you can kind of see them as being complementary to each other. So whereas MCP enables AI agents to connect applications on the server side, and you'd need to set up your own server for the agent to access and then the agent can access the information anywhere at any time WebMCP, is different in that it's kind of inspired by MCP. I like to think of it as how JavaScript is inspired by Java and that's in short, WoMCP is the implementation of the tools part of the MCP. And so WebMCP allows engineers to provide tools to in-browser AI agents and it's very specific for the client side features. So you have to have your browser window open for WebMCP to work. And then you can use it to help your agent interact with the browser. So all of the tools live in the browser. But you can imagine this for quite a few different types of use cases. So imagine those websites that are really complicated I have a lot of steps that a user needs to take, maybe like booking a flight or filtering products on a normal shopping website. or filling in complicated medical forms or financial forms, or to trigger fixes that need to be hidden on a page, that are hidden on a page. Thank you. Or if you're like me, you're just on a normal shopping site. and you're trying to find the right Black. faux leather clutch bag that can fit your mobile phone in. And instead of going through all the little filters, You just want to ask your AI agent to do it for you. So these are a bunch of examples where any user can ask whatever AI agent they are using to complete these things on their behalf. So the user doesn't have to manually do this. and they don't have to fill in each input, they don't have to select each checkbox, and using WebMCP in these cases can mean that you can make those actions much easier for users. So let's look at the APIs. WebMCP proposes two approaches for implementation. So we've got the declarative API and the imperative API. Let's start with the declarative API. So if you have a normal HTML form, you can just add a few attributes to the HTML to get this to work. So we've got the tool name and tool description here, and then your browser will automatically generate a JSON schema. that the agent can use to read using the form fields as parameters for the tool. So here's an example of what the Jason Schema would look like. for this form HTML. And there are a whole bunch of other attributes that can be used. So there's like an agent invoked Boolean attribute so you can tell whether your form was filled in by an agent, or it was filled in by a human. And there's lots of more specific attributes that can be used for things like that too. But essentially, you want to use the declarative API when you have a standard form element. But when you have something more complicated, That's when we want to go back to the imperative. API. So this is where you can register and define your own custom tools for when you have more complex, maybe multi-step UI flows. So here is an example. So at the bottom we have this. REGISTER TOOL FUNCTION. And when you call registerTool with an object like this, Thank you. you need to manually create your own schema similar to the one that we had in the declarative API that was generated. You... name your tool and give it the description and you want to make sure you have really descriptive descriptions that enable the AI agent to know when it should be calling this tool. Thank you. And then you have the execute block, which is essentially where you call normal JavaScript, maybe you already have functions that you're using that you can call in here, maybe do a light wrapper. In this add to do item example, you can validate and trim text input, for example, and then you create the DOM elements or DOM nodes and add them to your page. And then you want to return some information to the AI agent so it knows what happened, if everything happened successfully. So it can use... [15:00] that information. for his next steps. So, So those are the two APIs. The imperative API is probably the one that's most used because people have more complex UI flows that he wants the agent to complete. But if we go back to my vibe-coded... demo. I have added A few. tools here So we have a few featured events in the demo and then all of the events available down here and then you can go in and purchase tickets for an end on an individual. content page. So So I have noticed that this works much better with Gemini 3.1, so I'm going to try that one. Thank you. If we wanted to buy tickets to one of these festivals, let's buy tickets. to this Summer Vibes Festival. Thank you. and of vibes. festival. let's see, two VIP tickets Thank you. because it's VIP only for me. Thank you. Thank you. Send that prompt. So the A-- the AI saw the tool search concerts. Okay. which it has called to find the specific concert via the concert name. and the tool RETURNED THE information about the concert including the ID for that concert then it is called the second tool open concert page. with the concept ID. and that has opened this Summerflies Festival page and then this new page has separate tools. this one here called purchase ticket I guess. called that in the third tool core here with a quantity 2 and the section name and then I've got a little notification saying, oh, you've bought your tickets. You spent £356 Great, I'll put that on the Google's credit card. Amen. But you can see as well, like in each step, it's updated the UI. to make sure the user can also see what's happening. So you always want to make sure that your UI is in sync with the tool calls that are happening. So we've got the VIP selected, we've got the quantity selected and then it real life it will go through to some checkout page. You'll probably want your user to manually do that step. so they know that they're spending real money. Thank you. Thank you. Let's head back. So if you're interested, in trying this out. It's probably worth just understanding the status of where we're at with WebMCP. So we're still in early preview stage. API is Very experimental. It will change, it has been changing over the past few weeks. And so the code that I've shown might be different next week. But that's because we want people to try it out. We want feedback. We want to know the best way to use this API. If you're interested in doing that, These are a few steps. to get set up Thank you. So WebMCP is enabled in Chrome version 146 upwards. I recommend using Chrome Canary just so you can-- keep things separate otherwise In the normal Chrome, you have to enable experimental flags. You might not want to do that on your normal. your normal browser. Once you have Chrome Canary, you'll need to enable the WebMCP testing flag with by putting this flag in your URL. and then install... the model context tool inspector from the Chrome website that I mentioned earlier, just so you can play around and debug and see what your tools are doing. Then, I. These are the two resources I recommend taking a look at. So this is our main blog post. that gives you information on the early preview program for WebMCP. So if you sign up there, you get access to all of our initial documentation. and you get extra information about the program, information on best practices, all the extra implementation details that you might want to use while you're testing it out, and all of the API information. That is the first one, and the second one is the GitHub repository of all the tools. So we've got the inspector tool here. We've got all the demos. So you can see the maze demo code is live there. to play around with. There's about six, seven different demos you can try out. And there's an evals CLI tool you can use to help you start testing your own sites [20:00] tools on your own sites today. So. I mentioned we're still in early preview. That's because and we're looking for feedback. SO TRY IT OUT, LET US KNOW what you think, if you have any friction points, if you find any bugs. We'd love to know that so we can keep iterating on this API. and eventually move on to the next stage and start getting WebMCP in front of more users. Thank you. But to wrap up, AI agents are already using the web. We don't have to settle for these token, heavy, brittle. screen scraping processes that we have today. Instead, we can use WebMCP tools to turn every website into a high-performance API for agents, AND AT THE SAME TIME, build incredible user experiences for the users of our science. So now that you have the tools and the context, please give it a go. and try making your agents try making your website's agent ready today. Thank you very much.