Google's Michael Hablich reveals four engineering lessons for building agentic interfaces

For decades, software development centered on the human interface. We focused on visual hierarchies, color theory, and reducing cognitive load for biological users. However, Michael Hablich, Product Manager for Chrome DevTools at Google, argues that we must now design for a new class of user: the autonomous agent. These agents share our goals—like debugging a web page—but possess entirely different cognitive bottlenecks. While humans struggle with visual clutter, agents struggle with context window saturation and token overhead.

Optimizing for fuel efficiency with tokens per successful outcome

Traditional performance metrics focus on latency or throughput. In the world of Model Context Protocol (MCP) servers, Hablich introduces a more critical metric: tokens per successful outcome. This represents the "fuel efficiency" of an interface. It is not enough for an agent to complete a task; it must do so without burning through thousands of unnecessary tokens on raw data dumps.

Initially, the Chrome DevTools team attempted to feed agents raw performance trace files. These files, often exceeding 50,000 lines of JSON, immediately pushed models into the "dump zone," where reasoning fails. The solution was a move toward semantic summaries. By providing high-level markdown summaries of performance metrics like LCP and INP instead of raw telemetry, the team enabled agents to pinpoint issues without reading the entire "book" of data.

Designing for autonomous error recovery and self-healing

When a human encounters an error, they interpret the context and adjust. When an agent hits a generic error message, it often gets stuck in a retry loop that drains resources. Hablich emphasizes turning errors into proactive recovery playbooks. For example, changing an error from a vague "Unable to navigate back" to a descriptive "Cannot navigate back, no previous page in history" provides the agent with the necessary context to self-heal. This subtle shift in schema design allows the agent to pivot its strategy without requiring human intervention, significantly increasing the resilience of the agentic workflow.

The paradox of tool discoverability and description smells

There is a common trap in building Model Context Protocol servers: the monolithic tool vs. tool sprawl. The Chrome DevTools team first tried a single debug_webpage tool, which was too broad for the model to use effectively. They then decomposed it into 25 specialized tools, only to find that agents couldn't identify which tool to use.

Hablich points to research showing that 97% of tool descriptions suffer from "quality smells." To fix this, descriptions must act as the UI for the agent. This involves defining a clear purpose and providing specific activation criteria. However, there is a trade-off: overly verbose descriptions bloat the context window. Finding the "minimum viable description" is an ongoing challenge as models continue to evolve.

Prioritizing trust over convenience in a prompt-injection world

In standard UX design, friction is the enemy. In agentic design, friction is often a security requirement. Hablich warns against the "lethal trifecta"—a term coined by Simon Willison—where agents with high privileges are exposed to untrusted data.

Even though users requested an "auto-allow" feature for screen sharing with tools like Claude Code, the Chrome DevTools team intentionally kept the manual consent requirement. In a landscape where every website could contain a malicious prompt injection, maintaining strict trust boundaries between the local development environment and the open web is the only way to prevent agents from becoming unintentional backdoors.