Google Overhauls Chrome DevTools MCP to Curb AI Agent Token Burn

Building Agent Interfaces: Lessons from Chrome DevTools (MCP) for Agents — Michael Hablich, Google — AI Engineer

AI Engineer

Autonomous coding agents require concise semantic summaries rather than raw runtime dumps, alongside deliberate human-in-the-loop friction to prevent prompt injection through the lethal trifecta.

AI-assisted summary of Building Agent Interfaces: Lessons from Chrome DevTools (MCP) for Agents — Michael Hablich, Google — original source. Check the original for full context.

Source published:

Key ideas

  • Feeding raw browser performance traces of over 50,000 JSON lines saturated agent context windows into degraded reasoning zones, prompting Google's DevTools team to replace raw outputs with concise Markdown summaries focused on Core Web Vitals. (3:31)
  • The Chrome DevTools MCP team established 'Tokens per Successful Outcome' as a core efficiency metric, evaluating task completion against token expenditure within specific workflow categories rather than across global product benchmarks. (8:09)
  • Replacing a monolithic debugging tool with 25 granular endpoints shifted failure modes from inability to compose multi-step plans to tool selection ambiguity, highlighting that tool descriptions serve as the graphical UI for language models. (15:26)
  • To prevent Simon Willison's 'lethal trifecta' of security vulnerabilities, DevTools deliberately preserved autoconnect friction and explicit human consent prompts instead of auto-authorizing live browser sessions. (18:33)

Detailed notes

## Background Published by the AI Engineer channel on YouTube on June 5, 2026, this talk features Michael Hablich, Product Manager for Chrome Developer Tools at Google. Hablich reflects candidly on the iterative failures and breakthroughs in building the Chrome DevTools Model Context Protocol (MCP) server, detailing how the team moved from monolithic tools and context-saturating JSON files to an optimized, agent-centric architecture.

## TL;DR Hablich presents four core engineering lessons learned from treating AI coding agents as a distinct user class with unique cognitive and context constraints. The DevTools team replaced massive 50,000-line JSON traces with concise semantic Markdown summaries and established 'Tokens per Successful Outcome' to evaluate interface fuel efficiency. To help agents self-heal, they rewrote opaque error messages into deterministic recovery instructions and balanced tool discoverability between an unwieldy 25-tool surface and an aggressive 3-tool 'slim mode.' Finally, Hablich outlines a three-tier security model, defending the deliberate preservation of user-consent friction to mitigate prompt injection risks and Simon Willison's 'lethal trifecta.'

## Atmosphere & style The presentation is candid, pragmatic, and refreshingly humble, characterized by an engineering leader openly dissecting his team's past missteps. Hablich speaks with conversational clarity and dry humor, acknowledging how counterintuitive agent behavior proved when treating models like ordinary machines. The room feels intensely engaged, bridging high-level interface philosophy with concrete developer empathy, and building toward an empowering vision of expanding traditional UX into agent experience.

## Bulletin - [03:31](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=211s) Feeding raw browser performance traces of over 50,000 JSON lines saturated agent context windows into degraded reasoning zones, prompting Google's DevTools team to replace raw outputs with concise Markdown summaries focused on Core Web Vitals. - [08:09](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=489s) The Chrome DevTools MCP team established 'Tokens per Successful Outcome' as a core efficiency metric, evaluating task completion against token expenditure within specific workflow categories rather than across global product benchmarks. - [15:26](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=926s) Replacing a monolithic debugging tool with 25 granular endpoints shifted failure modes from inability to compose multi-step plans to tool selection ambiguity, highlighting that tool descriptions serve as the graphical UI for language models. - [18:33](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1113s) To prevent Simon Willison's 'lethal trifecta' of security vulnerabilities, DevTools deliberately preserved autoconnect friction and explicit human consent prompts instead of auto-authorizing live browser sessions.

## Key takeaways - [00:15](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=15s) Chrome DevTools for Agents provides an agent-agnostic interface via Model Context Protocol (MCP) and CLI surfaces, compatible with harnesses like Gemini CLI, Claude Code, and Codex. - [03:31](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=211s) Early agent integrations failed because developers incorrectly assumed software agents could effortlessly ingest multi-megabyte, 50,000-line raw JSON trace files without cognitive degradation. - [03:31](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=211s) Default agent interfaces should emit semantic Markdown summaries highlighting actionable signals like Largest Contentful Paint (LCP) and Interaction to Next Paint (INP) rather than exhaustive raw data dumps. - [05:24](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=324s) Autonomous agents represent a distinct user class with bottlenecks rooted in token budgets and semantic parsing, whereas human developers depend on spatial layout, typography, and visual cues. - [08:09](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=489s) Evaluating agent interfaces requires balancing functional effectiveness (task completion) against efficiency (tokens, execution time, and tool calls) through the metric 'Tokens per Successful Outcome.' - [08:09](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=489s) Measuring tokens per outcome without verifying successful task completion misleads teams, as fast failures appear artificially fuel-efficient. - [11:10](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=670s) Hiding niche tools behind explicit CLI flags prevents default prompt bloat and spares agent context windows on every interaction turn. - [11:10](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=670s) A minimal 'slim mode' exposing only three core primitives reduces prompt overhead, but trades away specialized runtime observability like network request monitoring. - [12:43](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=763s) Allowing agents to chain terminal commands locally (e.g., piping grep into click actions) cuts token consumption by avoiding round-trips of raw DOM trees through the model. - [12:43](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=763s) Rewriting opaque error strings into actionable recovery messages allows agents to self-heal and re-route plans autonomously without human intervention. - [12:43](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=763s) Injecting proactive detours into tool responses nudges models away from slow legacy behaviors (like default Lighthouse audits) toward modern tracing tools. - [15:26](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=926s) Decomposing single monolithic tools into 25 granular endpoints exposes agents to tool selection ambiguity, with research showing 97% of MCP tool descriptions contain quality smells. - [15:26](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=926s) Tool schemas must balance clear activation triggers and standardized terminology (e.g., explicit Core Web Vitals acronyms) against the prompt tax imposed by verbose descriptions. - [18:33](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1113s) Removing authorization friction for convenience exposes users to the lethal trifecta, where private browser data, untrusted inputs, and automated tool execution intersect. - [18:33](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1113s) Browser agent security must be tiered across local human-in-the-loop environments, isolated containerized CI workflows, and hardened sandbox environments for open-web navigation.

## Detailed walkthrough ### [00:15](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=15s) Introduction and Context: Chrome DevTools for Agents

Michael Hablich introduces the session on building agent interfaces, surveying the audience on their familiarity with Model Context Protocol (MCP) servers and command-line interface (CLI) tooling. Virtually the entire room reports already running MCP servers or CLI tools in their agent workflows, while roughly half have directly built and deployed MCP servers. Speaking on behalf of the Chrome DevTools team at Google, Hablich sets out to share four hard-earned engineering lessons drawn from building and shipping Chrome DevTools for agents.

To ground the discussion, Hablich contrasts the familiar human-facing developer tooling with its new autonomous counterpart. Built directly into Google Chrome, standard DevTools serves millions of web developers daily to inspect pages, identify runtime errors, run accessibility or security audits, and capture performance profiles. Chrome DevTools for Agents, by contrast, is purpose-built from the ground up for autonomous coding agents. Hablich demonstrates a live recording of Gemini CLI communicating through the DevTools MCP server: the agent triggers Chrome to launch on the right-hand display, executes a performance trace, digests the resulting performance insight, applies code modifications to accelerate page load, and independently validates that the target page actually runs faster. The architecture is agnostic to the host; while shown on Gemini CLI, Hablich emphasizes that it functions interchangeably inside Claude Code, Codex, OpenClaw, or any MCP-compliant agent harness.

Hablich briefly introduces himself as the Product Manager for Chrome Developer Tools at Google, bringing 20 years of tech experience spanning development, testing, QA, and program management, alongside guest lecturing at a nearby university.

```mermaid flowchart LR accTitle: Chrome DevTools MCP Architecture accDescr: An MCP client interacts with the Chrome DevTools MCP Server to control Google Chrome for debugging and profiling.

subgraph Client["Agent Environment"] Agent["Agent Harness / CLI<br/>(Gemini CLI, Claude Code)"] end

subgraph MCP["Protocol Layer"] Server["Chrome DevTools<br/>MCP Server"] end

subgraph Browser["Runtime Environment"] Chrome["Google Chrome<br/>(Target Web Page)"] end

Agent -->|"MCP tool call"| Server Server -->|"Automates & profiles"| Chrome Chrome -->|"Trace & page data"| Server Server -->|"Semantic summary / result"| Agent ```

[03:31](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=211s) The 50,000-Line Trace Mistake and Semantic Summaries

Around eighteen months prior, the team observed that coding agents were remarkably adept at code synthesis, yet effectively “flying blind” because they lacked real-time visibility into the browser runtime to validate the behavior of the code they generated. Under the initial assumption that software agents are machines and could effortlessly consume arbitrary volumes of data, the team fed raw performance trace profiles directly into common agent harnesses.

This assumption backfired completely. A standard DevTools performance trace is a massive JSON file spanning multiple megabytes and upwards of 50,000 lines of low-level runtime events. Bombarding an agent with a raw trace immediately saturated its context window, degrading its reasoning abilities into what Matt's conference talk dubbed the "dump zone." Hablich admits the mistake candidly: “We assumed they are going to be fine if we throw a lot of data at them. Because I mean, they are machines, right? The thing is, we were wrong.”

To resolve this failure mode, the DevTools team completely redesigned the output layer of their tracing endpoints. While raw JSON traces remain accessible for external post-processing tools, the default interface now synthesizes the raw capture into concise Markdown documents featuring semantic summaries. Instead of parsing tens of thousands of raw engine events, the agent receives high-level Core Web Vitals metrics, such as Largest Contentful Paint (LCP) and Interaction to Next Paint (INP). As Hablich explains the shift: “Well, essentially, we didn't force the agent to read the entire book, the trace, but instead we just pointed it at the right sentence, and this is the semantic summary.”

- Raw performance trace exports frequently exceed multiple megabytes and 50,000 lines of serialized JSON. - Context saturation directly pushes language models into degraded reasoning performance (the "dump zone"). - Default agent endpoints replace raw event logs with pre-digested Markdown summaries highlighting Core Web Vitals (e.g., LCP, INP).

[05:24](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=324s) Agents as a Distinct User Class

The realization prompted the DevTools team to conceptualize autonomous agents as a fundamentally separate user segment. While human engineers and software agents share identical operational goals—such as discovering bugs, fixing layout regressions, or resolving performance bottlenecks—they operate through completely distinct cognitive constraints.

Human developers are fundamentally visual thinkers who depend on spatial layouts, typography, graphical waterfall charts, and color cues to isolate anomalies within dense interfaces. Agents, conversely, possess different bottlenecks centered on context limits, semantic comprehension, and text token consumption, demanding interface architectures that surface concise, structured signals rather than visual representations.

[08:09](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=489s) Fuel Efficiency: Tokens per Successful Outcome

To quantify interface quality for agents, Hablich defines two complementary dimensions: effectiveness and efficiency. Effectiveness evaluates functional intent—whether an agent successfully navigates the full user journey from start to finish. Efficiency measures resource consumption along the way, including token burn, cumulative tool calls, and overall execution time. Hablich synthesizes these into a core operational metric: **Tokens per Successful Outcome**.

Hablich cautions against common pitfalls when applying this metric. High efficiency is meaningless in isolation: “Fuel efficiency is relatively worthless if you can't reach your destination.” Measuring raw "tokens per outcome" without factoring in task success obscures whether an agent failed quickly or succeeded frugally. Furthermore, Hablich warns against attempting to benchmark tokens per successful outcome as a single global KPI across an entire product. A simple, linear task like scraping structured text from a webpage naturally consumes far fewer tokens than an open-ended, highly interactive debugging session investigating a broken responsive design layout across multiple viewport breakpoints.

Presenting an internal evaluation dashboard illustrated with neon progress bars, Hablich explains that each bar represents a specific developer use case, with bar length indicating the operational effectiveness of the interface. Short bars pinpoint workflows where agents struggle or waste tokens, identifying high-priority targets for interface refactoring. Hablich emphasizes that while measuring this metric involves complexity, having directional data is essential: “The thing is, but even an imperfect measurement is better than simply doing gut-driven decisions.”

- **Effectiveness:** Binary verification of whether the user journey was completed and the functional intent achieved. - **Efficiency:** The operational cost required to finish the task, measured in LLM token volume, tool invocation counts, and wall-clock time. - **Tokens per Successful Outcome:** A ratio measuring the interface's "fuel efficiency," valid only when evaluated within specific, isolated task categories rather than globally.

[11:10](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=670s) Three Techniques to Mitigate Token Burn

To reduce token burn and prevent context window exhaustion, the DevTools team implements three distinct tactical approaches: tool categorization, a stripped-down "slim mode," and an alternate CLI surface.

First, the team applies tool categorization to trim the default tool manifest. Specialized capabilities, such as tools dedicated to inspecting and debugging Chrome extensions, are hidden behind explicit command-line flags. Because the overwhelming majority of developers are not building browser extensions, injecting those tool definitions into the default prompt context imposes unnecessary overhead on every invocation.

Second, the team built an aggressive variant called "slim mode," which pushes tool reduction to its extreme by exposing only three primitive operations: `select_page`, `navigate_page`, and `evaluate_script`. While this keeps the initial context footprint remarkably compact, Hablich notes the inherent architectural trade-off: restricting available tools can force the model into redundant intermediate reasoning loops or render certain capabilities impossible. An agent relying solely on `evaluate_script`, for instance, cannot intercept or inspect raw network requests.

Finally, recognizing that different model types and coding agents thrive on different input modalities, the DevTools team offers a dedicated CLI interface alongside the MCP server. This provides nearly identical browser automation and inspection capabilities through scriptable terminal commands, accommodating agent workflows optimized for shell execution rather than structured tool schemas.

- **Tool Categorization:** Hides domain-specific tools (e.g., Chrome extension debugging) behind CLI parameters to keep the default system prompt lean. - **Slim Mode:** Exposes a minimal three-tool surface (`select_page`, `navigate_page`, and `evaluate_script`), trading away specialized observability (like network monitoring) for minimal context consumption. - **Dual MCP/CLI Architecture:** Offers both an MCP server endpoint and a CLI alternative to accommodate different coding agent harnesses and execution models.

[12:43](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=763s) Command Chaining and Self-Healing Error Recovery

Token efficiency can be dramatically improved by allowing agents to chain terminal commands together for local post-processing rather than dumping entire state trees back into the LLM context. In the example Hablich shares, an agent extracts an accessibility tree using a standard `grep` command, filters for the relevant control, and pipes the resulting element ID straight into a `click` command. Because all that intermediate filtering occurs directly on the local machine rather than round-tripping through the model, the token savings are substantial. Yet, as Hablich points out, optimization alone is not enough: “Efficiency is useless if your agent gets stuck.” Every single time an agent hits an unrecoverable wall, it burns through tokens attempting blind retries, hallucinating causes, and trying to parse what went wrong.

To combat this, the team treats error recovery as a spectrum consisting of three distinct layers: 1. **Actionable error messages**: Standard developer error strings are notoriously opaque to an LLM. In an early iteration, when navigation failed, the tool returned: `Unable to navigate back in currently selected page`. The agent had no idea why it failed or what to do next. By appending a concrete explanation—noting that no previous history entry existed—the agent was immediately able to alter its plan and self-heal without needing a human to intervene. 2. **Proactive detours**: Because underlying foundation models are heavily biased by their training corpora, they frequently reach for familiar legacy tools that may not fit modern workflows. When asked to evaluate page performance, agents routinely defaulted to kicking off a slow Lighthouse audit. DevTools MCP implemented proactive detours in tool responses, deliberately nudging the agent away from Lighthouse toward their dedicated `performance.start_trace` profiling tool instead. 3. **Diagnostic playbooks**: Recognizing that environment setup is inherently fragile, the team bundled diagnostic playbooks directly into agent skills. When developers struggle to configure the Chrome DevTools MCP server properly, a dedicated troubleshooting skill automatically detects the failure state and guides both the human and the agent through resolving configuration bottlenecks.

- Performing local operations like piping `grep` outputs into action commands offloads post-processing from the model context to the host machine. - Error recovery is an economic necessity; every failed step forces expensive model retries and context pollution. - Informative error states convert dead ends into deterministic recovery paths, granting agents true self-healing autonomy.

[15:26](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=926s) Tool Discoverability: From Monolith to 25 Tools

The initial architecture for Chrome DevTools MCP attempted to solve debugging with an all-in-one approach: a single monolithic tool called `debug_webpage`. An orchestration agent could call this endpoint with a broad prompt like, *"Hey, debug this webpage. There is some responsive layout that's not working."* While Hablich jokes that it felt elegant from a software engineering standpoint, in practice it fell apart because the model could not reliably reason through or compose multi-step browser interactions inside a single opaque call. In response, the team broke the monolith apart into 25 granular, focused tools. But replacing one design flaw immediately birthed another: “Because we traded that problem off to another. And that was agents now had 25 tools at their disposal. How are you going to find out which one to use when?”

Citing recent research showing that 97% of MCP tool descriptions suffer from "quality smells," Hablich argues that tool schemas must be treated with the same intentionality as graphical interfaces: “The schema is the UI for the agent.” However, rewriting schemas involves delicate trade-offs. Expanding tool descriptions bloats the system prompt, exhausting context windows and introducing token overhead on every turn. Furthermore, smaller models become heavily distracted or biased by verbose documentation, often triggering tools when they should not be touched at all.

To strike the right balance, the DevTools team focuses on two foundational rules: defining an unambiguous core purpose and setting strict activation criteria. For their performance tracing tool, the schema description explicitly highlights that it is used to diagnose front-end performance bottlenecks and Core Web Vitals such as Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). Supplying these explicit acronyms enables the agent to map abstract user requests—like *"investigate why this page load feels sluggish"*—directly to the trace tool. While specialized workflow skills can supercharge complex tasks, Hablich warns they are not a silver bullet; overloading an agent with too many skills merely recreates the discoverability crisis at a higher level of abstraction.

- Moving from one monolithic tool (`debug_webpage`) to 25 modular endpoints shifted the failure mode from inability to compose to tool selection ambiguity. - Research reveals 97% of real-world MCP descriptions contain quality smells that directly confuse agent tool-calling logic. - Verbose descriptions create a prompt tax and risk biasing smaller language models toward calling unnecessary tools. - Effective activation schemas anchor on standardized terminology (such as Core Web Vitals: LCP, INP, CLS) to trigger correct routing.

[18:33](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1113s) Trust Boundaries and the Lethal Trifecta

Chrome DevTools MCP includes a marquee capability called autoconnect, which lets a developer pair an agentic coding assistant (like Claude Code) directly to their live browser session. It essentially mirrors a pair-programming screen share where a stuck developer asks the agent to inspect the page and pinpoint rendering bugs. Almost immediately, users began demanding the removal of confirmation prompts: *"Why do I need to click allow all the time? Please remember my choice."* In standard product design, eliminating repeated permission dialogs is considered an obvious usability win. But in an agentic world where autonomous actors execute commands on behalf of users, Hablich emphasizes that convenience must take a back seat to security boundaries. The friction was preserved intentionally to defend against the security nightmare known as the "lethal trifecta" (a concept popularized by Simon Willison, where private data access, untrusted inputs, and external communication channels collide).

To establish robust safety guarantees, Hablich maps browser agent deployments across three escalating security tiers:

```mermaid flowchart TD accTitle: Browser Agent Security Tiers accDescr: Three-tiered trust hierarchy for browser agents ranging from local developer environments to untrusted web access.

subgraph T1["Tier 1: Local Development"] A["Human in the Loop"] -->|"Time-Bound Explicit Consent"| B["Default Chrome Profile & Session Data"] end

subgraph T2["Tier 2: CI / Controlled Automation"] C["Isolated Headless Fleet"] -->|"Network & State Isolation"| D["Containers & Ephemeral Profiles"] D -->|"Managed Access"| E["Remote Debugging Port"] end

subgraph T3["Tier 3: Full Internet / Autonomous Browsing"] F["Wild Web / YOLO Mode"] -->|"Untrusted Data Injection Risks"| G["Hardened Sandboxes & Domain Allowlists"] end ```

Tier 1 represents the local developer machine where the human remains directly in the loop. Because the agent connects to the user's primary Chrome profile containing authenticated sessions, personal cookies, and sensitive company data, access must be strictly time-bound and require manual consent for every connection. Tier 2 encompasses automated testing and continuous integration pipelines. These controlled, headless environments enforce structural data separation via Docker containers, ephemeral profiles, and dedicated remote debugging ports. Tier 3 is what Hablich candidly dubs "YOLO mode": autonomous agents navigating the open web, where arbitrary third-party pages can launch indirect prompt injection attacks. Tier 3 requires strict network allowlists, sandbox isolation, and aggressive prompt injection defenses. Hablich warns that while a local debugging assistant and a cloud-based web research agent might share underlying tool libraries like Chrome DevTools MCP, they must never share the same security assumptions.

- User requests to remember authorization choices were rejected because agent trust boundaries require explicit human gating. - Simon Willison's lethal trifecta explains the compounding risk when agents combine private browser state with untrusted web content and tool execution. - Local environments (Tier 1) demand time-bound, per-session human consent to protect default browser credentials. - CI environments (Tier 2) isolate execution using ephemeral profiles, containers, and explicit remote debugging ports. - Open-web browsing agents (Tier 3) operate in an untrusted threat landscape demanding strict domain allowlists and prompt injection mitigations.

[21:32](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1292s) Four Core Takeaways for Agent Interfaces

Hablich closes by reframing how software teams must think about software design going forward: user experience is fundamentally widening to encompass "agent experience." AI agents represent a brand-new segment of end users, complete with their own non-functional requirements spanning computational efficiency, discoverability, stability, and system security.

To guide developers building tools, MCP servers, and interfaces for this emerging class of consumers, Hablich summarizes the Chrome DevTools journey into four operational tenets: 1. **Measure fuel efficiency**: Track *tokens per successful outcome* as the primary benchmark for interface design, optimizing payloads so models consume only what is necessary to complete a task. 2. **Turn errors into recovery playbooks**: Write error strings that diagnose the root cause and hand the model actionable next steps, unlocking autonomous self-healing. 3. **Audit descriptions for intent**: Craft tool schemas with precise activation triggers, guarding against ambiguity and context bloat. 4. **Never compromise trust for convenience**: Resist the temptation to strip out security guardrails, permissions, or confirmations for the sake of a frictionless user experience.

He leaves the audience with a guiding imperative for the agentic era: “Agents are our next users. Let's help them help us.”

- Interface builders must treat LLMs as first-class users with distinct operational and cognitive constraints. - Token consumption per completed task provides an objective metric for interface efficiency. - Preserving friction at critical trust boundaries protects users from autonomous privilege escalation and prompt injection vulnerabilities.

## Notable quotes > [15:26](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=926s) The schema is the UI for the agent. — Michael Hablich

> [12:43](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=763s) Efficiency is useless if your agent gets stuck. — Michael Hablich

> [21:32](https://www.youtube.com/watch?v=_B4Pv9ttFgY&t=1292s) Agents are our next users. Let's help them help us. — Michael Hablich

## Mentioned Michael Hablich, Google, Chrome DevTools, Model Context Protocol (MCP), Gemini CLI, Claude Code, Codex, OpenClaw, Matt, Core Web Vitals, Simon Willison, Lighthouse, Docker

## Video description Chrome DevTools MCP shipped with one tool: debug_webpage. Agents failed silently because they couldn't compose behaviors. The team decomposed it into 25 focused tools and assumed the problem was solved. It wasn't — now agents had 25 tools and no reliable way to pick the right one. Michael Hablich's talk is an honest account of building the same thing wrong three times and what the fixes actually looked like.

The concrete lessons: semantic summaries instead of raw 50,000 line JSON trace files, error messages rewritten so agents can self heal without a human in the loop ("Cannot navigate back, no previous page in history" instead of "Unable to navigate back in currently selected page"), a metric called tokens per successful outcome to measure interface fuel efficiency, and a deliberate decision to keep the autoconnect friction rather than remove it once they thought through prompt injection and the lethal trifecta.

Speaker info: - https://x.com/MHablich - https://www.linkedin.com/in/michael-hablich/

---

Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/_B4Pv9ttFgY-building-agent-interfaces-lessons-from-chrome-devtools-mcp-for-agents

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

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

---

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

Reading summary

Drawing on Google's development of the Chrome DevTools Model Context Protocol (MCP) server, Product Manager Michael Hablich argues that autonomous agents represent a distinct user class requiring purpose-built interface designs that prioritize token efficiency, discoverability, self-healing error recovery, and uncompromising security boundaries. Semantic Summaries Replace Context-Saturating Raw Data (3:31) Early in development, the Chrome DevTools team operated under the mistaken assumption that autonomous coding agents could seamlessly ingest raw, low-level data because they are machines. Feeding standard browser performance traces—often spanning multiple megabytes and upwards of 50,000 lines of JSON—quickly saturated model context windows, degrading language model reasoning into what was described as the 'dump zone.' To counteract this failure mode, the DevTools team restructured agent-facing outputs to prioritize concise Markdown summaries that highlight Core Web Vitals such as Largest Contentful Paint (LCP) and Interaction to Next Paint (INP), rather than forcing models to parse raw trace events. Optimizing Fuel Efficiency and Token Consumption (8:09) To evaluate agent interface design, Hablich proposes the metric 'Tokens per Successful Outcome.' He emphasizes that measuring efficiency is meaningless without verifying task completion, and cautions against attempting to track this metric as a single global KPI across an entire application, since task complexity varies dramatically. Internal evaluations track this ratio across isolated developer workflows to identify interface bottlenecks and guide refactoring. To limit token burn, the team deployed three practical strategies: categorizing tools to hide niche capabilities like Chrome extension debugging behind CLI flags; offering a 'slim mode' that exposes only three core primitives (`select_page`, `navigate_page`, and `evaluate_script`), accepting that specialized observability like network monitoring is lost; and providing a scriptable CLI interface alongside the MCP server. Furthermore, allowing models to perform local command chaining—such as piping `grep` element filtering directly into a `click` command—prevents intermediate UI states from round-tripping through the LLM context. Tool Discoverability and Self-Healing Recovery (12:43) Interface complexity shifted when the team abandoned an opaque, monolithic `debug_webpage` tool in favor of 25 modular endpoints, which introduced tool-selection ambiguity. Citing research indicating that 97% of real-world MCP descriptions contain 'quality smells,' Hablich notes that schema descriptions serve as the agent's user interface. However, overly verbose schemas bloat system prompts and bias smaller models toward unnecessary tool calls. The team resolved this by focusing descriptions on unambiguous purposes and explicit activation criteria, anchoring tools to established terminology like Core Web Vitals. When execution stalls, uninformative errors waste tokens on blind retries. The team structured error handling into actionable messages that explain underlying causes (such as clarifying that navigation failed because no browser history exists), proactive detours that nudge models away from legacy routines like Lighthouse toward dedicated trace endpoints, and automated diagnostic playbooks designed to resolve server configuration errors. Maintaining Security Friction Against the Lethal Trifecta (18:33) Despite user requests to remove repetitive authorization prompts in the autoconnect feature, the DevTools team intentionally preserved confirmation friction to mitigate Simon Willison's 'lethal trifecta'—the compounding hazard where an agent simultaneously accesses private data, untrusted inputs, and external communication channels. To enforce security, browser agent deployments are segmented into three operational tiers with distinct trust models. Tier 1 covers local development with human-in-the-loop oversight, requiring time-bound, explicit user consent to access personal profiles and authenticated cookies. Tier 2 governs automated testing and continuous integration fleets, relying on isolated Docker containers, headless environments, and ephemeral profiles accessed via remote debugging ports. Tier 3 addresses autonomous open-web browsing, an untrusted operational space where agents risk indirect prompt injection, requiring hardened sandboxes and strict domain allowlists. Hablich concludes that software teams must expand traditional user experience into 'agent experience,' balancing lean token consumption against the need for rich diagnostic signals. As interface schemas become the primary UI for autonomous systems, preserving deliberate friction at critical security boundaries remains essential even when users demand operational convenience.

Source quotes

[15:26] Michael Hablich: The schema is the UI for the agent. [12:43] Michael Hablich: Efficiency is useless if your agent gets stuck. [21:32] Michael Hablich: Agents are our next users. Let's help them help us.

Original transcript

[0:07] [music] [0:15] >> Let's get started in in in interest of [0:17] time, right? [0:20] So, hi. Welcome. Let's talk about [0:22] building agent interfaces today. So, let [0:24] me start with a question first. Who in [0:27] here is already using MCP servers or CLI [0:30] tools on your [0:32] uh [0:33] agent Okay, everybody? That is [0:34] unsurprising, to be honest. [0:37] Um who in here have already built MCP [0:40] servers and deployed them for effect? [0:43] Okay, it's approximately half of the [0:44] people. [0:46] Well, today I'm going to share four [0:48] engineering lessons from the Chrome uh [0:50] DevTools team on how we build Chrome [0:52] DevTools for agents [0:54] and how we deployed it for effect. [0:57] Quick context setting. [0:58] Chrome DevTools for humans is used by [1:00] millions of web developers on a daily [1:02] basis to [1:04] debug web pages. It's directly built [1:06] into Chrome and developers use it to [1:08] debug web pages. Find errors, audit it, [1:10] performance profile it, and so on and so [1:12] on. [1:13] Uh [1:14] right. So, now let's talk a little bit [1:16] more about Chrome DevTools for agents. [1:18] So, this is a purpose-built [1:21] Chrome DevTools, but for agents. How [1:23] surprising. [1:24] Um yeah, let me briefly show you how it [1:27] works. [1:28] So, you can see on the left side Gemini [1:30] CLI and the prompt is being entered, and [1:33] now uh Gemini CLI has the MCP server [1:36] being configured, and that opens Chrome [1:38] on the right side, and then does [1:40] debugging. I think yes, this is about [1:42] performance tracing. So, it does a [1:43] performance trace, analyzes the trace [1:45] that comes back or the performance [1:47] insight, [1:48] acts on it, and then makes the web page [1:50] faster, uh [1:52] validates that it's actually faster [1:53] afterwards, [1:55] and it's done. You should be done now. [1:58] It's nearly done. [1:59] Sorry, it's the video. [2:01] Whatever. What I wanted to tell you is [2:03] like, yeah, this is going to work in any [2:05] MCP client and uh agent harness that is [2:08] MCP capable. Doesn't really matter. That [2:09] was Gemini CLI, also works in Cloud [2:11] Code, [2:13] Codex, Open Claw, doesn't matter. [2:17] If you want to have more information, go [2:18] to this QR code [2:20] because that QR code is going to uh [2:22] bring you to a web page, and [2:24] that's going to tell you everything [2:25] about how you can install it, configure [2:27] it for your agent harness. [2:30] Question again. Who in here has already [2:32] tried it out? [2:35] Okay, so 10%? [2:37] Thank you. [2:38] I love you. I also love everybody else, [2:40] but [2:41] I love the others more. [2:44] So, I was rude. I didn't introduce [2:45] myself. Uh my name is Michael Hablich. I [2:48] am the product manager for Chrome [2:50] developer tools uh at Google. [2:53] And I'm also a guest lecturer at the [2:55] university near nearby where I'm living. [2:58] I have 20 years of experience in tech, [3:00] developer, tester, QA engineer, project [3:04] manager, product manager, program [3:06] manager, and so on. [3:08] If you have questions afterwards, please [3:10] talk with me in the hallway track or uh [3:13] connect with me over LinkedIn. Uh the QR [3:15] code will bring you to my LinkedIn page. [3:18] Both is fine. [3:19] Uh please do that. I would be super [3:21] interested to talk with you about MCP [3:23] servers, browser automation tools, and [3:25] stuff like that. [3:26] Okay, but now enough advertisement. [3:29] Let's move on. [3:31] We ship Chrome DevTools because [3:33] we saw that coding agents were flying [3:35] blind. So, like 1 and 1/2 years ago, [3:37] they were very good with generating [3:39] code, but [3:40] they were not able to validate what they [3:42] actually were doing, right? [3:44] And that just sucked. [3:46] But we assumed [3:48] they are going to be fine if we throw a [3:50] lot of data at them. [3:52] Because I mean, they are machines, [3:53] right? The thing is, we were wrong. So, [3:55] this is a [3:56] uh [3:58] This is the head [3:59] of a trace file. A trace file it has all [4:03] the data about the performance profile. [4:07] And this is a file like multiple [4:08] megabytes of data, and this is like [4:10] 50,000 lines of JSON, and we did throw [4:13] that against common agent harness at [4:14] that point, like 1 and 1/2 year ago, [4:16] something like that. [4:18] And without surprise, this is too much [4:20] data for an agent for a model to [4:22] actually reason about, and it blew [4:24] through the context window. [4:25] And if you have seen Matt's talk about [4:27] the dump zone, [4:30] you are moving the agent into the dump [4:31] zone at that point. So, I thought, okay, [4:33] we built it wrong. That's not going to [4:34] work. We need to do something else. So, [4:36] in that case, for example, what we did, [4:38] our performance tracing endpoints, [4:41] it can also return that for [4:42] post-processing [4:44] uh with other tools, but what it's [4:46] really doing is it's returning markdown [4:48] now and semantic summaries. Like, this [4:51] is a example of a such a semantic [4:53] summary, which just gives you [4:54] information about typical performance [4:56] metrics like largest contentful paint, [4:59] IMP, and so on and so on. I'm not going [5:01] to bore you about all the [5:03] uh performance metrics. And we are going [5:04] to talk about them anyway because they [5:06] are a very good example of how this is [5:08] uh working. [5:10] Well, essentially, we didn't force the [5:12] agent to read the entire book, the [5:14] trace, but instead we just pointed it at [5:16] the right sentence, and this is the [5:18] semantic summary. [5:19] That works quite well. [5:24] In the end, [5:25] uh or in the beginning, agents are a [5:27] different user class. So, that's where [5:29] when it's kind of like it clicked for [5:30] me, like, ah yeah, they are kind of like [5:32] a separate user segment. So, how do we [5:34] reason about that? [5:36] The thing is, agents and humans, [5:38] they share the intent, they share the [5:40] goal, right? In our case, for example, [5:43] both want to identify errors in a page [5:45] and want to fix those errors. [5:48] But they think differently. [5:50] They have different cognitive [5:52] bottlenecks, more or less. [5:54] For humans, it's a lot about visual [5:55] complexity. [5:57] So, humans are very typically very [5:59] visual uh creatures, [6:02] and we need layout, we need color in [6:04] order to find a signal. And this might [6:06] not be the best example for uh [8:09] efficiency. [8:10] Uh sounds very happy, [8:12] and maybe it is. I don't know. [8:15] Um [8:17] What is it about? So, effectiveness [8:19] is about does the agent complete the [8:21] entire user journey? [8:23] Is the functional intent actually [8:25] fulfilled? Yes or no. [8:28] And then there's efficiency, which [8:30] unsurprisingly is about token cost, tool [8:33] calls, duration. [8:36] In the end, [8:38] what tokens per successful outcome tell [8:40] you is [8:41] the fuel efficiency of your interface, [8:44] right? [8:45] And there's a caveat [8:47] because there's always a caveat. [8:49] Fuel efficiency is relatively worthless [8:52] if you can't reach your destination. So, [8:53] that's why it's called tokens per [8:56] successful outcome and not token per [8:58] outcome. So, make sure that you actually [9:01] also measure effectiveness, right? [9:05] And there's one more caveat. [9:06] And this is [9:10] you can't measure that globally. I mean, [9:12] you can do that, but you [9:13] maybe you want to do that because it's a [9:15] nice metric, [9:17] but it's going to be tremendously [9:20] different between different user [9:21] journeys and task classes. So, [9:24] don't compare them globally, compare [9:26] them within your user journey that [9:28] they're measuring that. [9:29] Uh and what I mean with that is like, [9:31] for example, in Chrome DevTools, we have [9:32] the user journey of web scraping, right? [9:35] So, an agent going to website and [9:37] extracting information. [9:39] That's relatively cheap. [9:41] But there's also user journeys that are [9:42] more intricate like debugging a website, [9:45] finding out why the responsive layout is [9:47] not working. [9:49] That thing is going to use more tokens, [9:51] but that is fine because it's a much [9:53] more much more [9:55] intricate uh and more interactive [9:57] session that's happening. [10:01] Okay, how does this look like in real [10:02] life? Uh, [10:03] this is what it looks like in practice [10:05] and for a project from the internal [10:06] project that we're working on, and you [10:09] see a lot of neon bars, which is great. [10:11] I like neon bars. [10:13] But, I am not going to worry about [10:14] details. The important thing is the neon [10:16] bars on the left side, [10:18] the longer the bar, the more effective [10:20] the tool. [10:21] Right? [10:23] The shorter the bar, the less effective [10:25] the tool for the particular use case. [10:26] So, each of those bars on the left side [10:28] are about use cases. [10:30] Uh, which means [10:32] the smaller bars are probably the ones [10:34] that we should be focusing on our work [10:36] next, how to improve that, how to [10:38] improve the tokens per successful [10:39] outcome there. [10:42] Yeah. [10:43] Uh, [10:43] as you might have already guessed, [10:45] measuring tokens per successful outcome [10:46] is not straightforward. [10:49] The thing is, but even an imperfect [10:51] measurement [10:52] is better than simply doing gut-driven, [10:55] um, [10:56] decisions. [10:57] And with that, at least you can do [10:59] data-informed decisions. [11:03] Right. [11:07] Ian, sorry. Uh, [11:08] I had my audio on. [11:10] In DevTools for Agents, we're [11:12] addressing, uh, token burn from three [11:14] different three different angles. [11:16] First, there's tool categorization. So, [11:20] very straightforward, we hide hide niche [11:22] niche tools behind command line [11:24] parameters. Like, for example, uh, we [11:27] have tools for Chrome extension [11:28] debugging. [11:31] And not everybody is developing Chrome [11:33] extensions. So, why add it to the [11:35] default context menu? There's no point [11:36] in doing that. [11:38] Then there's a slim mode. [11:41] And this one is fun. So, what slim mode [11:43] is doing is like, uh, pushing tool [11:45] categorization to its limits. It's only [11:47] exposing I think three different tools. [11:50] Select page, navigate page, and evaluate [11:52] script. [11:54] And this is great for your context [11:56] window, but there's a trade-off. I'm [11:58] going to talk about a lot about [12:00] trade-offs today. Um, [12:01] there's a trade-off [12:03] because the less tools you expose, the [12:05] less tools are also at the disposal for [12:08] a for your agent harness, which means [12:09] your agent might do extra turns to [12:11] achieve the same goal. It might not [12:14] actually have the right tools at the [12:15] disposal to actually do something, like [12:17] for example, getting network requests. [12:18] You can't do that with evaluate script. [12:21] And stuff like that. [12:23] Yeah, and there's also a CLI interface. [12:25] Uh, sorry, there's a command line [12:26] interface that we're offering. Uh, you [12:28] have seen the previous talk maybe about [12:31] a code model and all that stuff. We also [12:33] support that. So, it is a MCP server, [12:35] yes, but there's also, uh, [12:37] a command line interface for the same [12:39] thing, giving you nearly the same [12:40] functionality. [12:41] What it enables you, [12:43] you can have your agent chain commands [12:45] together to do post-processing. Like in [12:47] this example, I don't think you can see [12:48] it. Um, [12:51] the accessibility tree is extracted with [12:52] a with a grep [12:54] uh, command, and then the result, the ID [12:57] of the control is being piped into a [12:58] click command. And that is, of course, [13:00] saving a lot of tokens [13:03] doing that [13:04] because the model doesn't need to [13:05] process all the tokens. The token [13:08] post-processing is happening on your [13:10] computer. [13:12] Right. [13:13] Um, [13:14] efficiency is useless if your agent gets [13:16] stuck. So, that brings us to error [13:19] recovery. [13:20] And [13:22] yeah, because every time your your agent [13:26] encounters an error, [13:28] it's going to cost you tokens [13:30] because it needs to retry, it needs to [13:32] understand what is happening and stuff [13:33] like that. And that just sucks. [13:37] Oh, yeah. [13:40] Error recovery is a spectrum, and let's [13:42] talk a little bit about that, what we [13:43] are doing here. So, first, of course, [13:46] you should add [13:48] uh, useful error messages. That sounds [13:50] obvious. [13:51] Uh, for a lot of tools, it isn't. [13:54] And it was also not obvious for all the [13:55] tools that we actually offered, so we [13:56] also did, uh, a few iterations on them [13:59] to actually make the make the error [14:00] messages good. Like here, for example, [14:03] uh, an unable to navigate back in the [14:04] selected page for a particular tool [14:06] history entry to navigate, [14:09] uh, was not found. We actually added the [14:10] last sentence, and that enabled the [14:12] agent to self-heal, which is super [14:14] useful because then the agent doesn't [14:15] need a human to actually fix the [14:17] problems, but the agent can, uh, [14:18] self-fix the problems. [14:20] Then there's proactive detours. So, [14:23] beneath each of the agents, there's a [14:25] model, and the model is being trained on [14:27] certain data. [14:29] And sometimes, the, [14:32] there are things where you [14:35] want to counteract the training data. [14:37] And that's what you can do with [14:38] proactive detours. Like in this example, [14:40] um, we detour the agent for performance [14:44] profiling to our start performance trace [14:46] tool and not to the Lighthouse audit. [14:49] And there's diagnostic playbooks. Uh, [14:52] so, we also offer, uh, skills, of [14:54] course. And we have a skill that's [14:56] called, uh, troubleshooting, and we see [14:59] a lot of people have problems setting up [15:01] the Chrome DevTools MCP server [15:03] correctly, and that troubleshooting [15:04] skill is then going to kick in and help [15:06] the human and the agent to [15:09] fix the setup issues. [15:11] Again, enabling self-healing [15:14] of the agent. [15:16] And all of this increases the resilience [15:18] of your product, uh, of the agent [15:20] harness that you're building. And this [15:22] is [15:23] nice and helps you with telling the [15:25] mistakes. [15:26] And now, let's talk about [15:28] discoverability, which is about actually [15:29] preventing them. [15:31] So, our initial design had one [15:34] monolithic tool called debug webpage. [15:36] So, we only had one tool, debug webpage. [15:39] And you could the another agent could [15:41] send a prompt there and tell it, "Hey, [15:43] debug this webpage. There are some [15:45] responsive layout that's not working." [15:47] And it was neat from an engineering [15:48] perspective, but it didn't really work. [15:51] Uh, so, we decomposed it into 25 [15:53] different tools. And did we solve the [15:55] problem? Did we solve it? Of course, it [15:56] wasn't. [15:58] Because we traded that problem off to [16:00] another. [16:01] And that was [16:03] agents now had 25 tools at their [16:04] disposal. How are you going to find out [16:06] which one to use when? [16:09] Well, let's talk about that. [16:12] According to this paper here, [16:14] uh, 97% of MCP tool descriptions have [16:17] quality smells. [16:19] And this matters because [16:21] the schema is the UI for the agent. So, [16:24] let's make the UI better. [16:26] And [16:28] fixing this is a trade-off, as I said. [16:30] It's always a trade-off. [16:32] Because, of course, you can make the [16:33] descriptions better, and that's going to [16:34] increase your context window size. So, [16:36] you probably don't want to have that. Or [16:38] maybe you want. [16:40] And also, smaller models in particular [16:42] are not that good with more descriptions [16:45] because they get biased in using tools [16:46] they shouldn't be using in the first [16:47] place. [16:48] There's a trade-off space. [16:50] Uh, read the paper. Super interesting. [16:52] Uh, [16:53] yeah. But, there are a few things you [16:55] actually should be doing that are [16:56] relatively uncontroversial, and that is, [16:59] um, [17:01] define purpose. [17:04] Clearly explain how what the tool core [17:06] function is. Is this working? Ah, yeah. [17:08] Here it is. [17:10] Come on. [17:11] Yes. Ah, it's a [17:13] Okay. Clearly explain the tool's core [17:15] function, and there's usage guidelines, [17:17] like provide clear activation criteria. [17:21] And how does it look like in, uh, Chrome [17:23] DevTools for Agents, for example? And, [17:26] uh, [17:27] again, performance start trace tool. [17:30] What we have in there as a as a [17:32] description is used to find performance, [17:34] uh, front-end performance issues and [17:35] core web vitals, LCP, INP, CLS. Why is [17:38] this relevant? LCP, INP, CLS are web [17:41] performance metrics, and an agent is [17:42] able to make the connection, "Oh, I'm [17:44] going to use that tool if I need to, uh, [17:46] improve page load, for example." [17:49] We are far from finished optimizing that [17:51] because models and agent harnesses also [17:53] keep on, uh, changing all the time, so [17:55] it's kind of like an endless quest for [17:57] minimum viable description. [18:00] Yeah, but it is what it is. [18:03] You can supercharge all of that with [18:04] skills. As I said, we also have skills, [18:06] and that is great, [18:07] uh, in particular if you have more [18:08] intricate workflows. [18:10] But again, there's a trade-off. [18:12] They are not free lunch. [18:14] If you pile in too many skills, uh, [18:16] you're going to [18:18] to shift the problem and run into the [18:20] same problem again. [18:21] Uh, [18:23] agents are going to [18:24] call your skills even if they shouldn't [18:26] be calling them. [18:28] Uh, your context window size is going to [18:29] increase and all that stuff. The [18:30] trade-off is shifting, it's not [18:31] disappearing. [18:33] Okay, now we have optimized for cost, [18:34] recovery, and discovery. Let's now talk [18:36] a little bit about trust because [18:39] you don't want to have a backdoor into [18:40] the system. [18:43] Chrome DevTools for Agents has a feature [18:44] called autoconnect, and it's kind of [18:46] like it lets you, the human, using your [18:50] coding agent, like Claude Code, [18:52] share the screen with the agent, like, [18:54] "Hey, I'm stuck here. Uh, please help me [18:56] debugging the debug that and fix the [18:58] problem that I'm seeing here." [19:00] Amazing feature. I really like it. Um, [19:05] and users, of course, [19:07] requested the feature, "Hey, why do I [19:09] need to click allow all the time? I [19:11] don't want to do that. Please remember [19:12] my choice." And in a traditional user [19:15] experience design, that would have been [19:16] a clear win, right? Because it's just [19:18] fixing the friction that you want to [19:19] remove. [19:20] In a world where you are delegating away [19:23] work to agents and automating away [19:26] agents, you need to think about trust [19:27] boundaries. [19:29] And so, that's why we actually designed [19:32] it, uh, with so that friction is [19:34] actually by design because we didn't [19:35] want to have that. And why? Let's talk [19:37] about that. [19:39] There's a blog post from, uh, Simon [19:41] Willison [19:42] about the lethal tri factor. [19:44] QR code. You should read it, it's great. [19:47] Uh, I'm not going to talk more about [19:49] that. [19:52] And utilizing that, there is a free uh, [19:54] at least three tiers that I'm thinking [19:56] about in browser a browsing agents more [19:59] or less. You have tier one and that is [20:01] the local development environment. In [20:03] the local development environment, you [20:04] have the human in loop and the human [20:05] wants to grant access to the default [20:07] Chrome profile to the data that you [20:08] already have access to uh to the agent [20:10] in a [20:12] time bound manner. And then you have uh [20:15] tier two and tier two is uh agents [20:17] running in continuous integration [20:19] environment. So, it's controlled [20:20] environments, but they're separated [20:21] away. At that point, you should be using [20:24] data separation things like containers, [20:25] of course, but also other things like [20:28] separate Chrome profiles and stuff like [20:30] that. [20:31] Um if you want to connect to them, we [20:33] also have a mechanism for that and that [20:35] is called uh remote debugging port. [20:38] And third, there's agents with full [20:40] internet access and that is YOLO mode [20:42] essentially because every webpage out [20:45] there [20:46] is able to do some prompt check chain [20:48] text to your agent. So, make sure that [20:50] it do the same thing as in tier two, but [20:53] also in tier three, [20:55] uh make sure that they have the domain [20:56] allow list and don't prompt injection [20:59] mitigations, all that stuff together. [21:02] Going back to the leaf trajectory [21:04] factor, that's what we mostly reason [21:05] about uh [21:07] tier one and that's where all those [21:08] three things are coming together. So, [21:09] that's why we actually say no, the human [21:11] actually need to consent every time. [21:14] Key point being is a local agent, tier [21:17] one, and a browsing agent fleet, tier [21:20] three, where you're research agents [21:21] maybe, might share a tool like Chrome [21:23] DevTools for agents, but they shouldn't [21:25] share nothing else else about your [21:27] security model that you're having, [21:29] right? [21:30] Okay. [21:32] Let's Let me wrap it up. User experience [21:34] is evolving to incorporate agent [21:35] experience. [21:37] An agent is just another type of user, [21:40] segment of user, also with [21:41] non-functional requirements. [21:44] Efficiency, discoverability, security, [21:47] stability, and so on and so on and so [21:48] on. [21:50] I shared four takeaways from Chrome [21:52] DevTools for agents. [21:53] Um when we are implement while we are [21:56] implementing that, that is measure fuel [21:58] fuel efficiency of the interface with [22:00] tokens per successful outcome. [22:02] Turn errors into recovery playbooks. [22:05] Audit descriptions for intent and never [22:07] compromise trust for convenience. [22:10] Agents are our next users. [22:13] Let's help them help us. [22:15] And with that, I wish you a nice [22:17] remaining conference. [22:20] >> [applause] [22:27] [music] [22:32] [music]