Key Takeaways

  • Modal's SDK team pivoted from Developer Experience (DX) to Agent Experience (AX), recognizing that AI agents are now the primary consumers of infrastructure.
  • Just as developers hated complex Kubernetes YAML, agents shouldn't have to either. Akshat Bubna, Modal's CTO, argues infrastructure should be accessible via simple code decorators.
  • Observability has become paramount. Bubna states that understanding what agents are doing through dashboards and CLIs is now more critical than directly reviewing their code.
  • Modal built "modal bench," a benchmark specifically to identify agent pain points, then added product features like simple CLI commands to close those gaps.

The DevX Playbook, Rerunning for AI Agents

For the last decade, companies raced to simplify developer experience. They abstracted away Kubernetes, built self-provisioning runtimes, and packaged complex operations into simple code decorators. Now, Akshat Bubna, CTO of Modal, says it's time to do it all again, but this time for AI agents.

Modal initially made its name by abstracting infrastructure complexity, letting developers provision runtimes through a few lines of Python. “We've actually changed our SDK team to think about agent experience instead of developer experience,” Bubna explained. The logic is simple: if a human developer shouldn't have to read hundreds of Kubernetes YAML files, why should an AI agent?

Bubna argues that the same benefits that applied to DX apply to AX. “Why would you have an agent read through hundreds of Kubernetes files and like write YAML that's not even typed when it can basically make a couple changes in a decorator and it gets this sort of self-provisioning runtime?” The goal is to “collocate the infrastructure requirements to the code that runs it,” as swyx noted, making the agent's interaction with the backend as seamless as possible.

This isn't just a philosophical shift for Modal; it's a product mandate. They've identified where agents are lacking, even building an internal benchmark called "modal bench" to surface these pain points. The result? Adding new "surface area" to the product, often in the form of simple CLI commands, to meet agent needs directly.

Observability: The Agent's User Interface

With agents increasingly operating autonomously, the human-computer interface is changing. It's less about debugging code line by line and more about understanding system behavior at a higher level. Bubna highlighted this shift, saying, “one thing we actually still see is really important is observability. How good is your dashboard?”

While agents can use CLI tools to investigate their own performance, human oversight remains vital. “You still need humans to go interpret what's going on and make judgment calls and whatnot,” Bubna noted. This means that dashboards and intuitive CLIs for monitoring agent activity are now more critical than raw code review. For Modal, this translates to pushing a lot of agent insights and diagnostic capabilities directly to the CLI, enabling both agents and humans to understand live changes and performance.

This move acknowledges that as AI systems become more complex and self-directed, our primary interaction shifts from giving commands to monitoring outcomes and intervening only when necessary. Good observability becomes the human's portal into the agent's world.

What to Do With This

First, audit your own internal automation or public APIs through an "agent's eye view." Identify any complex configuration files, multi-step provisioning processes, or obscure error codes that an autonomous system would struggle with. Your goal should be to simplify these interactions down to single-line declarations or decorators, abstracting away the underlying complexity.

Next, prioritize observability as the human interface for any autonomous systems you build. Design dashboards and CLI tools specifically for human operators to quickly understand an agent's status, progress, and potential failure points. Focus on providing actionable insights rather than raw data, enabling quick judgment calls and interventions when your automated components inevitably encounter edge cases.

Finally, create a simple benchmark for your own agents or automated workflows. Actively look for areas where they fail, get stuck, or require human intervention. Then, build direct, simplified solutions (like a single CLI command or a new API endpoint) to address those specific agent pain points, just as Modal created "modal bench" to improve its own AX.