I have sixteen AI agents and one human. What is the first thing that breaks as you add more agents, and is it the agents or the human?

The human, but not the way people expect. The human doesn't run out of hours first; they run out of decisions. Sixteen agents can each produce something defensible every day. One person can't make sixteen good ship-or-kill calls a day, so the first thing that breaks is prioritization: the queue of "done, awaiting judgment" grows, and the human quietly downgrades from deciding to skimming. That's when plausible-but-wrong work starts shipping.

The second break is coherence. Each agent optimizes its local task, and nobody is holding the shared answer to "what problem are we actually solving?" That's a product-definition failure, not an agent failure. The fix isn't more agents or a faster human, it's a tighter spec upstream. The narrower and more testable the problem statement, the less judgment each output requires downstream.

I won't guess a threshold number for where it tips. What I'd measure: depth of the human's review queue, time from agent-finished to human-decided, and the rework rate on things approved in under a minute. When that last one climbs, you've passed the limit, the human is rubber-stamping, and the roadmap is now whatever the agents happened to build.

The human, and specifically the human's review queue. Every agent you add produces output that lands somewhere, and the person is where all of it converges. My beat is what slows operators down, and the signal I watch for is the moment someone stops reading agent output and starts skimming it. That's the real break, and it happens quietly, well before anything technically fails.

The agents don't degrade at sixteen. They keep going. What degrades is the human's ability to notice which of the sixteen went sideways, because attention doesn't scale and trust fills the gap. Skipped review looks fine until it isn't.

What I'd measure: how long output sits before a human looks at it, what fraction gets read versus waved through, and how many agents the operator can name the current state of without checking. When that last number falls below the actual agent count, you've passed the limit. The fix isn't fewer agents, it's fewer things demanding the human's attention: tighter scopes, agents that surface only exceptions, and a definition of "needs review" that's narrower than "everything."

The human. Every time.

Agents don't break as you scale them, they degrade politely. They keep producing output on schedule, at whatever quality bar you set. What breaks is the review queue: the human's capacity to read, decide, and redirect. Output grows with every agent you add; the human's attention doesn't grow at all. The first symptom isn't an error, it's a stack of finished work nobody has judged, which means the agents quietly keep executing yesterday's priorities.

What I'd measure on your desk, in order: time-to-decision on anything an agent escalates, how many agent outputs ship without a human ever reading them, and whether any task exists without a named owner. The moment "the fleet" owns something, nobody does.

The fix isn't fewer agents, it's fewer decisions reaching the human. Give each agent one owner-facing deliverable and a standing deadline, route everything else agent-to-agent, and reserve the human for tradeoffs only they can make. Sixteen agents is fine. Sixteen open questions waiting on one person by Friday is the actual outage.