TLDR:
- Amdahl’s Law, formulated in 1967, holds that the maximum speedup from parallelisation is constrained by the sequential portion of a task.
- In Plain English: If every passenger passes through the same border officer, adding more planes won’t speed up the queue.
- Applied to AI development workflows, human review and decision-making represent that sequential fraction. Adding more sub-agents yields diminishing returns.
- Broader industry adoption of agentic workflows is likely to increase demand for experienced developers rather than reduce it.
In 1967, IBM researcher Gene Amdahl made the argument that became Amdahl’s law: the maximum speedup from parallelising a task is limited by the sequential fraction of that work.
Amdahl’s Law: Speedup (n) = 1 / (S + P/n), where S is the serial fraction of the program (the portion that can’t be parallelised). P is the parallel fraction of the program (the portion that can be parallelised). n is the number of processors. The constraint is that S + P = 1 .
In plain English, you can add as many processors as you want, but the bottleneck still sets the ceiling.
Hardware engineers learned this the hard way. As CPU clock speeds plateaued and Moore’s Law slowed, the industry leaned harder into multi-core processors and distributed computing.
They enjoyed useful but bounded gains. Applications with large sequential components couldn’t fully exploit additional cores, so returns diminished quickly.
A 32-core machine running software with 30% sequential work reaches roughly 3.1x improvement, and even with infinite cores it can’t exceed roughly 3.3x.
Explanation: If 30% of the work is sequential and 70% is parallelisable, the speedup on 32 cores is: 1 / (0.30 + 0.70/32) = 3.11x. The absolute ceiling, with infinite cores, is: 1 / 0.30 = 3.33x.
AI development workflows now face a similar problem. You can add more sub-agents, but if every decision still has to pass through one human reviewer, human attention becomes the sequential bottleneck.
How Amdahl’s Law works for sub-agents
A modified version of Amdahl’s law helps explain the sub-agent problem. If we treat human review, task coordination, and final decision-making as the sequential fraction, then adding more AI agents can only help up to a point.
Under a simple model where 30% of the workflow still depends on human attention and 70% can be parallelised, one developer running three agents gets roughly a 1.9x speed increase.
At seven agents, the gain reaches roughly 2.5x. At ten agents, it reaches roughly 2.7x. Even with infinite agents, the workflow can’t exceed roughly 3.3x, because the human bottleneck still remains.
| S (Serial fraction) | P (Parallelisable fraction) | n (Processors or agents) | Speedup (to 2 d.p.) |
| 0.3 | 0.7 | 1 | 1.00 |
| 0.3 | 0.7 | 3 | 1.88 |
| 0.3 | 0.7 | 7 | 2.50 |
| 0.3 | 0.7 | 10 | 2.70 |
| 0.3 | 0.7 | 32 | 3.11 |
| 0.3 | 0.7 | 1,000 | 3.33 |
| 0.3 | 0.7 | 10,000 | 3.33 |
| 0.3 | 0.7 | Infinite | 3.33 |
The attention cost is separate from the speedup calculation. In practice, each extra agent adds review, routing, correction, and synthesis work.
That means the optimal operating zone is likely to be small: enough agents to divide the work, but not so many that the developer spends most of their time supervising agents rather than developing software.
Under this model, two to four agents is a plausible working range. Beyond that, the gains may continue, but the management cost rises quickly.
Once the developer is spending most of their attention supervising agents, the workflow starts to behave less like parallel software development and more like running a small team with none of the social cues, judgment, or accountability that make human teams easier to manage.
Why human attention doesn’t parallelise
A developer running multiple agents still has to verify output, catch errors, resolve conflicts between agents, and apply judgment to decisions that require contextual understanding.
A sub-agent can monitor compiler warnings, run tests, and update documentation simultaneously. But the developer’s capacity to evaluate all three streams doesn’t scale at the same rate.
This is the same structural problem Amdahl identified in distributed computing. The parallelisable portions of the work benefit from additional resources; but the sequential portions, which include any task requiring human expertise and judgment, create a hard ceiling on total throughput.
Unlike CPU cores, adding more expert developers to the same workflow doesn’t remove the bottleneck for free, because each extra person adds coordination, context-sharing, review, and handoff costs.
What this means for future developer demand
If sub-agents produce diminishing returns above a relatively low threshold, and if expert human oversight remains the non-parallelisable component of every agentic workflow, then increased agent deployment across the industry creates demand for more skilled developers, not fewer.
More organisations deploying more agents need more people capable of supervising those agents well, recognising failure modes, and keeping attention costs within the productive range.
The skill of working effectively with sub-agents, which requires deep technical judgment, becomes more valuable as agent counts rise across the industry, not less.
Previous automation waves often expanded the scope of work for people who knew how to operate, supervise, repair, and improve the new systems (the auto industry, for example).
Amdahl’s Law suggests the same outcome for software development. The ceiling on agent productivity is set by the developer; more agents don’t remove that ceiling. This makes the developer’s capacity to manage agents the primary competitive variable.