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

Michael Hablich, Product Manager for Chrome DevTools at Google, delivers an honest, iterative account of building Chrome DevTools for Agents — a purpose-built MCP server that enables coding agents to debug, audit, and performance-profile web pages. The talk distills four core engineering lessons learned from shipping the same product wrong multiple times.

The first lesson concerns interface fuel efficiency. The team initially assumed that feeding agents raw performance trace files — 50,000-line JSON documents spanning multiple megabytes — would suffice because agents are machines. In practice, this blew through context windows and pushed agents into what Hablich calls the 'dump zone.' The fix was replacing raw trace data with markdown-formatted semantic summaries covering core web vitals such as Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). The insight: agents should be pointed at the right sentence in a book, not forced to read the entire book. To quantify interface quality, Hablich introduces the metric tokens per successful outcome — the fuel efficiency of an agent interface. He emphasizes two caveats: effectiveness (whether the agent actually completes the user journey) must be measured alongside efficiency, and the metric must not be compared globally across task classes because intricate workflows like responsive layout debugging legitimately cost more tokens than simple web scraping.

The second lesson addresses error recovery as a spectrum. Hablich walks through how a vague error like 'Unable to navigate back in currently selected page' was rewritten to 'Cannot navigate back, no previous page in history,' adding enough context for the agent to self-heal without human intervention. The team also implemented proactive detours — tool-description-level redirects that counteract model training biases, steering agents toward the start_performance_trace tool rather than defaulting to Lighthouse — and diagnostic playbooks embedded as skills for common setup failures.

The third lesson covers discoverability. Chrome DevTools for Agents began with a single monolithic tool called debug_webpage. The team decomposed it into 25 focused tools, then discovered that 25 tools created a new selection problem. Hablich cites a paper finding that 97% of MCP tool descriptions have quality smells. The fix requires schema-as-UI thinking: each tool description must define its core purpose and provide clear activation criteria. For example, the start_performance_trace tool description explicitly names LCP, INP, and CLS so agents can correctly infer when to invoke it. The team also introduced tool categorization (hiding niche tools like Chrome extension debugging behind CLI flags), a slim mode exposing only three tools for context-window-sensitive deployments, and a CLI interface enabling agent command chaining with grep and pipe operations to handle token post-processing on the client machine rather than in the model.

The fourth lesson is about trust. The autoconnect feature — which lets a human share an active browser tab with a coding agent — prompted user requests to persist the allow choice and remove friction. Hablich refused, citing Simon Willison's 'lethal trifecta' of prompt injection risk. He outlines a three-tier security model: Tier 1 (local dev environment with human in the loop, time-bounded access to the user's default Chrome profile), Tier 2 (CI/CD environments using data separation, containers, and separate Chrome profiles accessed via remote debugging port), and Tier 3 (agents with full internet access where every webpage is a potential injection vector, requiring domain allowlists and prompt injection mitigations). The key principle is that a local agent and a browsing agent fleet may share the Chrome DevTools MCP server tool but must never share the same security model.

Hablich closes by reframing agents as a distinct user class with their own non-functional requirements — efficiency, discoverability, security, and stability — and positions UX design as evolving into AX (agent experience) design.