Google Launches WebMCP to Let AI Agents Directly Control Chrome Tabs
Chrome for Developers
Chrome is re-engineering web standards around browser-native tools because autonomous AI agents require explicit execution APIs and active session authentication that visual DOM scraping cannot deliver.
Chrome introduced WebMCP, an open specification entering an Origin Trial in Chrome 149 (targeted for June 2, 2026), enabling browser tabs to expose declarative HTML forms or imperative JavaScript tools directly to autonomous AI agents. (9:42)
Modern Web Guidance and Chrome DevTools for Agents launched to bridge the gap between fast browser release cycles and outdated LLM training data, providing evergreen skills packs alongside an MCP server for runtime browser telemetry and debugging. (18:32)
The web platform added 55 features to Baseline Widely Available over the past year and reached 52 Baseline Newly Available features, including View Transitions, the Navigation API, and cross-browser Core Web Vitals. (25:17)
Chrome 148 unlocked on-device multimodal Prompt APIs, declarative partial updates for out-of-order server-rendered HTML streaming, and dynamic streaming markup via methods like streamHTML. (31:07)
HTML-in-Canvas enables live, semantic DOM trees to render inside 2D and 3D canvas contexts with full text selection, accessibility trees, search, and translation intact. (37:37)
Detailed notes
## Background
Published by Chrome for Developers on YouTube on May 21, 2026, this Google I/O 2026 keynote session features Paul Kinlan presenting what is new in the web platform and Chrome. According to the video description, the presentation highlights upcoming browser capabilities designed to make the web more capable, reliable, and intelligent throughout 2026.
## TL;DR
Chrome Developer Relations lead Paul Kinlan presents Chrome's strategy across three pillars: enabling sites to participate in agentic experiences, equipping developers and models with modern baseline guidance, and introducing future-facing platform experiments. He introduces WebMCP, a protocol enabling web applications to expose structured declarative and imperative tools directly to AI agents from the browser tab, alongside agent-tailored tooling like Modern Web Guidance and DevTools for Agents. Kinlan also showcases major platform innovations, including on-device multimodal execution via the Prompt API, declarative partial HTML streaming, and HTML-in-Canvas, which allows accessible, interactive semantic DOM elements to render inside 2D and 3D graphics engines. Together, these updates establish a web ecosystem engineered both for expressive human interaction and deterministic AI agent automation.
## Atmosphere & style
The presentation is conversational, upbeat, and self-deprecating, blending nostalgic technical anecdotes about QBasic and Perl with live interactive demonstrations set inside a 3D recreation of Kinlan's childhood bedroom. Kinlan fosters an intimate, engaging keynote vibe, trading playful banter with the audience over his Scouse accent, his ongoing efforts to learn Welsh, and an audience tally tracking his 62 mentions of the word 'agent.' The overall experience feels both pragmatic and forward-looking, pairing unvarnished developer empathy about the rapid pace of browser releases with infectiously optimistic enthusiasm for the platform's future.
## Bulletin
- [09:42](https://www.youtube.com/watch?v=YuMdsHIXatY&t=582s) Chrome introduced WebMCP, an open specification entering an Origin Trial in Chrome 149 (targeted for June 2, 2026), enabling browser tabs to expose declarative HTML forms or imperative JavaScript tools directly to autonomous AI agents.
- [18:32](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1112s) Modern Web Guidance and Chrome DevTools for Agents launched to bridge the gap between fast browser release cycles and outdated LLM training data, providing evergreen skills packs alongside an MCP server for runtime browser telemetry and debugging.
- [25:17](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1517s) The web platform added 55 features to Baseline Widely Available over the past year and reached 52 Baseline Newly Available features, including View Transitions, the Navigation API, and cross-browser Core Web Vitals.
- [31:07](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1867s) Chrome 148 unlocked on-device multimodal Prompt APIs, declarative partial updates for out-of-order server-rendered HTML streaming, and dynamic streaming markup via methods like streamHTML.
- [37:37](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2257s) HTML-in-Canvas enables live, semantic DOM trees to render inside 2D and 3D canvas contexts with full text selection, accessibility trees, search, and translation intact.
## Key takeaways
- [03:28](https://www.youtube.com/watch?v=YuMdsHIXatY&t=208s) Chrome's engineering strategy centers on three pillars: enabling sites as first-class citizens in agentic workflows, equipping developer tools and LLMs with modern Baseline knowledge, and testing forward-looking platform experiments.
- [05:33](https://www.youtube.com/watch?v=YuMdsHIXatY&t=333s) The transition to an agentic web is moving substantially faster than the historical shift from desktop to mobile, shifting user navigation from manual clicking to delegating multi-step cross-site intents.
- [05:33](https://www.youtube.com/watch?v=YuMdsHIXatY&t=333s) Preparing websites for autonomous agents does not require a novel framework, but rather recommitting to core fundamentals: semantic HTML, accessible DOM structures, and baseline standards.
- [07:48](https://www.youtube.com/watch?v=YuMdsHIXatY&t=468s) Skills in Chrome enables end users to turn multi-turn browser conversations into reusable, shareable workflows that extract structured data across arbitrary web pages.
- [09:42](https://www.youtube.com/watch?v=YuMdsHIXatY&t=582s) WebMCP executes directly inside the open browser tab, allowing agent-invoked tools to inherit active cookies, local storage, and authentication state within the browser's native security boundary.
- [11:39](https://www.youtube.com/watch?v=YuMdsHIXatY&t=699s) Developers can implement WebMCP declaratively by annotating standard HTML form elements or imperatively via navigator.modelContext.registerTool.
- [13:49](https://www.youtube.com/watch?v=YuMdsHIXatY&t=829s) An Origin Trial for WebMCP kicks off in Chrome 149, following prototype validations with industry partners such as Expedia combining structured tools with fallback DOM actuation.
- [16:06](https://www.youtube.com/watch?v=YuMdsHIXatY&t=966s) Rapid browser release cycles conflict with AI models trained on stale web data, creating a need for curated skills packs that keep coding agents aligned with modern standards.
- [19:15](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1155s) Modern Web Guidance delivers evergreen platform skills across 100+ use cases, pairing with baseline-checker.chrome.dev to help teams target appropriate browser baselines using real Google Analytics traffic.
- [21:16](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1276s) Chrome DevTools for Agents exposes browser console logs, network activity, memory traces, and accessibility trees via an MCP server so agents can inspect and fix runtime issues directly.
- [23:02](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1382s) DevTools for Agents supports attaching to running Chrome instances, driving multiple browser windows concurrently, and inspecting Chrome extensions including service workers and side panels.
- [28:30](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1710s) Webstatus.dev launched Baseline Alerts, delivering automated updates via email, RSS, or webhooks whenever web capabilities transition between browser support tiers.
- [31:07](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1867s) Chrome 148 introduced on-device multimodal Prompt API capabilities with structured JSON output, with upcoming Gemma family integration enabling client-side autonomous function calling.
- [33:38](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2018s) Declarative partial updates and native dynamic streaming methods like streamHTML eliminate manual client-side JSON serialization by patching streamed HTML directly into the DOM.
- [37:37](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2257s) HTML-in-Canvas preserves native accessibility, translation, and DOM event handling within 3D graphics pipelines like Three.js and PlayCanvas, offering graceful fallback when unsupported.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=YuMdsHIXatY&t=0s) Opening Demo: HTML-in-Canvas and WebMCP
Paul Kinlan, head of the Chrome Developer Relations team, opens the session with a joke about his Scouse/Liverpudlian accent before diving straight into a live interactive demonstration showcasing two major upcoming web APIs: **WebMCP** and **HTML-in-Canvas**.
To demonstrate these capabilities, Kinlan loads a 3D virtual environment modeled after his childhood bedroom from 30 years ago, back when he first started programming. Inside this 3D environment, he highlights an embedded virtual browser running directly within a canvas surface using the new HTML-in-Canvas API. Unlike traditional canvas rendering, the embedded browser retains native web capabilities: users can interact with pages, highlight text, and access the underlying DOM directly. To illustrate this, Kinlan translates content into Welsh—a language he is currently learning as a resident of Wales—and performs an in-page text search for "WebGPU."
Switching to agentic workflows, Kinlan demonstrates WebMCP by exposing browser-side tools directly to AI agents. In the virtual room, he triggers an agent command via keyboard shortcut (`Command + A`) with natural language: "turn off the lights." The agent identifies the exposed tool and toggles the lights. He then demonstrates a multi-step intent flow by asking the agent to turn off the computer and reboot it—mimicking how he used to hide his late-night computing from his mother as a kid. The agent successfully executes the sequence, shutting down and restarting the virtual terminal within the canvas scene.
- Kinlan jokingly recalled starting as a Perl programmer 30 years ago, noting that only HTML existed at the time.
- Emphasized that HTML-in-Canvas provides full DOM access within 3D/canvas environments, opening up capabilities that were previously impossible in canvas-based web apps.
- Demonstrated agent tool exposure through WebMCP handling both single-shot tools and multi-step agentic sequences.
---
[03:28](https://www.youtube.com/watch?v=YuMdsHIXatY&t=208s) Development Evolution and Chrome's Three Strategic Pillars
Kinlan reflects on his programming origins, showing a screenshot of QBasic to illustrate early developer tooling. He shares an anecdote from his beginnings: he spent an entire week debugging a syntax error because he didn't realize American English omitted the "u" in `color`. He contrasts that era—before language servers, syntax highlighting, modern IDEs, and inline debugging—with the modern era. While today's tools still revolve around text interfaces, Kinlan argues that development workflows have made monumental leaps, particularly over the preceding six months.
Kinlan outlines the mission of the Chrome Developer Relations team: preparing developers for the next generation of web engineering. He breaks Chrome's strategy into three primary pillars:
```mermaid
flowchart TD
accTitle: Chrome's Three Strategic Pillars for Modern Web Development
accDescr: Three pillars showing agentic web integration, tooling support for web baseline, and forward-looking Chrome platform experiments.
subgraph P1["Pillar 1: Agentic Future"]
A["Enable sites to participate in agentic experiences as first-class citizens"]
end
subgraph P2["Pillar 2: Tooling & Baseline"]
B["Equip developer tools and models with modern Web Baseline knowledge"]
end
subgraph P3["Pillar 3: Future-Ready Web Platform"]
C["Introduce forward-looking experiments and collect developer feedback"]
end
```
Kinlan emphasizes the shift to natural language interfaces:
> “And this, to me, marks one of the most significant shifts in computing since the invention of the web.”
- Emphasized that developer roles and environments have transformed more rapidly in the last six months than during past platform transitions.
- Announced that upcoming Chrome platform features will be released iteratively as developer experiments to gather ecosystem feedback.
---
[05:33](https://www.youtube.com/watch?v=YuMdsHIXatY&t=333s) The Shift to an Agentic Web and Intent-Driven Navigation
Kinlan contrasts the current agentic transition with the historic mobile platform shift. Following the launch of the iPhone, it took the industry nearly a full decade to evolve from desktop-first to mobile-first development. In contrast, the transition toward an agentic web is moving significantly faster.
In this new paradigm, the web is transforming from a medium where users manually browse and click into one where users delegate high-level tasks to autonomous agents. While the current web can be navigated by agents, Kinlan notes that it is in a transitional phase comparable to early desktop websites rendered on the first iPhone: functional, but far from optimized.
> “So just like when the web worked well on iPhone, or it worked on iPhone but it wasn't optimized for mobile, today's web works for agent flows, but it's not yet optimized.”
Agents navigate pages by capturing screenshots or inspecting the Document Object Model (DOM). Kinlan points out that making sites agent-ready does not require an entirely new paradigm; rather, it demands a recommitment to core web best practices:
1. Writing semantic HTML
2. Enforcing accessible DOM structures (accessibility trees)
3. Adhering to modern baseline standards
User interaction models are also evolving from isolated, single-page actions into multi-step, cross-site journeys. Instead of manually searching for a hotel, checking nearby restaurant recommendations from colleagues, or searching for niche locations (Kinlan jokes about discovering kombucha bars for the first time while visiting North Wales), users now expect agents to formulate and execute complex multi-step plans across disparate services.
---
[07:48](https://www.youtube.com/watch?v=YuMdsHIXatY&t=468s) Gemini in Chrome, Skills, and Introducing WebMCP
Kinlan discusses how Chrome itself is evolving natively around AI. With the integration of **Gemini in Chrome**, users can multitask, chat, and analyze web content directly in the browser side panel without switching tabs. Gemini can summarize lengthy articles, generate interactive quizzes, or assist in product research (such as selecting a sleeping bag) because web pages structure and expose their functional intent.
Beyond basic chat assistance, Kinlan introduces **Skills in Chrome**, drawing a parallel between everyday spreadsheets and end-user programming:
> “But if you go one, little step further, just like how spreadsheets turned everyone into programmers, I think things like Skills in Chrome, where everyone can instruct the browser, has the same ability as well.”
Through Skills in Chrome, users can:
- Browse a curated library of pre-built, ready-to-run browser skills.
- Automatically extract specific structured data from unstructured web pages, such as technical hardware specifications or nutritional protein macros.
- Convert multi-turn exploratory chat workflows into reusable, remixable, shareable skills that run predictably across different web domains.
Kinlan concludes this segment by addressing developer ergonomics. While large language models can attempt to infer page intent by inspecting raw DOM trees, tracking click positions, or running visual models on screenshots, the process remains brittle, opaque, and non-deterministic. Web developers require explicit, structured control over how external AI tools and agents interact with their applications. Kinlan introduces **WebMCP** as Chrome's standardized protocol for explicitly declaring and exposing application tools and actions directly to AI agents.
[09:42](https://www.youtube.com/watch?v=YuMdsHIXatY&t=582s) The WebMCP Proposal: Bringing MCP Tools directly into the Browser Tab
User interfaces are heavily constrained by human requirements, including brand guidelines, visual mandates, and complex regulatory considerations. However, automated agents interacting with a website do not require the same visual clutter and presentation layers designed for human eyes. To bridge this gap, Chrome is introducing WebMCP, a proposed specification aimed at transforming regular HTML forms and JavaScript functions into structured tools that agents can easily understand and invoke. When Paul Kinlan polls the room with a playful check—“You all know WebMCP? Yeah. I know you know WebMCP”—he emphasizes that while the project draws heavily from the broader Model Context Protocol (MCP), it deliberately limits its scope strictly to the tools primitive.
```mermaid
flowchart TD
accTitle: WebMCP Architecture Flow
accDescr: Diagram comparing traditional MCP server setup with WebMCP browser tab integration and execution flow.
subgraph Traditional["Traditional MCP Setup"]
A["External MCP Server / CLI"] -->|"Complex integration"| B["Site Backend"]
end
subgraph WebMCP["WebMCP Browser Integration"]
C["Current Browser Tab"] -->|"Exposes tools directly"| D["Agent / Gemini"]
D -->|"Executes via"| E{"Tool Type"}
E -->|"Declarative"| F["HTML Form Attributes"]
E -->|"Imperative"| G["navigator.modelContext.registerTool"]
F & G -->|"Inherits Context"| H["User State (Cookies, Auth, LocalStorage)"]
end
```
Rather than burdening web developers with setting up an external MCP server or command-line interface and figuring out how to pipe that back into their web property, WebMCP allows developers to expose tools straight from the user's active browser tab. In a practical e-commerce scenario, instead of having an agent fumble around DOM elements looking for brown, size 10 shoes, a store exposes targeted tools such as `Search`, `Add to Cart`, and `Checkout`. The agent analyzes the user's intent, picks the matching tool, executes it, and fulfills the request directly. The defining architectural advantage is execution context: because the code runs inside the user's open tab, it naturally inherits all active authentication cookies, local storage state, and sign-in credentials within the browser’s strict security boundary—capabilities external MCP server architectures inherently lack.
---
[11:39](https://www.youtube.com/watch?v=YuMdsHIXatY&t=699s) Declarative vs. Imperative WebMCP Implementations
WebMCP is designed to build directly on familiar web development primitives rather than requiring an entirely separate stack. Developers can choose between a declarative approach leveraging standard HTML forms or an imperative JavaScript API, depending on their application architecture:
* **Declarative HTML Forms:** Developers augment standard forms with semantic agent attributes. Adding a tool description explains the high-level intent of the form, while individual input attributes define parameter descriptions (for instance, explicitly instructing an agent how to supply a star rating or text comments). Kinlan notes how natural this is: “You get the ability to explain to the agent through a normal form with HTML attributes how they should interact with it, which I think is incredible.”
* **Imperative JavaScript API (`navigator.modelContext.registerTool`):** For programmatic control, developers supply an object containing three core components:
* **Name:** The tool identifier the agent references.
* **Description:** A clear explanation of what the tool accomplishes.
* **Input Schema:** A structured schema defining the exact data shape and types accepted.
* **Execution Function:** The underlying JavaScript logic that triggers with the parsed arguments once the agent matches user intent to the tool.
Kinlan admits that while high-level site architecture adjustments might take thought, the core API remains straightforward: “It's relatively simple—sorry—to start to think about how to integrate into your experience at a technical level.”
---
[13:49](https://www.youtube.com/watch?v=YuMdsHIXatY&t=829s) Real-World Experimentation: The Expedia Prototype and Chrome 149 Origin Trial
To test how WebMCP behaves in practical workflows, the Chrome team collaborated with industry partners, including Expedia, on experimental implementations. In a demonstrated walkthrough, a user prompts Gemini with a complex travel intent: *"find a hotel close to Grandma on the 4th of July."* The model breaks the request down into a discrete task plan, and the user approves execution. From there, the browser coordinates with the site's exposed WebMCP tools:
```mermaid
flowchart LR
accTitle: Expedia WebMCP Execution Flow
accDescr: Step by step walkthrough of an agent navigating lodging choices using WebMCP and page actuation.
A["User Request:<br/>'Hotel close to Grandma'"] --> B["Gemini Plan Generation"]
B --> C["User Confirms Plan"]
C --> D["Search Lodging Tool"]
D --> E["Update Lodging Filters Tool"]
E --> F["DOM Actuation<br/>(Date Selection)"]
F --> G["Navigate to Property Tool"]
G --> H["User Confirmation / Checkout"]
```
During the flow, the agent calls dedicated functions like `Search Lodging` and `Update Lodging Filters`, but seamlessly combines them with direct page actuation whenever a specific tool (such as an explicit date picker tool) is missing. After updating parameters, the agent invokes `Navigate to Property`, successfully steering the user directly to the target lodging option where they can inspect and confirm checkout.
Kinlan stresses that WebMCP is an open, experimental specification being developed alongside standards bodies:
- An **Origin Trial** will begin in **Chrome 149**, targeted for availability around **June 2, 2026**.
- Developers can sign up through the provided Chrome Origin Trial URL to test capabilities and submit architecture feedback.
- As Kinlan summarizes: “Our goal here is once you're in the Origin Trial, we really want your feedback to shape out how this API should work.”
---
[16:06](https://www.youtube.com/watch?v=YuMdsHIXatY&t=966s) The Developer Paradigm Shift and the Browser Update Tension
Beyond altering how end users navigate websites, AI tooling is radically transforming software engineering workflows. Kinlan shares his own personal evolution as an engineering manager: whereas six months prior he could only code during sporadic free time, modern tools allow him to write software every single day. His daily routine involves sitting with an open microphone, verbally describing goals to an LLM, and conversing back and forth about edge cases and architectural choices before writing any implementation code.
This pattern is widespread across the industry. An analysis Kinlan conducted across GitHub revealed that millions of developers now submit millions of automated pull requests every single day via agentic coding tools. However, this velocity creates a severe technical tension with the web platform:
> “If you take one example of a browser, so Chrome, it updates once every four weeks. I think in a couple of months, it's going to update once every two weeks. But the models are trained on a version of the web from a year ago, in some cases.”
When an experienced engineer builds against cutting-edge APIs (such as HTML-in-Canvas), they must manually feed their model with spec explainers, fresh code samples, and unit tests to get accurate results. But typical product developers do not have the time to manually bridge this knowledge gap. Kinlan points out: “I really want us to get to a point where we're able to build for the web of today, not like the web that was.”
---
[18:32](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1112s) Modern Web Guidance: Evergreen Skills for Coding Agents
To solve the lag between rapid browser release cycles and outdated training data, the Chrome team announced Modern Web Guidance. Presented as a dedicated "skills pack" for coding agents, it acts as an evergreen, continuously validated knowledge repository that teaches AI agents the best and most current implementation practices for the modern web.
Key highlights of the toolkit include:
- **Universal Installation:** Easily installed across any skill-compatible IDE or terminal CLI using the universal command:
```bash
npx modern-web-guidance install
```
- **Validated Curated Knowledge:** Feeds up-to-date documentation, baseline features, and edge-case compatibility guidance directly into the agent's context window.
- **Core Domain Focus:** Ships with foundational packs covering web performance, identity, and modern security patterns, with further guidance packs actively expanding.
[19:15](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1155s) Modern Web Guidance and the Baseline Checker
Paul Kinlan outlines how the Chrome team is structuring guidance around specialized skills across more than 100 common use cases that web developers face daily, mapping each directly to its modern platform equivalent. A critical design goal for Modern Web Guidance is an innate awareness of Baseline. Even when a modern feature has not yet achieved Baseline Widely Available status, the guidance provides sensible fallbacks and progressive enhancements so developers can adopt new techniques without leaving users stranded on broken experiences.
To help teams determine precisely what platform capabilities their audience can handle, Kinlan announces an integration with Google Analytics accessible via `baseline-checker.chrome.dev`. By connecting real user data to site traffic, developers can calculate their specific Baseline target rather than guessing. Kinlan highlights that while large language models allow engineering teams to experiment at unprecedented scale, speed cannot come at the expense of quality or safety: “But I do want to make sure that we're able to build experiences that are high quality, safe, and then don't come at the expense of cross-browser compatibility.” He notes that Phil is slated to give the subsequent presentation—both in the room and on the livestream—to provide a comprehensive deep dive into Modern Web Guidance.
- **Use case breadth:** Covers over 100 common web developer use cases matched to modern platform APIs.
- **Progressive enhancement:** Built-in guidance provides fallback strategies for features not yet Baseline Widely Available.
- **Analytics tooling:** Launches `baseline-checker.chrome.dev`, integrating with Google Analytics to deduce target browser baselines from actual audience traffic.
- **Speaker handoff:** Phil presents the next session dedicated entirely to implementing Modern Web Guidance.
---
[21:16](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1276s) Chrome DevTools for Agents
Kinlan transitions to describing his day-to-day workflow with large language models, explaining that building with agents is not a matter of simply delegating tasks and walking away. Developers work with agents in tight feedback loops. While existing AI tools can generate code and run test suites, they traditionally suffer from a major blind spot: they have no internal understanding of what is physically rendered in the browser, how the document tree is laid out, or how the page actually executes at runtime. Deep runtime inspection has been a human superpower for years through tools like Chrome DevTools and Safari DevTools, and Chrome is now giving that exact capability to autonomous agents.
Chrome DevTools for Agents is packaged as a standard Model Context Protocol (MCP) server, allowing developers to install it directly into agentic environments. Through this MCP interface, agents gain direct access to console logs, network traffic, memory traces, and the browser's accessibility tree. With this runtime telemetry, agents can independently run Lighthouse audits, diagnose performance bottlenecks, capture heap snapshots, and debug memory leaks—not only diagnosing issues on sites like `developer.chrome.com`, but generating the code fixes automatically without requiring tedious human intervention.
```mermaid
flowchart LR
accTitle: DevTools for Agents runtime loop
accDescr: An AI Agent communicates through an MCP Server to Chrome DevTools, retrieving runtime data and issuing automated fixes.
subgraph AgentLoop["Agentic Development Loop"]
A["AI Agent"] -->|"Queries & Prompts"| B["DevTools for Agents<br>(MCP Server)"]
B -->|"Inspects Runtime"| C["Chrome Browser Instance"]
C -->|"Logs, Network, Memory, A11y Tree"| B
B -->|"Diagnostic Telemetry"| A
A -->|"Automated Fixes & Tests"| C
end
```
- **Runtime access:** Grants agents visibility into the accessibility tree, live console logs, network requests, and memory traces.
- **MCP architecture:** Shipped as an MCP server compatible with standard agent environments.
- **Automated remediation:** Enables agents to run diagnostic suites (such as Lighthouse audits) and write code adjustments directly against discovered issues.
---
[23:02](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1382s) Advanced Agent Capabilities: Skills, Multi-Instance, and Extension Debugging
Addressing the rapid pace of development, Kinlan admits he initially thought the first release would be complete: “Now, when we first shipped this, I was like, great, this is done. We don't need to update it anymore. Well, it turns out, the team's like, nah, we have to update it.” The team added specialized Skills to the DevTools for Agents project so agents can execute and reason through complex tasks, such as capturing and analyzing memory heap snapshots. For deployment across various environments, Chrome introduced both a token-efficient CLI tool and a dedicated TypeScript API for CI/CD pipelines.
The runtime connectivity also received major upgrades. Agents can attach directly to existing, running Chrome instances—enabling workflows where an agent picks up interactive debugging right where a human left off, or integrating with projects like OpenClaw. Furthermore, DevTools for Agents now supports multi-agent, multi-instance setups, allowing tools to connect concurrently to two, three, or four browser windows to evaluate multi-user and role-based interaction flows. Developers can select a specific request in the Chrome DevTools Network panel and prompt an agent to evaluate that exact item. Finally, the tool supports the automated installation and inspection of Chrome extensions, enabling automated testing across service workers, side panels, and popup windows. Kinlan stresses that combining Modern Web Guidance on the authoring side with DevTools for Agents on the inspection side establishes a comprehensive, tool-assisted development loop.
- **Developer interfaces:** Includes a CLI interface optimized for LLM token efficiency and a TypeScript API targeted at automated CI workflows.
- **Live session handoff:** Supports attaching to running Chrome instances so agents pick up state directly from live developer sessions.
- **Multi-agent & multi-instance:** Capable of controlling multiple browser instances simultaneously to test multi-role and collaborative applications.
- **Network panel integration:** Permits targeted agent queries directly from human selection inside the Chrome DevTools UI.
- **Extension automation:** Full automated install, execution, and debugging support for Chrome extension components (background service workers, side panels, popups).
---
[25:17](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1517s) Web Platform and Baseline Momentum (Newly and Widely Available)
Kinlan turns to the evolution of the underlying web platform, reiterating that modern developer tooling must pair with a robust, predictable browser foundation: “This is a really important component for us because baseline is the cross-browser--all the features that every browser supports, so it's what you as developers can really, really rely on.” Over the preceding year, 55 new features crossed into Baseline Widely Available status, guaranteeing dependable cross-browser support for APIs such as the `<search>` element, the Origin Private File System (OPFS), CSS Subgrid, `OffscreenCanvas`, and MathML, alongside dozens of others. Kinlan stresses that the momentum stems from every browser vendor coordinating to advance web capabilities simultaneously.
In addition to Widely Available features, Kinlan tracks features entering Baseline Newly Available—capabilities recently shipped across all major engines that developers can actively start planning around. While an initial tally as of April 22nd counted 44 features, a morning check ahead of the keynote showed that number reached 52. Among the most transformative additions are:
1. **View Transitions API:** Enables seamless, animated state and page transitions across single-page and multi-page layouts without heavy JavaScript animation dependencies, dramatically improving perceived responsiveness.
2. **Navigation API:** Provides a modern successor to the dated `window.history` API, consolidating all navigation routing, backward/forward traversal, and state handling into a single centralized event that integrates directly with View Transitions.
3. **Core Web Vitals Expansion:** Metrics including Largest Contentful Paint (LCP) and Interaction to Next Paint (INP) are now Baseline Newly Available, unlocking performance and responsiveness measurement across all major platforms, including iOS browsers.
| Baseline Status | Feature Count (Keynote) | Prominent Examples Cited |
|:--- |:--- |:--- |
| **Baseline Widely Available** | 55 features added over past year | `<search>` element, Origin Private File System (OPFS), CSS Subgrid, `OffscreenCanvas`, MathML |
| **Baseline Newly Available** | 52 features (updated morning of keynote; 44 as of April 22) | View Transitions API, Navigation API, Largest Contentful Paint (LCP), Interaction to Next Paint (INP) across engines |
[28:30](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1710s) Tracking the Evolving Web Platform: Baseline Alerts
Paul Kinlan emphasizes that developers can now understand feature support irrespective of the browser an end user happens to run. With 44 new features—technically 52 when counting all Baseline Newly Available capabilities—the pace of change can quickly become overwhelming. To help developers keep up without constant manual research, webstatus.dev has launched a feature called Baseline Alerts.
Baseline Alerts is designed to notify teams precisely when features land across browsers, as well as the exact moments they transition into either Baseline Newly Available or Baseline Widely Available status. Developers can consume these updates through familiar distribution channels, including email, RSS feeds, and webhooks. Kinlan explains that the ultimate purpose is straightforward: “And the goal is just to make it easier for you to understand how the platform is evolving so that you can just plan your business and your sites way more effectively into the future.”
- 44 (technically 52) features have reached Baseline Newly Available status.
- Baseline Alerts on webstatus.dev allows subscription via email, RSS feeds, or webhooks.
- Notifications trigger when features land in individual browsers, hit Newly Available, or reach Widely Available status.
[29:11](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1751s) Developer Feedback and Built-in On-Device Intelligence
Reflecting on his role, Kinlan notes that he loves tinkering on the cutting edge of Chrome development, but he values his daily interactions with working web developers just as much. In those conversations, developers consistently deliver two core requests. First, they ask browser vendors to help them ship more predictably: “Don't go breaking the web all the time.” Initiatives like Baseline and Modern Web Guidance are built specifically to satisfy that demand. Second, developers need to understand where the platform is headed over the next one to two years so they can plan roadmap investments accordingly.
Turning to Chrome's forward-looking work, Kinlan jokes that audience members might expect him to stop mentioning agents, only to immediately confess: “Actually, no, you will hear me say agents one more time. I told a little bit of a lie.” He splits the upcoming work into two categories: delivering powerful, on-device intelligence directly into user hands, and fundamentally improving end-user web experiences. The trajectory of Large Language Models (LLMs) has advanced rapidly from basic text completion to semantic data extraction, then to summarization, and currently into function calling for agentic workflows. Kinlan highlights that on-device browser AI should be universally accessible regardless of internet connectivity, completely private, and free of runtime LLM invocation costs.
```mermaid
flowchart LR
accTitle: Evolution of Browser-Integrated LLM Capabilities
accDescr: Diagram tracing the historical progression of LLM capabilities leading up to autonomous client-side agents.
A["Text Completion"] --> B["Semantic Data Extraction"]
B --> C["Summarization"]
C --> D["Function Calling & Agents"]
```
[31:07](https://www.youtube.com/watch?v=YuMdsHIXatY&t=1867s) The Prompt API: Multimodal Input, Structured Output, and Function Calling
The Prompt API landed in Chrome 148, bringing native multimodal analysis so models can inspect and understand visual assets like images directly in the browser. Because the capability is currently unique to Chrome, Kinlan urges developers to adopt it as a progressive enhancement rather than an absolute hard dependency. Major commercial partners—including Trip.com, Drupal, and Temu—have already experimented with the API and deployed it to production. A demonstration of Trip.com shows a clean flight-navigation assistant on the left-hand side of the page; users on non-supporting browsers simply receive the standard UI without degradation.
```mermaid
flowchart TD
accTitle: Client-Side Prompt API Architecture
accDescr: Flow diagram showing how web applications process multimodal input and produce structured JSON output locally in the browser.
subgraph Input ["User Input Layer"]
A["Text Prompts"]
B["Multimodal Inputs (Images)"]
end
subgraph Execution ["Chrome 148 On-Device Execution"]
C["Built-in Prompt API"]
D["Gemma Model Family"]
end
subgraph Output ["Application Integration"]
E["Structured JSON Output"]
F["Progressive UI & Flight Navigation"]
G["Native Function Calling & Agents"]
end
A --> C
B --> C
C --> D
D --> E
D --> G
E --> F
```
The Prompt API also supports structured output, allowing developers to constrain model responses to parseable formats like JSON instead of wrestling with brittle raw string parsing. Natural language support has expanded past English to include French, German, Japanese, and Spanish, with more languages slated for future releases (Kinlan playfully calls out Kenji in the audience to ask whether Welsh will be included soon, joking that he is actively learning Welsh himself). Looking forward, Chrome is integrating the Gemma family of open models into the Prompt API to unlock native function calling: “And when we introduce that Gemma family of models, it's going to enable us to do native function calling, which is going to enable you to build these autonomous client-side agents inside the web.” Kinlan urges developers to join the early preview program to shape API design and points attendees to Thomas Steiner's dedicated session, *Build New Features Using Built-in AI in Chrome*.
- Prompt API introduced in Chrome 148 with multimodal (image and text) support.
- Adopted in production by partners such as Trip.com, Drupal, and Temu.
- Structured JSON outputs eliminate complex string parsing when handling model responses.
- Language support includes English, French, German, Japanese, and Spanish.
- Upcoming integration with the Gemma model family brings native function calling for autonomous client-side agents.
[33:38](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2018s) Soft Navigations and Declarative Partial Updates
Switching to web rendering primitives, Kinlan emphasizes that recent platform capabilities allow developers to build experiences that were once technically impossible. Single-page applications (SPAs) will soon be able to measure Core Web Vitals accurately across route transitions via soft navigations landing in an upcoming Chrome version; telemetry already indicates that soft navigation tracking increases SPA Core Web Vitals pass rates. Kinlan then introduces what he considers a transformative leap for markup: “And I think it's one of the biggest changes to HTML in a decade.”
Kinlan presents a demo featuring an on-screen bedroom clock that updates every second despite running entirely without client-side JavaScript. This behavior is enabled by declarative partial updates, an implementation introduced in Chrome 148 that permits browsers to render HTML updates out of DOM order and out of network arrival order. Developers can stream down critical rendering paths immediately and stream secondary or heavy markup—such as complex site menus or slow user data lookups—later in the very same HTTP request, patching it into place without separate client fetches or JavaScript rendering cycles.
- Soft navigations coming to future Chrome releases to accurately record Core Web Vitals across SPA client transitions.
- Declarative partial updates (Chrome 148) allow out-of-order rendering of server-streamed HTML into the DOM.
- Eliminates secondary fetch requests and JavaScript overhead for patching slow or deferred UI components.
[35:49](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2149s) Dynamic Streaming Markup and UX Principles
Kinlan declares his ambition to “make HTML the new JSON,” supported by a newly introduced streaming API for dynamic markup. While framework patterns like the island architecture have popularized isolated client component updates, native web platform APIs now make comparable patterns trivial for vanilla JavaScript developers. Using newly introduced methods such as `streamHTML` and `streamHTMLUnsafe`, developers can stream the raw response body of a standard `fetch` call directly into the DOM tree, entirely skipping client-side JSON serialization and manual template generation.
Both the dynamic streaming markup methods and declarative partial updates have been available since Chrome 148. Kinlan underscores that Chrome's broader initiative across CSS and JavaScript goes beyond cosmetic features: the overarching objective is to make the platform scroll smoother, transition between views fluidly, and feel tactile and physically intuitive. To explore that design philosophy, he points developers to a session by Una Kravets and Bramus Van Damme detailing five fundamental user experience principles reshaping web application architecture.
- `streamHTML` and `streamHTMLUnsafe` pipe `fetch` response streams directly into the live DOM without intermediate JSON parsing.
- Dynamic markup streaming and declarative partial updates are available as of Chrome 148.
- Comprehensive UX principles for modern browser transitions and tactile physics are detailed in the talk by Una Kravets and Bramus Van Damme.
[37:37](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2257s) HTML-in-Canvas: Bringing Rich Semantic DOM into 2D and 3D Canvases
Paul Kinlan turns his attention to a technology that he believes will fundamentally transform web development: HTML-in-Canvas. Referring back to the opening presentation demo where a mock web browser operated smoothly inside an interactive 3D computer model, Kinlan explains that the underlying technology powering that experience is the ability to render real, standard DOM structures directly within a `<canvas>` element. Rather than forcing developers to rebuild UI logic from scratch in WebGL or WebGPU, HTML-in-Canvas allows 2D application frameworks like Qt, as well as 3D graphics engines, to inherit the web's mature semantic UI layer. Because the rendered content remains genuine DOM rather than static bitmaps, it stays searchable, interactable, accessible to assistive technologies, and fully compatible with native browser features such as automatic page translation.
To illustrate the API's flexibility, Kinlan showcases an `<input type="range">` slider transformed into an elaborate, non-traditional visual interface. Although he jokes that having every website adopt such extreme visuals would be completely over the top, he highlights that the underlying markup remains standard and semantically correct. Developers can implement expressive, custom design systems that are impossible with standard CSS today, while preserving complete graceful degradation: if a browser lacks support for the API, the page cleanly falls back to rendering the standard HTML input element as it normally would. Kinlan stresses that combining visual freedom with core web semantics creates experiences unique to the open web: “Personally, it's one of those reasons why I think people will keep coming back to the web, because we have these experiences that you just can't get anywhere else.”
```mermaid
flowchart TD
accTitle: HTML-in-Canvas Architecture
accDescr: Diagram illustrating how semantic DOM elements feed through HTML-in-Canvas into graphics engines while preserving browser capabilities.
subgraph DOM["Standard Semantic DOM"]
A["HTML Elements<br/>(Semantic inputs, forms, text)"]
end
subgraph Engine["Canvas Rendering Pipeline"]
B["HTML-in-Canvas API"]
C["Engines & Frameworks<br/>(Three.js, PlayCanvas, Qt)"]
D["Interactive 2D/3D Texture"]
end
subgraph Capabilities["Browser Native Services"]
E["Accessibility Tree"]
F["Full-Text Search & Translation"]
end
A --> B
B --> C
C --> D
B -.-> E
B -.-> F
```
- **Core Capability:** Enables standard HTML and DOM elements to be rendered directly inside a `<canvas>` surface.
- **Native Browser Integration:** Preserves in-canvas text selection, accessibility trees, keyboard focus, DOM event handling, native search, and Chrome translation.
- **Progressive Enhancement:** If the HTML-in-Canvas API is unavailable, the elements gracefully degrade to their default standard DOM presentation.
---
[39:33](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2373s) Integration with Three.js, Community Demos, and Ecosystem Momentum
Kinlan moves on to how straightforward it is for developers to integrate HTML-in-Canvas into modern 3D pipelines. Frameworks like Three.js and PlayCanvas already support the capability today, reducing implementation down to applying the DOM element as a material or texture on a 3D mesh. The graphics library and the browser coordinate behind the scenes to handle the complex rendering synchronization and event bubbling. At the conference, physical demo stations showcased practical use cases, including 3D automobile dashboards and interactive digital books that users can flip through and engage with while keeping full accessibility and text interaction intact.
The broader web ecosystem has rapidly embraced the technology. Kinlan points to experiments shared by educators like Wes Bos and viral projects across X, where developers have built wild demonstrations that rip apart or explode interactive web page layouts in real time. While Kinlan acknowledges these playful demos are largely visual spectacles, they underscore the API's sheer expressiveness. To help developers navigate and contribute to this growing movement, the Chrome team is assembling an "Awesome HTML-in-Canvas" showcase page to aggregate community projects, and Kinlan invites anyone creating experiments to submit their work. Kinlan states his belief in the technology's trajectory: “I just think this is a game-changing API, and I think it's going to change the way that we experience the web.”
- **Engine Support:** Works out of the box with Three.js and PlayCanvas by mapping DOM trees directly onto mesh materials and textures.
- **Practical 3D Experiences:** Powers use cases like interactive car dashboards, virtual terminals, and interactive 3D books.
- **Community Showcase:** Google is collecting experiments into an aggregated showcase to spotlight innovative community use cases.
---
[40:49](https://www.youtube.com/watch?v=YuMdsHIXatY&t=2449s) The Future of the Web Platform: Expressive UI, WebMCP, and Modern Web Guidance
Kinlan pauses to recap the presentation and playfully asks the audience if anyone kept track of how many times he uttered the word "agent." When an audience member promptly calls out "62," Kinlan responds with genuine surprise and laughter before reflecting on the overarching momentum of the web platform. He emphasizes that the evolution of the web is moving along two complementary tracks: front-facing richness for human users through expressive primitives like HTML-in-Canvas, and architectural evolution through protocols like WebMCP that enable web applications to become first-class participants in agentic AI platforms and automated workflows.
Recognizing the rapid pace of change and the difficulty developers face in keeping up with new APIs, Kinlan explains that helping engineers navigate this landscape is the primary mission of Developer Relations. Initiatives like Modern Web Guidance are designed to curate best practices and deliver concrete tooling so teams can build modern, resilient applications without getting overwhelmed by shifting standards. Kinlan concludes by articulating the DevRel team's focus: “We know it's hard to navigate the ecosystem and understand what's going on, and that's where things like Modern Web Guidance comes along, where we can give you the tools to help you build for the modern web effectively.”
- **Agent Count:** Kinlan logged approximately 62 mentions of the word "agent" across the keynote presentation.
- **Two-Pronged Web Platform Evolution:**
- *User-Facing:* Expressive UI primitives and rich interactive graphics (e.g., HTML-in-Canvas).
- *System-Facing:* Direct participation in agentic platforms and AI toolsets through WebMCP.
- **Modern Web Guidance:** Google's educational initiative providing curated architectural guidance and tools to help developers navigate modern web APIs.
## Notable quotes
> [05:33](https://www.youtube.com/watch?v=YuMdsHIXatY&t=333s) So just like when the web worked well on iPhone, or it worked on iPhone but it wasn't optimized for mobile, today's web works for agent flows, but it's not yet optimized. — Paul Kinlan
> [16:06](https://www.youtube.com/watch?v=YuMdsHIXatY&t=966s) I really want us to get to a point where we're able to build for the web of today, not like the web that was. — Paul Kinlan
## Mentioned
Paul Kinlan, Google I/O 2026, Chrome, Chrome for Developers, WebMCP, HTML-in-Canvas, Gemini in Chrome, Skills in Chrome, Expedia, Modern Web Guidance, Baseline, Baseline Checker, Chrome DevTools, Chrome DevTools for Agents, Model Context Protocol, webstatus.dev, Prompt API, Gemma, Trip.com, Drupal, Temu, Core Web Vitals, View Transitions API, Navigation API, Origin Private File System, CSS Subgrid, OffscreenCanvas, Three.js, PlayCanvas, Qt, Phil, Thomas Steiner, Una Kravets, Bramus Van Damme, Wes Bos
## Video description
Discover the cutting edge of web development and learn where Chrome is taking the browser in 2026. Explore new capabilities that make the web more capable, reliable, and intelligent.
Resources:
15 updates from Google I/O 2026: Blog Post → https://goo.gle/4dXodTO
WebMCP → https://goo.gle/4uqYauc
Modern Web Guidance → https://goo.gle/4dWeOf8
Chrome DevTools for agents → https://goo.gle/4fABEdz
HTML-in-Canvas → https://goo.gle/3RnDLYj
Prompt API → https://goo.gle/49b24ii
Baseline → https://goo.gle/3ReWwgz
Speakers: Paul Kinlan
Watch the Chrome sessions from Google I/O 2026 → https://goo.gle/Chrome-at-IO2026
Subscribe to Chrome for Developers → https://goo.gle/ChromeDevs
Paul Kinlan, head of Chrome Developer Relations, argues that computing is undergoing its most significant shift since the web's creation, requiring browsers to support autonomous AI agents while modernizing rendering and developer workflows.
Standardizing Agent Tool Access with WebMCP (9:42)
Kinlan contends that while autonomous agents can navigate current websites using screenshots and DOM inspection, the process remains brittle and non-deterministic. To resolve this, Chrome proposed WebMCP, an open specification adapting the Model Context Protocol strictly for browser tools. Instead of requiring an external server or command-line bridge, WebMCP enables developers to expose structured tools directly from an active browser tab. This design allows tool execution to automatically inherit active user state, session cookies, and local storage within the browser's security boundary.
Developers can register tools declaratively using semantic HTML form attributes or imperatively via JavaScript with `navigator.modelContext.registerTool`. In an experimental prototype developed with Expedia, an agent paired tools like search and filter updates with direct page actuation to complete multi-step hotel booking intents. Kinlan noted that WebMCP is scheduled for an Origin Trial in Chrome 149, targeted for availability around June 2, 2026, to collect developer feedback and collaborate with web standards bodies.
Bridging Agent Knowledge and Baseline Standards (18:32)
A critical technical tension in modern software development is the gap between browser release cycles and AI training data. While Chrome releases updates every four weeks—with plans to accelerate to every two weeks—LLMs are frequently trained on web documentation that is a year old or more. To keep coding agents aligned with modern standards, Chrome introduced Modern Web Guidance (`npx modern-web-guidance install`), an evergreen skills pack covering more than 100 common developer use cases, complete with fallback guidance for capabilities not yet widely supported across all browsers.
To help teams ground architectural decisions in empirical data, Google launched `baseline-checker.chrome.dev`, integrating with Google Analytics to calculate audience-specific baseline targets. Kinlan tracked significant platform momentum across browser engines, noting that 55 features achieved Baseline Widely Available status over the preceding year—including CSS Subgrid, MathML, and the Origin Private File System—while 52 features reached Baseline Newly Available status, such as the View Transitions API and Core Web Vitals metrics across iOS and desktop engines. Teams can monitor these transitions via Baseline Alerts on webstatus.dev through email, RSS, or webhooks.
Runtime Agent Telemetry and On-Device Intelligence (21:16)
To improve how automated coding assistants inspect applications, Chrome released DevTools for Agents as an MCP server. The integration provides agents with direct runtime visibility into console logs, network traffic, memory traces, and the DOM accessibility tree. This allows models to independently execute Lighthouse audits, diagnose memory leaks from heap snapshots, and generate code fixes. The toolkit supports CLI and TypeScript interfaces, multi-instance browser testing, extension debugging, and attaching directly to active developer sessions.
At the browser platform level, Chrome 148 introduced the Prompt API for on-device, local model execution. Operating without invocation costs or internet dependency, the API supports multimodal image and text inputs as well as structured JSON outputs. Commercial partners including Trip.com, Temu, and Drupal have adopted it in production as a progressive enhancement. Kinlan projected that future integration with the Gemma open model family will introduce native function calling directly to client-side web applications.
Dynamic Markup Streaming and HTML-in-Canvas (37:37)
Chrome is also updating core markup and rendering primitives to reduce client-side JavaScript overhead. Chrome 148 introduced declarative partial updates, allowing the browser to parse and render server-streamed HTML out of DOM order and network arrival order. Complementing this, dynamic streaming methods such as `streamHTML` and `streamHTMLUnsafe` pipe raw `fetch` response streams straight into the live DOM without intermediate JSON serialization or template generation.
For visual rendering, Kinlan highlighted HTML-in-Canvas, an API that renders interactive, semantic DOM nodes directly inside 2D and 3D `<canvas>` surfaces. Unlike static bitmap drawing, content rendered via HTML-in-Canvas remains selectable, accessible to screen readers, searchable, and compatible with native browser features like text translation. Frameworks such as Three.js and PlayCanvas support mapping these interactive DOM nodes directly onto 3D mesh textures, while unsupported browsers gracefully fall back to standard HTML presentation.
Kinlan positioned Chrome's direction as a dual evolution: delivering expressive user-facing graphics through primitives like HTML-in-Canvas while formalizing protocols like WebMCP to turn web pages into first-class agent tools. However, realizing this vision depends on cross-browser standardization, ecosystem feedback during the Chrome 149 Origin Trial, and developer discipline in maintaining accessible, semantic markup.
Source quotes
[5:33] Paul Kinlan: So just like when the web worked well on iPhone, or it worked on iPhone but it wasn't optimized for mobile, today's web works for agent flows, but it's not yet optimized.
[16:06] Paul Kinlan: I really want us to get to a point where we're able to build for the web of today, not like the web that was.
Original transcript
[0:00] [MUSIC PLAYING]
[0:05] PAUL KINLAN: Hello,
hello, everyone.
[0:06] How are you doing?
[0:07] We all good?
[0:08] Brilliant.
[0:09] So, at the start, did you
hear the Scouse accent
[0:12] or the Liverpudlian
accent in the keynote when
[0:14] they were doing-- yeah?
[0:15] 45 minutes of that now.
[0:17] It's going to be brilliant.
[0:18] Anyway, I'm Paul.
[0:19] I lead the Chrome
Developer Relations team.
[0:21] It's great to see everyone here.
[0:23] I'm thrilled to be back.
[0:24] I was here a year ago, talking
about what's new inside Chrome.
[0:26] But before we
start, I'm actually
[0:28] going to show you a
new demo that we've
[0:30] got that highlights
two of the APIs
[0:32] that we're really excited about,
WebMCP and HTML-in-Canvas.
[0:36] So can we just switch
to the demo, please?
[0:39] So this is my childhood
bedroom 30 years ago
[0:42] when I was starting to
learn how to program.
[0:45] I had all these books.
[0:46] Actually, this is a lie.
[0:47] I didn't actually
have these books
[0:48] because only HTML was the
thing that was actually
[0:51] around at the time.
[0:52] I was a Perl programmer when I
was actually starting things.
[0:55] Anyway--
[0:56] [AUDIENCE CHEERS]
[0:57] Brilliant.
[0:57] Hello.
[0:57] [LAUGHS] So anyway, but I did
have this browser, this thing
[1:02] that I could browse the
web and find new things.
[1:04] I could maybe play some games.
[1:07] Now this is the
HTML-in-Canvas bit.
[1:09] We've got a 3D--
[1:10] I'm terrible at
games at the moment.
[1:12] I could then browse
the web, select text,
[1:15] and do all these really
fancy things around the web.
[1:18] I found a lot of new friends
when I was actually browsing
[1:20] and on the internet at
the very start of things.
[1:23] And then I also had
this slide deck.
[1:25] I wanted to be a
web developer, and I
[1:27] wanted to be a developer
advocate, even though the role
[1:30] didn't exist at the time.
[1:31] Anyway, the thing I
want to show you here
[1:34] actually is I
developed these slides.
[1:36] I'm not going to present these.
[1:37] These aren't my actual slides.
[1:38] You're lucky today.
[1:40] But the thing I like about
HTML-in-Canvas is the fact that
[1:42] we have these very 3D-related
experiences like this.
[1:46] This is a full 3D experience,
but we have the browser
[1:49] and the content
just embedded in.
[1:50] And so we can do things
like translate to Welsh.
[1:54] Does anyone know any Welsh?
[1:56] No?
[1:56] I do a little bit.
[1:57] I live in Wales, and I'm
learning at the moment.
[1:59] And then we can even do things
like find WebGPU, things
[2:05] that we've never been able to do
inside a Canvas-based experience
[2:08] before.
[2:08] We have access to the DOM.
[2:10] I think this is just incredible.
[2:12] Anyway, so you jump
forwards 30 years,
[2:15] and, thankfully, I'm no
longer living with my parents.
[2:19] We have these agents roaming
the web and doing things.
[2:22] And in Chrome, one of the
things that we really want to do
[2:24] is make sure that the
web can participate
[2:27] in these agentic experiences.
[2:28] So I'm just going
to show WebMCP.
[2:31] I don't know whether you can
see that properly at the moment,
[2:33] but this experience here has
exposed a number of tools
[2:37] to, essentially,
agents at this point.
[2:40] And so what I can do is
I can do a single one.
[2:42] I can just say, Command
A, turn off the lights.
[2:48] It might ask me which lights,
but we'll see which one it does.
[2:51] So there we go,
turned off the lights.
[2:52] That's really cool.
[2:53] But when I was a kid, my
mom hated me on the computer
[2:55] in the evening.
[2:56] And so what I'd do is I'd
maybe turn off the computer
[3:00] and then start it again
once she had gone.
[3:06] So let's see if it works.
[3:07] And so there we
are, the computer.
[3:09] I can maybe zoom in,
and there we are.
[3:11] It's rebooted.
[3:12] And so we've had
this multi-step flow
[3:14] of turning the machine off
and turning it back on.
[3:17] But anyway, this is
just a simple demo.
[3:18] We can just go back to
the slides, if possible.
[3:20] I just wanted to show you
some of the things that
[3:22] were kind of possible with
HTML-in-Canvas and also WebMCP.
[3:26] I'm very excited about them.
[3:28] But this is the early days.
[3:29] When I started my
development journey,
[3:31] this is what my
environment looked like.
[3:33] This is Q-- any QBasic people?
[3:35] AUDIENCE: Yeah.
[3:36] PAUL KINLAN: Brilliant.
[3:37] If you're not old
enough to remember,
[3:38] this was before
modern IDEs, before we
[3:40] had language servers
and syntax highlighting
[3:43] like inline debugging.
[3:44] We just had these experiences.
[3:46] And there's a fun fact.
[3:47] I actually nearly
quit programming
[3:49] before I even started
because I didn't realize
[3:51] American English was a thing and
that you spelt color incorrectly
[3:55] without a U. But anyway, I
learned what to do in the end.
[3:58] It literally took me a week
of debugging to work out
[4:00] what a syntax error was.
[4:02] But I got over it,
at least, anyway.
[4:03] You jump forwards 30 years, and
now, my development environment
[4:06] is pretty damn similar.
[4:09] It's a text-based experience.
[4:11] But the thing here
is the actual strides
[4:13] that we've made in development
environments and development
[4:16] processes, we've just taken
massive leaps and especially
[4:19] within the last six months.
[4:22] So our primary goal in
Chrome and why I do what I do
[4:25] is to get everyone ready for
this next generation of web
[4:28] development.
[4:29] And the way I look
at it, at least,
[4:31] anyway, there's three
different components.
[4:33] One, we want to make sure that
your sites can participate
[4:36] in this agentic future, and the
web is a first-class experience.
[4:40] The second is that
we want to make sure
[4:42] that your tools can also
understand the modern web
[4:45] capabilities and how to build
for a modern web baseline,
[4:49] even if the models and
the tools that you use
[4:51] don't have that
knowledge built in.
[4:54] And the third part
is we also want
[4:55] to get you ready for
the years ahead as well.
[4:57] And so we are going to talk
about some of the things
[5:00] that Chrome is introducing as
experiments, in a lot of cases,
[5:03] where we would like
a lot more feedback.
[5:05] But I think it's
kind of nice to see
[5:07] where the platform is going so
that you can plan ahead as well.
[5:11] Now, you're going to hear
"agents" quite a lot.
[5:14] I know one person is counting
how many times-- how many
[5:17] are we at?
[5:19] Two agents.
[5:20] Three.
[5:21] Brilliant.
[5:21] Anyway, so we live
in a world where
[5:23] people can start to
get things done just
[5:25] by using their voice,
their natural language.
[5:28] And this, to me, marks one of
the most significant shifts
[5:30] in computing since the
invention of the web.
[5:33] Now, with the web, most
of the platform shifts
[5:36] actually come quite slowly.
[5:38] So since the invention
of the iPhone,
[5:40] it took us nearly
a decade to get
[5:42] from building
desktop-first experiences
[5:44] to mobile-first experiences.
[5:47] And we had this technology
to turn the browser
[5:49] into a mobile-based experience,
but the industry had to move,
[5:52] and it moved very, very slowly.
[5:55] And it took a huge
amount of effort
[5:56] for developers to redesign
their experiences.
[6:00] But when I look at where we are
today, over the last six months,
[6:03] we've seen a massive, enormous
shift in our role as developers.
[6:07] And I think it's going
to happen at a pace that
[6:09] is much faster than
the mobile transition.
[6:13] The web is transforming
from a medium
[6:15] where users browse and then
take action to one where it also
[6:19] has agents to let people
delegate their work for them
[6:23] to be able to
complete their tasks.
[6:25] So just like when the web
worked well on iPhone,
[6:29] or it worked on iPhone but it
wasn't optimized for mobile,
[6:32] today's web works
for agent flows,
[6:35] but it's not yet optimized.
[6:37] But the great thing
is many agents
[6:39] can just analyze the site,
either by looking at screenshots
[6:42] or understanding the DOM.
[6:44] And one of the things that we
like about this is it really
[6:47] just requires us to
recommit to semantic HTML,
[6:51] ensuring accessibility,
and just recommitting
[6:53] to the basic principles of
modern web development, things
[6:56] that, arguably, we
should already all
[6:58] be doing as developers.
[7:00] But user's intent
has transformed.
[7:02] It's not single interactions.
[7:04] It's actions across
multiple phases of a site,
[7:06] maybe across sites as well.
[7:08] People want to find their
hotel for the upcoming tech
[7:11] conference, maybe integrate
it with their colleagues'
[7:15] restaurants.
[7:16] I was told about this.
[7:18] People like to
find kombucha bars.
[7:20] I literally learned what
kombucha was this week.
[7:22] I'm still not quite sure.
[7:24] Anyway, North Wales,
we don't do kombucha.
[7:26] Anyway, so the
bit here is agents
[7:28] are able to create these plans
that are way more complex,
[7:31] that are way more powerful than
we've thought about before.
[7:34] But it really requires an
integrated approach, both
[7:37] in the browser
sense, like how we're
[7:39] going to reason about
changing the browser,
[7:42] but then how do we help
you get your sites evolved
[7:45] to get ready for these
multi-step agentic approaches.
[7:48] So, obviously, the
browser is evolving.
[7:50] Earlier this year, we
introduced Gemini in Chrome,
[7:52] and it enables users
to chat and multitask
[7:55] without switching tabs.
[7:56] We've created this
browser assistant
[7:58] that can navigate sites,
summarize content.
[8:01] It can create quizzes, books,
help you find the right sleeping
[8:05] bag and those types of things.
[8:06] But it can do this
because web pages describe
[8:10] the function of what is on
the site and the function
[8:13] of the site, and so our
tools can understand.
[8:15] And this gets back to the
point is if we can actually
[8:18] say to the tools
that we're using,
[8:21] this is a well-designed
site, this is the structure,
[8:24] we can help the agents and the
tools achieve the user's goals.
[8:28] But if you go one,
little step further,
[8:31] just like how spreadsheets
turned everyone
[8:33] into programmers, I
think things like Skills
[8:36] in Chrome, where everyone
can instruct the browser,
[8:39] has the same ability as well.
[8:41] So with Skills in Chrome,
you can browse a library
[8:45] of ready-made skills already.
[8:47] You can get it to pull
out product specs.
[8:50] I'm told protein
macros are a thing.
[8:51] I actually don't know what
protein macros are as well,
[8:54] but you can extract
them from the pages.
[8:56] You can summarize long
documents to find what you need.
[8:59] But then you can
take those chats
[9:01] and then turn them into,
essentially, skills which
[9:05] are repeatable, remixable.
[9:07] And then you can run them across
a number of different websites.
[9:10] And I think this is a new
level of experience where we're
[9:12] going to enable people to
be more like a developer,
[9:15] just at a different
level of abstraction.
[9:18] But the good thing
is, and this is
[9:20] where I get on to the very
developercentric things, is LLMs
[9:23] can infer the intent of a
page by scraping the images,
[9:28] scraping the DOM,
getting the clicks.
[9:30] But behind the scenes, it's
a little bit hard and opaque.
[9:33] And as developers, we really
do like a lot more control.
[9:37] We like to be able to guide
our tools around our sites.
[9:39] And this is where
WebMCP comes in.
[9:42] Now, obviously,
broadly, before WebMCP,
[9:45] there's a lot of
difficulties that emerge.
[9:47] Our UIs that we
build often reflect
[9:49] many different
human constraints--
[9:51] brand guidelines, UI
mandates, regulation.
[9:55] In a lot of cases,
our tools don't
[9:57] need to deal with the
same kind of experiences
[9:59] that people who will
browse your site do.
[10:02] And I do think that this
is where WebMCP can help.
[10:04] Now, WebMCP is a proposed
specification at the moment.
[10:08] And the goal is to transform
HTML forms and JavaScript
[10:11] functions into tools that
your agents can use and then
[10:15] make it a lot easier
for you to participate
[10:17] in this agentic ecosystem.
[10:20] Now, WebMCP-- actually,
I have a question.
[10:23] You all know WebMCP?
[10:24] Yeah.
[10:25] I know you know WebMCP.
[10:27] And so WebMCP, our goal
here is to integrate
[10:30] many of the learnings with
the Model Context Protocol,
[10:33] but, however,
we're only focusing
[10:34] on the tools part of MCP.
[10:37] And instead of having to
expose an MCP server or a CLI
[10:41] and then trying to work out
how to get that to integrate
[10:43] with your website, you're just
exposing your current browser
[10:46] tab, and then that is able
to share a list of tools
[10:49] that the agent can then
interact with on your site.
[10:52] And so in the demo
that I showed earlier,
[10:54] I exposed the light switches,
the actual machine, the browser
[10:57] so you can change pages.
[10:59] They were all the types of tools
that I exposed to the agent
[11:02] that we have.
[11:04] In a real-world
example, though--
[11:05] that was a fun demo--
[11:07] imagine you're running a
store, and the user wants
[11:10] to buy some shoes, size 10
shoes that are brown, maybe,
[11:13] or whatever.
[11:15] In this case, with WebMCP, you
would expose a number of tools
[11:18] like Search, Add to
Cart, maybe Checkout.
[11:22] It depends on where you want the
user to actually interact with.
[11:25] And you would expose these via
either a form or JavaScript,
[11:28] at this point.
[11:29] And then, simply,
the agent should
[11:30] be able to work out
which tools to use,
[11:33] which ones to execute, and
then get to the point where,
[11:35] hopefully, that the
user's task is complete.
[11:39] Now, the great
thing about this is
[11:40] that we're able to use the
existing semantics of modern web
[11:44] development.
[11:45] Everyone pretty much here knows
how to build an HTML form.
[11:49] Well, we can just add a
number of extra attributes
[11:51] onto the form, like a
tool description which
[11:54] describes to the agent
what this form does
[11:57] and how to interact with it, and
then some extra tool parameter
[12:00] descriptions about how the
agent should fill the form out.
[12:04] And so, for
instance, if you have
[12:05] things like maybe a star
rating, you would say,
[12:07] this is a star rating or this is
a description or some comments,
[12:11] you get the ability to
explain to the agent
[12:13] through a normal form
with HTML attributes
[12:17] how they should interact with
it, which I think is incredible.
[12:20] If you're on the
Imperative API, we
[12:22] have navigator.modelC
ontext.registerTool.
[12:25] And, again, it's a
similar type of shape.
[12:27] You give it a name so the
agent knows what tool to call.
[12:30] You give it a description,
which describes
[12:32] the intent of the
actual tool, and then
[12:35] an input schema, which describes
the shape of the data that
[12:38] will go into the function.
[12:39] And then when the agent chooses
to match the user's intent
[12:43] with this tool, it will
then execute the function
[12:48] with the data passed in as well.
[12:50] I think this is just a
very powerful primitive
[12:52] that we have where
we have both HTML
[12:54] and also JavaScript
ways of actually
[12:57] engaging in this
agentic ecosystem.
[12:59] But the one thing I really like
about this, one, obviously,
[13:02] I think it's actually quite--
[13:03] I don't want to say simple, but
it should be relatively-- well,
[13:05] I'm going to say it.
[13:06] It's relatively simple-- sorry--
[13:08] to start to think about how to
integrate into your experience
[13:11] at a technical level.
[13:12] Maybe at a wider level,
your site architecture,
[13:15] it's a little bit harder.
[13:17] But the real powerful
thing about this
[13:18] is because it's running
inside the browser,
[13:20] it's running inside the
context of where the user is.
[13:23] So you have things like
sign-in state and other cookies
[13:25] and local storage just available
to these tools, something
[13:29] that you don't really
get from other kind
[13:31] of tool-based, MCP-based systems
where they're not actually
[13:35] running inside the browser.
[13:37] Now, obviously, this all runs
within the security boundaries
[13:40] and the security
context of the browser,
[13:43] but I think this is
a very powerful way
[13:45] of starting to integrate
within the ecosystem.
[13:49] So I just want to show you a
quick demo of one of the people
[13:52] that we've been working with.
[13:53] Now, this is an experiment.
[13:54] It's not a
production-level system.
[13:55] But Expedia have been
doing some integrations
[13:58] to try and integrate WebMCP into
a hypothetical flow for them.
[14:03] So I'm just going to
talk through the demo.
[14:04] Now, we start off-- it's hard
to see, but a search that says,
[14:08] find a hotel close to
Grandma on the 4th of July.
[14:10] Gemini will then create
the task, the plan.
[14:13] The user accepts it.
[14:15] And then they have a
number of different tools
[14:16] on the system like Search
Lodging, Update Lodging Filters,
[14:20] and then Navigate to Property.
[14:22] And the browser is working
out which tool to call.
[14:24] And so in this case, actually,
it's called some tools
[14:26] to update the
search, but it's also
[14:28] doing actuation on the page.
[14:30] So they don't have an
Update Date Filter,
[14:32] but it's done the actuation.
[14:33] It will then work
out, well, actually,
[14:35] we think we want to send
the user to this hotel.
[14:40] There we go.
[14:41] It's kind of worked.
[14:42] And then the user has the
ability to either confirm
[14:44] or, in some cases, the agent
might choose to check out.
[14:47] Now, this is just an experiment.
[14:49] This isn't in production.
[14:50] But it gives you an idea
about how these things might
[14:52] work in the future.
[14:53] And I think it's
quite exciting to see,
[14:55] especially once we
figure out performance,
[14:58] and we work with on the
security primitives even more.
[15:01] There are another whole set of
other people in the industry who
[15:05] have also been
experimenting with WebMCP
[15:08] and given us a lot more
feedback around this as well.
[15:10] Now, WebMCP is designed to
be an open specification,
[15:14] and we are working across the
industry standards bodies.
[15:17] But I will say, it is still
very experimental at the moment.
[15:21] Now, Gemini and
Chrome will also start
[15:23] to work out how to
integrate this so we
[15:25] can experiment even further.
[15:26] And we're running some of
these early tests with some
[15:29] of these partners as well.
[15:31] But if you want to actually
stay on top of this,
[15:34] you can register at this
URL for the Origin Trial.
[15:38] Now, we're expecting this will
land in Chrome in Chrome 149,
[15:42] which, if I get my
dates correctly,
[15:43] it's about June the 2nd.
[15:45] So it should be available around
June the 2nd for you to start
[15:47] experimenting with as well.
[15:48] And our goal here is once
you're in the Origin Trial,
[15:51] we really want your
feedback to shape out
[15:54] how this API should work.
[15:55] Does it work for you?
[15:56] Does it work for your use cases?
[15:57] And then we can work
out how we can actually
[15:59] start to help other
developers architect this,
[16:03] if this does become a standard.
[16:06] Now, that's agents transforming
how users will browse.
[16:10] I just want to spend
some time talking
[16:12] about how the tools that we
use will change how we build
[16:14] software, at least, anyway.
[16:16] So on a personal level,
I'm a manager in the team.
[16:19] And prior to maybe
the last six months,
[16:21] I could do development
in my free time.
[16:23] But now, with some
of these tools,
[16:24] I'm building every single day.
[16:26] And the weird thing is,
probably like many people,
[16:28] we're having conversations with
a tool that kind of works out
[16:32] what we want to try and do.
[16:33] I don't know about
everyone else,
[16:34] but I actually
have a microphone.
[16:35] I just use my voice to literally
talk to my large language model.
[16:39] I ask it kind of what
I want to try and do.
[16:41] And then I have a conversation
about how we're going
[16:44] to achieve it, edge cases.
[16:45] And that's before I then
get it to start to work.
[16:49] Now, I'm definitely far from
the only developer doing this.
[16:51] I actually ran some--
this is from my blog.
[16:53] But I ran some
analysis across GitHub
[16:55] to understand how
many people are
[16:57] using all the different
tools to create commits.
[17:00] It's going like crazy.
[17:02] Millions and millions
of developers
[17:03] are submitting millions
of pull requests every day
[17:06] with agentic tools.
[17:07] And so this is one
of the trends that we
[17:09] want to make sure that we're
able to help developers with.
[17:13] Now, the tension is,
obviously, the tools
[17:16] are advancing at a
pretty rapid pace.
[17:20] Our workflows are changing.
[17:21] It's at conflict with how
the web platform works.
[17:25] If you take one example
of a browser, so Chrome,
[17:29] it updates once
every four weeks.
[17:30] I think in a couple
of months, it's
[17:32] going to update once
every two weeks.
[17:34] But the models are trained
on a version of the web
[17:36] from a year ago, in some cases.
[17:39] And so how do we deal
with that tension?
[17:41] So today, what happens if I
want to build some technology--
[17:44] some examples like my
HTML-in-Canvas demo--
[17:47] I would load up the
context with the samples,
[17:50] the examples, the spec, the
explainer, some unit tests,
[17:53] sometimes, submit that in.
[17:55] And then they're actually
pretty good at building.
[17:58] But I have to know about
all of that context.
[18:00] And if you're a
general developer,
[18:02] you're not staying
on top of things.
[18:04] It's my job to stay on
top of all these things.
[18:06] Every other developer is just
like, I've just got a job to do.
[18:09] I need to implement some
functionality for my business.
[18:11] So the real question
for me becomes,
[18:13] can Chrome help in this space?
[18:15] Can we take the decades of
web development experience
[18:18] and help you solve and reason
about the modern platform?
[18:22] I really want us to
get to a point where
[18:24] we're able to build
for the web of today,
[18:27] not like the web that was.
[18:28] And so I think
the answer is yes,
[18:29] we can definitely
help in this space.
[18:32] So one way that we're doing
this is with the preview
[18:34] that you saw in
the keynote, which
[18:36] is with Modern Web Guidance,
which is a skills pack.
[18:38] And the goal here is to give
your tools a validated-- sorry,
[18:43] there we go--
[18:44] a validated, evergreen
repository of the best ways
[18:48] to improve the compatibility
and implement what is
[18:52] and what we think is
the modern web platform.
[18:55] You can install it with a pretty
simple universal script, npz,
[18:59] modern-web-guidance
install, which
[19:01] means that it should
work in any IDE or CLI
[19:04] that you have that
supports skills.
[19:06] And we've built up a number
of different skills as well.
[19:09] We have high-level skills around
web performance, identity,
[19:12] and security.
[19:13] And then there's
lots more guidance
[19:15] around specialized
skills across I
[19:16] think it's over 100 other
different common use
[19:19] cases that you as
developers have to implement
[19:22] in your sites every day.
[19:23] And then we're
able to match that
[19:24] with the modern equivalent
on the platform.
[19:28] We aim for this
guidance to also be very
[19:30] understanding of
baseline is probably
[19:33] the easiest way to say it.
[19:35] So even if a feature
that you're using
[19:37] isn't baseline widely available,
we should be able to give you--
[19:41] or we should be able to
make you more confident
[19:43] and give you the guidance with
a set of fallbacks and maybe
[19:46] progressive
enhancements as well.
[19:47] So the goal here
is that you should
[19:49] be able to rely on the guidance
that is coming from these skills
[19:52] packs to be able to be
usable by your users.
[19:55] But you also need to
understand who your users are.
[19:57] And we're also launching a
new tool with an integration
[20:00] into Google
Analytics so that you
[20:02] can understand from your actual
pages your baseline target
[20:06] and work out your
baseline target based
[20:08] on how your users are
interacting and visiting
[20:11] your site.
[20:12] And so we can go to, I think,
baseline-checker, chrome.dev.
[20:17] Now, I think, in
all, broadly, this
[20:19] is going to enable our
coding tools to properly
[20:21] use modern features,
ideally, to follow
[20:24] best practices from
industry experts
[20:27] within Chrome and
across the industry,
[20:29] and to help you use platform
features in a way that solves
[20:32] your problems without you having
to reason about the entire shape
[20:36] of the web platform.
[20:37] Now, for me, I'm actually very
excited about this because LLMs
[20:40] are going to give us, or are
giving us, a way to experiment
[20:43] at scales that we've
never been able to.
[20:45] But I do want to
make sure that we're
[20:46] able to build experiences
that are high quality, safe,
[20:49] and then don't
come at the expense
[20:51] of cross-browser compatibility.
[20:53] And I think this project with
the high-quality guidance
[20:56] built in and
maintained by our team,
[20:58] we're definitely on
a step and a path
[21:00] into that phase, that space.
[21:02] If you do want to learn more
about Modern Web Guidance, Phil,
[21:05] who is just sitting
there, he's going
[21:06] to be the next
talk in this room.
[21:08] And if you're on the livestream,
the next talk on the livestream.
[21:10] And he's going to do a deep
dive into using Modern Web
[21:13] Guidance and how it works.
[21:16] So returning to my
conversations with my machine,
[21:18] my large language models,
as I build with agents,
[21:22] I'm not just sending
them off to work.
[21:24] I actually am working with them
in a really, really tight loop.
[21:27] And my tools, they do output
the code, essentially,
[21:31] that I requested.
[21:32] And they run it against
a battery of tests,
[21:34] but they don't really
have a deep understanding
[21:36] of how the page is
running, what is actually
[21:39] on the page, what is
rendered, and how it's
[21:41] working inside the browser.
[21:43] This ability to
really deeply inspect
[21:46] pages inside the browser, it's
been a developer superpower
[21:48] for years.
[21:49] We all use Chrome DevTools
or Safari DevTools,
[21:52] all the different DevTools.
[21:54] But now, we want to make sure
that with DevTools for Agents,
[21:57] your tools also have the
same ability to actually
[22:00] deeply inspect your pages.
[22:02] So one example
about this is we're
[22:04] going to give you direct access
to things like console logs,
[22:07] network traffic, memory traces.
[22:09] We give you access to
the accessibility tree.
[22:11] And by bringing this runtime
data into your tools,
[22:14] you're able to perform very
sophisticated diagnostic tasks
[22:17] like performance profiles, heap
snapshots, memory debugging,
[22:21] and then automated
Lighthouse tests as well.
[22:24] DevTools for Agents,
it's an MCP server
[22:26] so you can just install
it the same way that you
[22:28] install any other MCP server
into your environment.
[22:32] And then, really,
all you have to do
[22:33] is then, say, prompt
the agent to run, say,
[22:36] a comprehensive
performance analysis
[22:38] of developer.chrome.com.
[22:40] There are performance
issues, and it
[22:41] will tell us what we need
to fix there as well.
[22:43] And the goal here
is really designed
[22:45] to transform the
debugging process
[22:47] and aiming to reduce the
amount of manual intervention
[22:51] and also the manual
fixes that you
[22:52] have to do because you can get
the tools to then subsequently
[22:55] fix the issues
that it finds when
[22:58] it runs something like a
Lighthouse audit as well.
[23:02] Now, when we first shipped this,
I was like, great, this is done.
[23:06] We don't need to
update it anymore.
[23:07] Well, it turns out, the team's
like, nah, we have to update it.
[23:10] We've got loads of ideas.
[23:11] And so we've done a number
of different features,
[23:14] and I'm going to go through
them pretty quickly.
[23:16] So the first one is
we've introduced Skills
[23:18] into the DevTools
for Agents project,
[23:21] and that's going to
enable the tools to handle
[23:23] more complex tasks.
[23:25] So if it needs to do,
say, memory debugging,
[23:29] we can instruct it
to do heap snapshots
[23:30] and then understand how to
actually reason about what
[23:33] is in the heap snapshot.
[23:34] We have a CLI tool.
[23:35] So if you're on the command
line or you want your agents
[23:38] to be a little bit
more token efficient,
[23:39] you can use the CLI
version of the tool.
[23:41] And we also have
a TypeScript API
[23:43] if you want to integrate
it into something
[23:45] like your continuous
integration environment.
[23:49] We also have the
ability to connect
[23:50] to a running instance
inside Chrome
[23:53] so that the idea here is
that your agent can then
[23:56] pick up from where you left off,
which I think is pretty cool.
[23:59] And, obviously, people are using
it for things like OpenClaw.
[24:02] We can also support
multi-agent workflows.
[24:04] Now, this is great.
[24:05] So you can connect to
multiple instances of Chrome,
[24:08] and this is important
if you're creating
[24:09] multi-user systems or
multi-role-based systems
[24:12] as well.
[24:13] So can connect to two or three
or four different versions
[24:16] of Chrome at the same time.
[24:17] And one thing as well is that
if you're inside Chrome DevTools
[24:19] and you're inside
the Network panel,
[24:21] you can, say, select an
element in the Network panel
[24:23] and then ask your
agent to analyze
[24:26] what is selected as well.
[24:27] So we have this
really nice hookup
[24:28] between DevTools, DevTools for
Agent, and then, obviously,
[24:32] within other things as well.
[24:34] And then the final
piece is we also
[24:36] now have the ability to
automatically install and debug
[24:39] Chrome extensions.
[24:40] So if you're a Chrome
extension developer,
[24:43] you can do the install,
you can inspect
[24:45] the service worker, the
side panels, the pop-ups.
[24:48] It's a whole new level of
automation for Chrome extensions
[24:51] as well, all powered
by DevTools for Agents.
[24:54] I'm very excited about this.
[24:55] On one hand, we've got
Modern Web Guidance.
[24:57] The goal here is to give you
access to the best practices
[25:00] to help you build
for the modern web
[25:01] so you can build higher sites.
[25:03] And then on the other side, you
have Chrome DevTools for Agents.
[25:06] The goal is to just give
your tools the ability
[25:08] to really deeply understand
what's on the page, any issues,
[25:12] and fix them.
[25:13] It's a really nice tool-assisted
loop for building sites.
[25:17] And, obviously, I
can't stop here.
[25:20] Loads more to go still.
[25:22] As the tools
improve just broadly
[25:24] and we're able to build
higher-quality sites,
[25:26] I think it is important
to look at what
[25:30] is coming to the
platform that is also
[25:31] going to enable you to
build those higher-quality
[25:34] experiences.
[25:34] And so I'm going to give you a
very brief overview of what's
[25:37] come to the web platform and
also what is going to come
[25:40] to, hopefully, Chrome soon.
[25:42] But one of the
things you'll hear me
[25:43] say quite a lot and the
team talk about is baseline.
[25:46] This is a really
important component for us
[25:48] because baseline is
the cross-browser--
[25:55] all the features that
every browser supports,
[25:58] so it's what you as developers
can really, really rely on.
[26:01] Since last year when
I was on this stage,
[26:03] I think 55 new features
have become baseline widely
[26:06] available, which are
available for you
[26:08] to be able to use and be
confident that you can use it
[26:11] with your user base.
[26:12] That's things like the Search
element, Origin, private file
[26:15] system, Subgrid,
OffscreenCanvas, MathML.
[26:18] There's like, 50 more
after this as well.
[26:20] But I think the bit here is that
the exciting thing is not just
[26:23] the features.
[26:23] It's the fact that every
single browser vendor
[26:26] is trying to push on the
platform at the same time
[26:29] to make it easier for every
single developer to build for.
[26:33] And again, since I was here
last year, 44 features,
[26:36] as of April the 22nd, have
become newly available,
[26:40] things that you can start to
plan to use in the near future.
[26:43] They are available
across all browsers,
[26:45] but they might not meet your
usage requirements in terms
[26:48] of your browser-support matrix.
[26:50] Now, I don't have enough
time to go through all 44,
[26:53] but I do want to give
you a highlight of how
[26:54] some of these things that
have come to the platform
[26:57] is going to change
how the web feels.
[26:58] And actually, before I
go to the next slide,
[27:00] I did a little
check this morning.
[27:02] We're actually at 52
features as of this morning
[27:04] that are now baseline
newly available.
[27:07] So the first up is,
you probably heard
[27:09] us talk about this quite
a lot, view transitions.
[27:11] We just think this
is going to change
[27:12] the way that the web feels.
[27:13] It enables smooth transitions
between different view states
[27:16] inside a page and
also across pages
[27:19] without the need for complex
JavaScript like libraries
[27:22] and animation libraries.
[27:24] And it's going to help
basically improve the perceived
[27:27] performance of the web.
[27:28] And to complement
view transitions,
[27:30] the Navigation API is
now newly available.
[27:33] And the Navigation
API, the goal here
[27:35] is to replace the aging
History API inside the browser.
[27:39] And it lets you manage
your application state, all
[27:42] your navigations, through
one event, essentially,
[27:45] so you can understand
whether someone is pressing
[27:48] backwards and forwards.
[27:49] And you can then hook that up
with your View Transitions API
[27:52] as well.
[27:53] This is going to make web
applications just so much easier
[27:55] to build.
[27:56] And then the final
piece is you'll
[27:59] hear us talk about
Core Web Vitals a lot.
[28:01] Large Contentful Paint and
Interaction to Next Paint
[28:05] are also newly available.
[28:06] And what this means
is that you can just
[28:08] understand how your users
are using your site in terms
[28:12] of performance and
responsiveness,
[28:14] irrespective of browser.
[28:16] So if your user
is using iOS, you
[28:18] will have these metrics
available to you now.
[28:20] And I think this is one
of those ones where we're
[28:22] very excited to see what's
happening with Core Web Vitals
[28:25] just for the last
couple of years
[28:26] because it really
does help you improve
[28:28] the performance of your site.
[28:30] And now, you can understand
it irrespective of whatever
[28:33] browser someone's using.
[28:35] Now, I mentioned that there's 44
new features or 52, technically,
[28:39] baseline newly
available features.
[28:41] It's a lot to keep up with.
[28:43] And so with webstatus.dev,
you can use this new thing
[28:47] called Baseline Alerts.
[28:49] And the goal here
is to enable you
[28:50] to track when features
come into a browser, when
[28:53] they become newly available or
also baseline widely available.
[28:57] You can get notified via email,
RSS, or even webhooks as well.
[29:01] And the goal is just
to make it easier
[29:02] for you to understand how the
platform is evolving so that you
[29:06] can just plan your business
and your sites way more
[29:08] effectively into the future.
[29:11] Now, one of the
things I do-- a couple
[29:12] of things I love about my job,
is, one, I get to tinker a lot.
[29:15] I build lots of things
at the very cutting edge
[29:19] of web development with Chrome.
[29:21] But I also get to talk to
developers every single day.
[29:24] Now, two of the
things that people say
[29:27] is, firstly, we just
need to ship better.
[29:30] We need to be able
to ship more easily,
[29:31] understand what's
on the platform,
[29:33] make sure the platform's
more predictable.
[29:35] Don't go breaking
the web all the time.
[29:37] The goal there is that's
baseline Modern Web Guidance.
[29:40] They're the tools that hopefully
help you ship more sites more
[29:44] effectively.
[29:44] And then the second
part of this is
[29:46] that you want to
understand where
[29:47] the web is going so that you
can plan for the next one or two
[29:49] years ahead.
[29:50] And so that's what
I'm going to talk
[29:51] about now, all the
things that are
[29:53] starting to come into Chrome.
[29:55] So I want to show
you some of the bits.
[29:57] This is the very
tactile part of the web.
[29:59] I don't think you'll hear
me say agents one more time,
[30:02] but these are the
things that people will
[30:04] experience as they use the web.
[30:06] Actually, no, you will hear
me say agents one more time.
[30:08] I told a little bit of a lie.
[30:09] So the bit here is we
have two areas or two ways
[30:12] that I think about this.
[30:13] One, how do we put on-device
intelligence into people's hands
[30:17] because the technology is
very capable and very good?
[30:20] And then the second
is, how do we actually
[30:22] just help you improve people's
experience of the web?
[30:25] So for the first
area, obviously, LLMs
[30:28] have changed what is
possible with the computer.
[30:31] And obviously, they've evolved
from things like text completion
[30:34] and then semantic
data extraction.
[30:36] Then people moved on
to more summarization.
[30:38] And now, people are
starting to look
[30:40] at function calling for those
kind of agentic use cases.
[30:44] Now, the tools I'm
going to talk about
[30:46] are designed to
help everyone think
[30:48] about these new
types of experiences
[30:50] that they want to
bring to the platform
[30:52] by enabling more
intelligence in the browser.
[30:55] Now, the way I look
at this is that we
[30:57] do want to make sure that
everyone should have access
[30:59] to these tools, irrespective
of internet connection.
[31:01] And they should be able to run
them privately and then also
[31:04] at no cost in the context
of large language models.
[31:07] Now, the Prompt API, it
came to Chrome in 148.
[31:10] And it came with
multimodal support
[31:12] as well, which means that you
can also analyze, for instance,
[31:15] images and understand
what's happening.
[31:17] And this basically
means it makes it easier
[31:19] for you to think about these
new kinds of experiences
[31:23] that you want to add.
[31:24] But it is only
available in Chrome.
[31:25] This is only a
Chrome-based experience.
[31:27] And so one of the things that
we encourage people to do
[31:30] is to think about where
you can use these features
[31:32] progressively, without them
being core to your application
[31:35] right now.
[31:36] But we do have a number of
partners, Trip.com, Drupal,
[31:38] and Temu, who have
experimented with this API
[31:41] and also shipped it to
production to their users.
[31:43] And so I just want to give you
a quick overview of Trip.com.
[31:46] It's a very short demo.
[31:47] But they integrated the Prompt
API just to make it easier,
[31:50] on the left-hand side,
to navigate flights.
[31:53] If you don't have this Prompt
API, it doesn't appear.
[31:56] But if you do, it's a nice,
simple, progressive enhancement
[31:59] and a nice feature for them.
[32:01] And I believe they like using
this technology on that side.
[32:06] The Prompt API also
supports structured output.
[32:08] And the reason why
we have this is
[32:10] it just enables you to
constrain the output
[32:12] from the large language model.
[32:13] So if you're building
an application that
[32:15] needs to understand
what's come out
[32:16] and respond to things inside--
[32:19] respond to maybe the
caption, for instance,
[32:23] you can basically get
JSON out, and then you
[32:25] can just integrate it into
your application logic
[32:27] just far more effectively
than just parsing strings.
[32:31] And we've also expanded language
support from English-only
[32:34] to include French, German,
Japanese, and Spanish,
[32:37] with more to come in the future.
[32:39] And [? Ken G's ?] at the back,
and I hope Welsh is coming soon.
[32:42] Is Welsh coming?
[32:43] Is Welsh coming?
[32:45] Maybe.
[32:46] We'll see.
[32:46] We'll talk later.
[32:46] Anyway, it's fine.
[32:47] I'm learning Welsh.
[32:49] Looking ahead, we're
also expanding what
[32:53] we can do with the Prompt API.
[32:54] So we're going to introduce
the Gemma family of models.
[32:57] And when we introduce that
Gemma family of models,
[33:00] it's going to enable us to do
native function calling, which
[33:03] is going to enable you to build
these autonomous client-side
[33:06] agents inside the web.
[33:09] Now, we do want to make
sure that these upcoming
[33:12] improvements are rock solid,
the performance and the quality
[33:15] and the security are all great.
[33:16] So please do sign up for
our early preview program
[33:19] so you'll get
access to the latest
[33:20] capabilities but
the ability to help
[33:22] us influence the shape of these
APIs into the future as well.
[33:25] If you want to learn more about
this, Thomas Steiner has a talk,
[33:28] "Build New Features Using
Built-in AI in Chrome."
[33:30] And I encourage you to
watch that because it's
[33:33] way more expansive about what
we're doing with built-in AI
[33:36] on-device.
[33:38] Now, when I think about the
web and improving experiences,
[33:42] there's been a huge
amount of new capabilities
[33:45] that have come to the platform
just in the last year alone.
[33:48] Now, I get really
excited by these
[33:49] because they enable people
to experience things
[33:51] that they've never
seen before, but they
[33:53] enable developers
to build things
[33:55] that have been previously
impossible to do
[33:57] on the platform.
[33:58] And I think we've taken huge
strides in new capabilities
[34:01] on the platform this year.
[34:02] Single-page applications are
now able to correctly measure
[34:06] their Core Web
Vitals performance
[34:08] between routes with the
introduction of soft navs.
[34:10] This is going to
come in a slightly
[34:11] later version of Chrome.
[34:13] But what it does,
our data indicates
[34:15] that if you have
a single-page app,
[34:17] your Core Web Vital
pass rates will go up.
[34:19] But I do want to
show you something
[34:20] that I think is just going to
change the way that we build
[34:22] some UIs in the future
that are both performance
[34:25] and also UI wins.
[34:26] And I think it's
one of the biggest
[34:27] changes to HTML in a decade.
[34:29] So if you go back to
my bedroom and look
[34:31] at the clock on my
machine, you can
[34:33] see it updating every
single second, kind of what
[34:35] you'd expect from a clock.
[34:37] But the thing is there's
no JavaScript on this page.
[34:39] It's updating every
single second.
[34:42] And that's because of the
declarative partial updates,
[34:45] the implementation that
is coming into Chrome.
[34:47] You can now render updates
to HTML out of the order
[34:50] that they were sent on the wire
and that they appear in the DOM.
[34:53] Now, the clock demo isn't
all that useful by itself,
[34:57] but I do think it highlights
some compelling potential use
[35:00] cases.
[35:01] So for example, if you have
a huge amount of application
[35:04] structure, say, a massive
menu, you can render it
[35:07] at the end of your page,
let the critical content
[35:10] get rendered first, then you
can patch it back into the DOM
[35:13] just a little bit later.
[35:14] It's available in Chrome 148.
[35:16] And also, you don't
need JavaScript for it,
[35:18] which is great.
[35:19] I just want to show you
this other demo as well.
[35:21] You can think about
UI placeholders.
[35:22] If you have a very slow task
for looking up user data,
[35:26] frequently, we'd send
off a different request.
[35:28] You can keep it on
the same request
[35:30] and patch it in at the
end of the HTTP request.
[35:34] And because the way
that this API works,
[35:36] it will just update
the user interface
[35:38] with the latest data that's
come from that, again,
[35:42] all without JavaScript.
[35:44] But there's huge amounts
of different things
[35:45] that we can do with this
API, and this is just
[35:47] the start of some of them.
[35:49] Now, I want to show you
one other thing where
[35:50] I think I would like to
make HTML the new JSON,
[35:53] and we have a new API that's
going to help with that.
[35:56] So if you've been
using frameworks,
[35:57] you'll probably know about
something called the island
[35:59] architecture.
[36:00] I think it's a
beautiful pattern,
[36:01] and it's a beautiful concept.
[36:03] But it's going to be
even easier for us
[36:05] as just plain JavaScript
developers to do
[36:07] something very similar.
[36:09] So the new streaming
API for dynamic markup
[36:11] gives you a revamped way
to improve experiences
[36:15] by letting you inject
HTML into documents
[36:18] via the streamHTML and
streamHTMLUnsafe methods.
[36:21] Actually, there's a whole family
of different API calls in this.
[36:24] But what this
really means is you
[36:26] can take the body
from a fetch request
[36:28] and then just stream it
directly into the DOM.
[36:31] You don't need to do these
JSON transforms anymore.
[36:34] I think it's a very new,
powerful, primitive.
[36:37] These APIs have both been
available in Chrome since Chrome
[36:40] 148, so pretty recent.
[36:41] They're going to
change the way--
[36:43] I think, personally, they're
going to change the way that we
[36:44] build web experiences as well.
[36:46] But please do go to this URL,
try it out, and give us feedback
[36:49] so we can get it
across the platform.
[36:53] Now, obviously,
over the last year,
[36:55] we've been focusing a lot on
making the web just feel better,
[36:58] giving you way more APIs.
[37:01] If you look at it from
an API perspective,
[37:03] just a huge amount of
CSS and JavaScript APIs
[37:06] that are letting you build
more complex and richer user
[37:08] interfaces.
[37:09] But it really is more than
just API and aesthetics.
[37:13] Our goal is to help
you build sites
[37:15] that just scroll better,
transition between views better,
[37:19] enable people to interact
with their devices in a more
[37:22] physical and intuitive way.
[37:24] Now, I don't have a
huge amount of time
[37:26] to go through most of this,
but Yuna [? and Bramis ?]
[37:28] have identified five
core UX principles that
[37:31] are going to change
the way of how we think
[37:33] about building for the web.
[37:35] And so I would encourage
everyone to watch that talk.
[37:37] But there is one
technology that I
[37:39] think is going to change
what we build for the web,
[37:42] and that is HTML-in-Canvas.
[37:43] And I'm going to spend a
little minute or two talking
[37:45] about that.
[37:46] So you saw from the demo at the
start where this 3D experience,
[37:49] and we can integrate a fake
web browser into a computer.
[37:52] That's HTML-in-Canvas.
[37:54] And what it lets you do is just
render standard DOM directly
[37:57] into a Canvas element.
[37:58] And this can be used in a
number of different ways.
[38:00] You can imagine 2D
application frameworks,
[38:03] maybe something like QT, or even
3D engines starting to integrate
[38:07] this so that they can just
take the functional benefits
[38:10] of the web's rich semantic UI
layer and have real DOM content
[38:14] that's searchable,
translatable, accessible,
[38:20] interactable as well,
right inside the Canvas.
[38:23] But I just want to give
you a little preview
[38:25] of some of the
things that you might
[38:26] be able to do with this API.
[38:28] On one level, you could
take an individual element--
[38:31] this is an input
type equals range--
[38:33] and basically make it look very
different to what we expect.
[38:37] This is a semantically correct.
[38:39] There's the input
element up just there,
[38:41] and we're providing a
new, richer UI layer.
[38:44] Now, I don't imagine
every single website
[38:46] looking like this.
[38:47] I think it would be actually
pretty over the top.
[38:49] But if you have a
consistent design language
[38:51] that you can't implement
right now on a page,
[38:53] you can start to think
about, well, maybe I
[38:55] can use something like
HTML-in-Canvas to enhance it.
[38:58] And if the API is not there?
[38:59] It's great.
[38:59] It'll just look like your
existing website right now.
[39:02] You can go all the way to
those 3D-like experiences
[39:05] by integrating it into
something like Three.js.
[39:08] So you can have 3D car
dashboard, interactive books.
[39:11] We have a whole demo
station out there,
[39:12] which you can look at
which shows you what to do.
[39:14] Again, all accessible,
interactable.
[39:17] It takes advantage of all
the browser's features,
[39:20] things like Translate
and Search as well.
[39:22] I think this is just a
new layer of richness
[39:24] that we're going to
enable across the web.
[39:26] And personally, it's
one of those reasons why
[39:28] I think people will keep
coming back to the web,
[39:30] because we have
these experiences
[39:31] that you just can't
get anywhere else.
[39:33] Now, it is designed to be as
simple as possible to integrate.
[39:36] And if you have PlayCanvas or
Three.js, you can use it today.
[39:41] And it is just as simple as
adding a new material or texture
[39:44] into Three, and then the
library and the browser
[39:46] just handle all of that extra
complexity for you as well.
[39:50] I just think this is
a game-changing API,
[39:52] and I think it's going to change
the way that we experience
[39:54] the web.
[39:55] And if you look at the
rest of the ecosystem,
[39:57] this is something
that Wes Bos has done.
[39:59] It's hundreds of experiments
that are happening right now.
[40:02] If you're on X, and you
search for HTML-in-Canvas,
[40:04] you'll just see
people tearing up
[40:06] web pages, exploding web pages.
[40:08] Again, these are
all very fun demos,
[40:11] but it just highlights how
expressive this API can be.
[40:14] And there's hundreds of
more things happening
[40:17] in the ecosystem right now.
[40:19] I mean, I suppose
we could watch.
[40:22] You can go to
experience outside.
[40:23] I think it's going to be great.
[40:25] I think the bit here, though,
is if you want to try and see
[40:28] what we can do with this API,
we're starting to pull together
[40:31] an awesome HTML-in-Canvas
page where we're
[40:33] trying to aggregate the
ecosystems experiments
[40:36] in this place as well.
[40:38] So if you have a HTML-in-Canvas
demo, send us a link.
[40:40] We'll try and get
it on there as well
[40:42] because it's a really
beautiful, expressive API.
[40:49] So that was a lot.
[40:50] How many times did I say agent?
[40:52] AUDIENCE: 62.
[40:52] PAUL KINLAN: 62?
[40:53] Wow.
[40:54] OK, brilliant.
[40:55] You can probably tell I'm
quite excited for the future
[40:57] of the web platform.
[40:58] I think the platform
is going to evolve.
[41:00] For the people
who use it, you're
[41:02] going to see APIs
like HTML-in-Canvas,
[41:05] a whole bunch of
new UI primitives
[41:07] that just make the web
rich and expressive
[41:10] and something that
is very fun to use.
[41:12] And then at the
other side of things,
[41:13] we do want to evolve
the web so that it
[41:16] is a participant in these new
platforms, things like WebMCP,
[41:19] and getting it into
the experiences
[41:22] like the agents and the
tools that you're using.
[41:24] I think it's going to make the
web a first-class experience
[41:27] across all these different
types of platforms.
[41:29] And I think the real
important thing for me
[41:31] and why I'm in
developer relations
[41:33] is that we just want to
help you do this as well.
[41:35] We know it's hard to
navigate the ecosystem
[41:38] and understand what's
going on, and that's
[41:40] where things like
Modern Web Guidance
[41:41] comes along, where we can give
you the tools to help you build
[41:45] for the modern web effectively.
[41:48] So that's it.
[41:48] Thank you for coming along.
[41:50] You've been a great audience.
[41:52] Brilliant.
[41:52] [MUSIC PLAYING]