The reason your agent pilot underwhelmed is not the model. You added production capacity to a system whose real bottleneck was coordination and review, and coordination is precisely the work that agents generate more of, not less. Every task an agent absorbs spins off new supervisory work: someone has to draw its boundaries, check its output, own its mistakes, and reconcile what it did with what everyone else did. That load has to land somewhere, and in most companies it lands on the layer least equipped to absorb it — middle management.
This is an org-design problem wearing a technology costume. The capability is largely here. What is missing is a structure that can carry the new coordination burden, and the current org chart was built for a world where the people doing the work also did most of the checking of it.
The self-supervision discount that agents don't give you
Start with why span of control has a ceiling at all. A manager can coordinate roughly seven to ten people, and the reason is not that ten is a magic number. It's that a competent human report is a self-supervising unit. They know, most of the time, when they are stuck. They feel the weight of their own name on the work. They escalate before a small error becomes a large one. They reconcile their piece against their peers' in the hallway without being told to. The manager's actual job — exception handling, final review, bearing accountability upward — stays bounded because each report has already filtered ninety percent of the noise before it reaches the desk.
Call that the self-supervision discount. It is the single largest reason organizations scale at all. A manager reviewing eight people is not reviewing eight full workloads; they are reviewing eight pre-filtered summaries plus the occasional genuine exception. Thirty minutes of spot-checking covers a day of a good analyst's output, because you trust the ninety percent and you sample.
An agent gives you none of that discount. It produces plausible work at machine speed and takes no responsibility for any of it — a point I've made at length in the argument that your AI agent has no skin in the game. It does not know what it does not know. It will hand you a confidently wrong answer in the same fluent tone as a correct one, which means you cannot sample. With a human, errors cluster: a tired analyst makes three related mistakes in one section, and you learn to check that section. With an agent, errors are uncorrelated and locally invisible. Paragraph four is immaculate, paragraph five invents a citation, paragraph six is immaculate again. Spot-checking assumes the unchecked parts resemble the checked parts. That assumption is exactly what a stochastic generator violates.
So every unit of agent output converts, more or less directly, into human review load. There is no ninety-percent pre-filter. The manager who coordinated eight self-supervising humans now coordinates eight humans plus fifty tireless producers of unfiltered, unaccountable, confidently formatted output.
Do the arithmetic
Put numbers on it, because the point is quantitative and the math is the whole argument.
Suppose reviewing one analyst's daily output costs you 30 minutes, because you trust their self-review and inspect only the exceptions. Eight reports, four hours of coordination and review a day. Tight, but that is a functioning manager.
Now give that manager fifty agents. Each produces, conservatively, five times the raw volume of a human in a day — that is the entire pitch. None of it is self-verified, and none can be safely sampled, so the review cost per unit does not stay at thirty minutes. It rises, because you must read the whole thing to trust any of it. Say verifying an agent's daily output costs 45 minutes of genuine attention when done properly. Fifty agents is 37.5 hours of review per day dropped onto one person with a four-hour daily budget.
The response everyone actually chooses is to stop reviewing properly. You skim. You trust the fluent formatting. You let the ninety-fifth-percentile-plausible output through because you physically cannot inspect it. Now you have not automated the work — you have automated the generation of unverified liabilities, and quietly moved the point of failure downstream to wherever the error finally becomes expensive. The coordination tax did not disappear. It went unpaid, and unpaid taxes accrue interest.
Why productivity falls: you fed a bottleneck
The "we deployed agents and output went down" story stops being a paradox once you name the constraint. Most knowledge organizations are already review-bound, not production-bound. The scarce resource was never the writing of the memo, the drafting of the code, the first pass at the analysis. It was the trusted verification and the reconciliation of that work with everything else in flight.
This is the Theory of Constraints, and it is unforgiving. Throughput is set by the bottleneck. Adding capacity anywhere except the bottleneck does not raise throughput; it raises inventory. In a knowledge system the inventory is work-in-progress — half-finished threads waiting for someone qualified to approve them. Little's Law is blunt about the consequence: average cycle time equals work-in-progress divided by throughput. Hold throughput fixed at the reviewer's ceiling, pour in five or fifty times the WIP, and cycle time explodes. Things take longer. The queue in front of the one person who can sign off grows without bound, and every item in it is aging, going stale, needing re-reconciliation against work that moved on while it waited.
Measured productivity falls not despite the agents but because of them. You uprated the assembly line feeding a single inspector and called it an upgrade.
The coordination doesn't vanish — it concentrates
There is a comforting story where agents dissolve jobs into their component tasks, the routine tasks get automated, and humans float up to the interesting residue. The dissolving part is real; I've argued that agents don't replace jobs so much as unbundle them into tasks. What that story omits is what happens to the seams.
A job is not just a bag of tasks. It is also the implicit contract that one person owns how those tasks fit together and answers for the result. When you unbundle a job into twelve tasks and hand nine to agents, the nine still have to be bounded, checked, and stitched back to the three a human kept — and to the tasks other agents are running elsewhere in the org. The coordinating work that used to live inside one skull, done for free by the person who held the whole job, now has to be done explicitly, across a boundary, by a manager. Unbundling does not delete coordination. It externalizes it, and externalized coordination is far more expensive than the version that happened silently inside a single competent employee's head.
So the load does not spread out. It concentrates on whoever holds the review and the accountability. The org chart routes it straight to the middle, to the layer with the least slack and the least tooling, and that layer buckles.
What the org has to become
If verification capacity is the true constraint, you design the organization around it the way a plant is designed around its bottleneck machine. Three changes follow, and they are structural, not motivational.
First, make review a role, not a tax. The reflex is to smear agent supervision across existing managers as unpaid overhead on top of their real jobs. That is how you get the skim-and-pray failure mode. The alternative is explicit roles — agent supervisors, reviewers, verifiers — whose primary output is trusted sign-off, with the headcount and the authority to say no. This feels like adding cost to a project justified by cutting cost. It is. The saving is real only if you spend part of it buying back the verification capacity the agents consumed.
Second, go flatter and wider, and pay for the width with tooling. The point of agents is that a supervised span can be enormous — one competent reviewer overseeing dozens — but only if each unit of output arrives cheap to check. That means agents must produce verifiable artifacts, not walls of prose: diffs against a known baseline, provenance for every claim, explicit confidence and abstention when they are unsure, machine-checkable tests attached to their own output, structured results you can validate by sampling because the format guarantees the rest. Every dollar spent making output cheap to verify buys back span of control. That is the highest-leverage engineering investment in the whole stack, and almost nobody funds it, because it isn't the demo.
Third, treat verification throughput as the scarce resource you schedule against. Gate and batch agent output so it arrives in reviewable units instead of a continuous stream of ambient liability. Route work by who can be accountable for it, not by who can generate it — generation is now free and accountability is not. Size deployments to the review capacity you actually have, not the production capacity you just bought. A team with two hours of trusted review a day should deploy the number of agents that produces two hours of reviewable work, and not one more, no matter how cheap the marginal agent looks.
The companies that win the next few years will not be the ones with the best models. Model access is converging toward a commodity. They will be the ones that rebuilt their org chart around the fact that generation became free and verification did not — that hired reviewers before they hired more generators, that engineered their agents to be cheap to check, that recognized coordination as the bottleneck and stopped feeding it.
Everyone else will keep buying production capacity, pointing it at a review queue that cannot grow, and calling the resulting slowdown a temporary adoption curve. It is not temporary. It is arithmetic, and the arithmetic does not care how good the model is.