Checkpoint discipline for a fleet of agents you can't watch all at once
Running one autonomous agent is a solved problem. Running several in parallel, each one occasionally needing your judgement on something only you can decide, breaks down somewhere I didn't expect: not in the model's capability, but in my own capacity to actually notice and answer the decisions correctly once there's more than a couple of them landing at once.
The research that made this concrete for me comes from fields that solved a version of this problem decades before agentic coding existed. Security operations centres and clinical alarm systems have been studying "too many alerts, reviewer stops actually reading them" for a very long time, and the numbers are stark enough to take seriously. SOC teams ignore sixty-two percent of all alerts under volume. Clinical monitors generate alarms that are seventy-two to ninety-nine percent false or non-actionable, and nurses learn, correctly, to stop responding to most of them. Coding agents are walking into the exact same failure mode, just with a shinier name: approval fatigue, where by roughly the twentieth review request a person is pattern-matching on surface features rather than actually reading the content in front of them.
There's a second, nastier failure sitting right next to fatigue, and it's the one that worries me more because it's silent. Rubber-stamping. Two mechanisms drive it. Approving something is one click; rejecting it means actually understanding what's wrong and then waiting through a retry cycle, so the friction is asymmetric and it biases every decision toward yes by default. And after roughly fifty consecutive safe approvals, reviewers measurably stop independently verifying, coasting on the streak rather than the content. A research paper on oversight capacity puts a name to something I'd felt but hadn't quite articulated: oversight is a fatiguing cognitive resource, not a constant. Your hundredth review of the day is not as good as your third, no matter how disciplined you think you're being.
The fix that's converged across every serious system I looked at, coding agents and adjacent domains both, is radically fewer, better-packaged decisions, delivered on two distinct channels rather than one undifferentiated stream. A rare, genuinely interruptive channel, reserved for the handful of items that are simultaneously high-stakes, time-sensitive, and a real judgement call rather than something mechanical. And a batched channel, reviewed on my own schedule, for everything else, visible but not demanding immediate attention. Getting this split wrong in either direction breaks something: push everything and you train yourself to ignore the channel entirely; batch everything and the one decision that genuinely couldn't wait sits unread until it's too late to matter.
The other change that mattered more than I expected was what actually goes inside a decision, once it's decided to escalate at all. The instinct is to hand over everything: the full session transcript, every tool call, the whole reasoning trail, on the theory that more context helps, but what actually helps is the opposite: a one-line question, framed as an actual decision rather than "please review this," the artefact at the right altitude, a diff summary or a plan rather than raw logs, an explicit note on how reversible the choice is, and nothing that requires me to go reconstruct the "why now" from scratch. Process narration, the play by play of what the agent searched and read before arriving at the decision, is close to pure noise at this stage. It answers a question I'm not asking.
The reason self-contained packaging matters more than it sounds like it should comes down to a number from an entirely unrelated field. Gloria Mark's research on workplace interruption found the average context switch costs over twenty three minutes to fully recover from, and the person typically passes through two other tasks before actually getting back to the interrupted one. That cost runs in both directions. Every decision card that forces me to go reload context from wherever it originated charges me that same tax, not just the agent that got interrupted waiting on me. A well-packaged, self-contained decision is the only way async oversight of several parallel streams stays viable at all, because the alternative, going back to re-derive context every time, quietly turns "check in on four projects" into "context-switch four times a day at twenty-plus minutes each," which is a worse way to spend a day than just running one project at a time ever was.