Agent Time Becomes the Bottleneck
Executive Summary
The strongest signal today is that coding-agent discourse is shifting from “can the model do the work?” to “can the human keep the work moving?” Faster and more capable agents are exposing a less glamorous bottleneck: attention, interruption handling, session coordination, and the practical mechanics of supervising several semi-autonomous workers without turning the developer into a full-time babysitter.
What Happened
Michael Richman’s AI Engineer talk, “Let’s Talk About FOMAT: Fear of Missing Agent Time”, gave a useful name to a failure mode many agent users already recognize: you start an agent, step away expecting useful progress, and return to discover it blocked five minutes in on a question. The result is not catastrophic model failure; it is silent idle time.
That matters because the promise of coding agents depends heavily on asynchronous leverage. If a developer must remain close enough to answer prompts, approve actions, inspect branches, and redirect drift, then the workflow is still “back and forth” rather than genuinely low-touch. Richman’s framing is memorable because it does not overclaim. It accepts that agents are useful, but argues that the operational layer around them is still immature.
The concrete problem becomes sharper with parallelism. One session is easy to watch. Two or three are manageable. Beyond that, developers lose track of which agent is waiting, which one has gone off course, and which one has completed something worth reviewing. Richman’s proposed pattern — remote or mobile monitoring, notifications, grouped sessions, and fast human responses away from the main development machine — points toward an emerging product category: not smarter models, but better control surfaces for agent labor.
Why It Matters
This reinforces a recurring digest view: agent productivity is increasingly constrained by workflow design, not just benchmark capability. As models become faster and coding tools more autonomous, the scarce resource becomes high-quality human judgment at the right moment.
That has several implications for builders. First, notification design becomes part of developer productivity. An agent asking for help is not merely a chat event; it is a blocked worker. Good tooling should distinguish “needs a decision,” “needs review,” “made progress,” and “is likely wasting time.” Second, parallel agents need orchestration primitives. Session names, task grouping, shared status, and escalation rules may matter as much as another marginal model upgrade. Third, developers need habits that preserve optionality: smaller tasks, clearer constraints, and checkpoints that make it cheap to resume or redirect work.
The bigger cultural shift is that agent work is becoming managerial. The developer is not only writing code or prompting a model; they are allocating attention across partially independent processes. That makes old software-engineering skills newly relevant: scoping, review discipline, queue management, and deciding when a thread should be killed rather than rescued.
The Bigger Story
A second AI Engineer talk, “Scaling the Next Paradigm of Heterogeneous Intelligence”, widened the lens from developer workflow to system architecture. Adrian Bertagnoli argued that the field is moving away from a purely homogeneous scaling picture — one large model on fleets of similar chips — toward heterogeneous stacks: different prompts, models, roles, architectures, and hardware working together.
As a standalone thesis, that remains more conceptual than settled. But paired with the FOMAT discussion, it clarifies the day’s pattern. The future being sketched is not a single magic agent. It is a mesh of specialized components, sessions, tools, and human interventions. In that world, orchestration is not a side issue; it is the product.
This also complicates the usual autonomy narrative. More autonomous settings can reduce permission friction, and lightweight social signals around coding-agent “auto mode” suggest practitioners are leaning that way. But autonomy does not remove supervision; it changes when and where supervision happens. The question becomes whether tools can compress human involvement into fewer, better-timed decisions instead of many small interruptions.
The Retrospective
The useful takeaway is modest but durable: treat agent time as a resource that can be wasted. Idle time after an early clarification request, invisible drift in a background session, and unattended completed work are all forms of lost leverage. Teams experimenting with coding agents should measure not only task success, but also interruption rate, time blocked, review burden, and how many parallel sessions a developer can responsibly supervise.
The discourse is maturing when it stops treating “more agents” as automatically better. Today’s signal points to a more operational canon: agents need bounded work, visible state, reliable escalation, and human control surfaces that scale beyond a single chat window.
Further Reading
- All Compute Is Food: Palisade’s Jeffrey Ladish on AI Shutdown Resistance, Self-Replication & Ecology — a new Cognitive Revolution episode to watch for the safety/governance thread around shutdown resistance, self-replication, cybersecurity risk, and compute governance.