Michael Hablich on Agent Interfaces and Chrome DevTools

Michael Hablich, a Product Manager at Google focused on Chrome Developer Tooling, shared insights on building agent interfaces, drawing parallels with the development of Chrome DevTools. Speaking at AI Engineer Europe, Hablich highlighted how the established principles and user experience considerations of developer tools can inform the creation of effective interfaces for AI agents.

Understanding Agent Interfaces

Hablich began by posing a question to the audience: "Who in here is already using MCP server or CI tools on your ... agents?" He noted that roughly half the audience raised their hands, indicating a familiarity with such tools. He then stated his intention to share lessons learned from the Chrome DevTools team on building interfaces for agents, emphasizing that agents represent a different user class compared to humans.

He explained that Chrome DevTools are used by millions of developers daily to debug web pages. These tools, integrated directly into Chrome, allow developers to find errors, analyze performance, and inspect web pages. The core idea is that agents, like developers, need tools to understand and interact with systems, but their needs and cognitive processes differ significantly.

Lessons from Chrome DevTools for Agents

Hablich presented a framework for thinking about agent interfaces, emphasizing three key concerns: token burn rate, error recovery, and tool discoverability. He introduced the concept of TPSO, or Tokens per Successful Outcome, as a crucial metric. This metric balances the effectiveness of an agent (achieving its goal) with its efficiency (resource consumption, measured in tokens).

He illustrated this with a practical example using a performance trace, showing how detailed data can be processed. Hablich contrasted the human-centric approach of Chrome DevTools, which relies on visual complexity and layout, with the needs of agents, which require clear schema and data density. He demonstrated how the same performance data could be presented in a raw trace file versus a more digestible, summarized format for an agent.

Key Concerns and Trade-offs

Hablich delved into specific concerns when designing for agents:

• Tokens are Cognitive Load: Just as humans experience cognitive load with complex interfaces, agents can be overwhelmed by excessive data. The output of an agent is measured in tokens, and each token has a cost. Therefore, presenting information efficiently is paramount.
• Error Recovery: Agents, like humans, can encounter errors. The presentation showed a "dead end" scenario, highlighting the need for robust error handling. Hablich emphasized that simply displaying a failure message is insufficient; agents require mechanisms to explain the reason for failure and potentially self-heal or recover. He mentioned the importance of providing useful error messages and enabling agents to debug themselves.
• Tool Discoverability: The presentation illustrated how tools are categorized, with specialized tools often hidden behind flags or advanced settings. For agents, discoverability is crucial, and Hablich suggested streamlining this by categorizing tools and making the core functions easily accessible while keeping niche tools more discoverable through specific commands.
• Trust Boundaries: As agents gain more capabilities, establishing trust is essential. Hablich referenced a blog post about the "lethal trifecta" and discussed tiered trust models. In a local development environment (Tier 1), where humans are in the loop and have access to local data, trust is higher. In CI/CD environments (Tier 2), with data separation and dedicated profiles, trust is managed. For agents with full internet access (Tier 3), stricter controls like allowlists and prompt injection risk mitigation are necessary.

The Evolution of Agent Experience

Hablich concluded by emphasizing that agent experience is becoming an integral part of overall user experience. As AI agents are integrated into more workflows, the design of their interfaces needs to be as thoughtful and user-centric as human-facing applications. He summarized the key takeaways as measuring fuel efficiency with TPSO, turning errors into recovery playbooks, auditing descriptions for intent, and never compromising trust boundaries.