Notifications are the wrong abstraction for agent work

Every alerting system ever shipped is built on the same atomic unit: the notification. Something happened; here is a rectangle about it. The rectangle is identical whether the something was “your build finished” or “production is down.” You may dismiss the rectangle. There will be more.

This model was always mediocre, but it was survivable when applications were mostly reactive — they did things when you asked and were otherwise silent. AI agents break the truce. An agent is a colleague-shaped process: it works for twenty minutes or four hours, hits obstacles, makes progress, gets stuck, finishes. Wrap that in the notification model and you get one of two interfaces, both bad.

The chatty one. Every state change is a rectangle. Five agents produce a rectangle every ninety seconds. Within a day you have trained yourself to ignore all of them, which means the one rectangle that says blocked, waiting on you dies in the same muscle-memory swipe as the twelve that said still going fine.

The silent one. You turn it all off. Now supervising your agents means polling transcripts — scrolling walls of text to reconstruct state that the system knew perfectly well and simply had no vocabulary to show you.

The missing vocabulary is peripheral state. Consider how you supervise things in the physical world. A chef does not receive notifications from pans; the kitchen presents continuous ambient state — sound, smell, steam — and the chef’s attention samples it for free, at the periphery, without cost. Escalation exists (the smoke alarm) but it is rare, reserved, and earned.

Software almost never gets to use this channel, because screens went from single-window to notification-center without ever building the middle layer. That middle layer is exactly what agent supervision needs:

• Most agent state should be ambient. Working, progressing, slowing down, unusually quiet — these should be visible the way weather is visible: glanceable, ignorable, free.
• Some state should be signals. Completion of something you said you cared about deserves a quiet audio cue — a sound you learn, not a sound that demands.
• Almost nothing should interrupt. In our working taxonomy there is exactly one event class with a legitimate claim on interruption: blocked on a human. And even that interruption should carry the question it needs answered, not a link to a transcript where the question may be found.

This is the design bet behind our ambient agent dashboard: a working floor where each agent occupies a tile with continuously visible state, a small signal vocabulary above that, and interruptions treated as a budget the system spends reluctantly. We wrote up the framing more formally in Interruption Budgets, including how we plan to evaluate it — because “we like our own interface” is not evidence, and the prototype exists to generate some.

What’s already clear from daily use is the shape of the problem: the constraint on how many agents one person can run is not model capability. It’s that our interfaces spend human attention like it’s free. It isn’t, and the products that understand that will feel very different from a wall of rectangles.