In Ten People, One Hundred Agents, the team was flat. Ten people, ten agents each, every thread answering to a human.
The next step in scale is not ten more threads. It is a promotion. One of the agents stops doing work and starts supervising the ones that do. Then every person's ten becomes one manager and nine workers, then one manager and ten managers, and suddenly the structure humans spent ten thousand years inventing, the hierarchy, exists in software: one human steering ten managers steering a hundred workers.
This is the post about that shape. It is the most powerful configuration in the series and the most fragile, for the same reason.
What an agent manager actually does
Strip the title and an agent manager has five jobs, none of them optional:
- Decompose. Take the captain's brief and split it into worker-sized pieces that can run in parallel without stepping on each other.
- Assign with contracts. Every worker gets its own contract: what done means for this slice, what it may invent, where it must stop. The captain's contract says what the whole voyage means. The manager's contracts say what each haul means.
- Verify first pass. Check worker output against the slice contract before anything moves up. The manager is the first exam.
- Merge. Compress the pieces into one result, and notice where the pieces contradict.
- Escalate. When evidence runs thin, when the slices cannot compose, when the brief itself looks wrong, stop and go up. An agent manager that never escalates is not a manager. It is a worker with a longer way to fail.
Read the list again and you will notice it is a foreman on a build site, a stage manager before a school play, a shift lead in a kitchen. Management as a role is finally describable enough to delegate, and that is the quiet revolution here. The first agentic hire was a worker. The second is a manager.
The math, and the mirror
One human. Ten manager agents. Ten worker agents each. A hundred working threads, ten first-pass verifiers, one accountable person.
That is a span of control in software, and it inherits everything humans learned about spans the hard way. The manager agents hold the center of gravity: like any middle layer, they decide what the top hears, how the work gets framed, and which failures surface. Organizations were woven for one thread, and their hardest lessons were about the middle. Agent hierarchies rebuild the middle in code, and the lessons transfer exactly.
The telephone game is the enemy
Here is the failure mode, and a fifteen-year-old at summer camp can demonstrate it. Sit ten kids in a line and whisper "tell the kitchen: no onions in the soup." By the tenth kid the soup has pineapple in it, and every kid passed the message on confidently.
Every hop in a hierarchy compresses intent. The captain writes a rich brief. The manager summarizes it into slice assignments. Each slice assignment is thinner than the brief. Each worker's output is thinner than its assignment. At two levels the signal is strong. At three or four, what the human meant and what the fleet did can part ways entirely, with every node reporting success.
Worse, errors compound rather than add. A manager that misreads one slice in ten hands a wrong unit of work to its crew, and the crew executes it perfectly. Perfect execution of a misunderstanding, times a hundred threads, is the signature failure of agent hierarchies. It is confident wrong output with an org chart.
And hierarchy does not fix it by being taller. Every added level adds another compression, another merge, another place where the message can gain pineapple. The instinct that says "this is important, add another layer of review" is usually backwards. The fix is shorter chains, not taller ones.
The design rules
Agent hierarchies work when they are designed against the telephone game, not around it:
- Keep the chain short. Two levels, human to managers to workers, is the proven shape, the pattern Anthropic described in 2025 with a lead agent over three to five subagents. Three levels is a specialty tool. Four is a rumor mill.
- A contract at every edge. Not just the human-to-manager contract. Every manager-to-worker edge carries its own written done, its own evidence requirement, its own stop conditions. The edge without a contract is where the pineapple enters the soup.
- Verification at every level, humans sample the managers. Managers verify workers' output the way proof gates verify any change. The human verifies the managers the same way: by sampling, deeply, forever. Never audit only the bottom of the tree. The compression errors live in the middle.
- Escalation skips levels. Any worker holding thin evidence must be able to reach the human directly, not queue through its manager. The chain of command is for work. The escape hatch is for doubt, and doubt that must pass through the node that caused it is doubt that dies quietly.
- One named human per subtree. Every manager and its crew has exactly one owner, written down. When a subtree goes strange at three in the morning, there is no question whose phone lights up.
- Managers propose, humans dispose at irreversible edges. A manager may spend tokens, spin workers, and run experiments freely. It may not fire the customer, publish the release, or cross the irreversible line. Those edges stay human in every hierarchy, forever, because some work does not come in threads.
When the shape earns its keep
Agent hierarchies shine where the work is breadth-first all the way down: a research question that splits into subtopics that split into sources; a codebase change that splits into modules that split into edits; a market scan that splits into regions that split into accounts. Deep, wide, decomposable, verifiable. Anthropic's single-level system beat a single agent by 90.2 percent on exactly this kind of work, 2025, and the second level serves the same shape at larger surface area.
It fails predictably outside that shape. Sequential work, where step two means what step one made it mean, gains nothing from a chain of command. Shared-context work fragments. And the creative first version of anything still breaks the whole ladder, because the contract cannot be written for an unknown at any level of management.
Two honest notes on cost. The token bill multiplies per level: the single-level swarm ran about fifteen times a plain chat, and each added level adds its own coordination overhead on top; there is no clean public benchmark for two-level swarms as of mid-2026, which should make anyone conservative here. And the judgment at the top never multiplied. The hierarchy multiplies execution. Direction still arrives from one thread, and it still arrives at conversation speed.
The mirror test
The last caution is the strange one. Agent hierarchies are young, and they are already reproducing the pathologies of human org charts: middle nodes that filter what the top hears, subtrees that grow because their manager grew them, verification that rubber-stamps because it is cheaper than escalation. Nobody designed these. They emerged, because hierarchy transfers structure, not judgment, and structure alone will drift.
The human's job in a ten-by-ten hierarchy is therefore not less managerial. It is more. The human owns the intent at the top, samples the compression in the middle, and keeps the escape hatches clear to the bottom. That is a real management job description, and the teams that staff it well will run circles through a hundred threads. The teams that assume the org chart manages itself will discover that they built a telephone line with a hundred kids on it, each one confident.
FAQ
Why not just give one agent a hundred subagents?
Because the lead's context and attention become the ceiling, and its compression of a hundred results is the single point of failure. Widening without deepening keeps one compression point; deepening spreads the compression across managers, and then the design rules above become the difference between a fleet and a rumor mill. Most real work tops out at one extra level for exactly this reason.
Do agent managers get tired or play politics?
No fatigue and no politics, which removes half of human middle-management failure. But the other half remains fully intact: framing drift, filtered escalation, and local optimization at the expense of the whole. Those are not personality defects. They are compression artifacts of hierarchy, and software reproduces them faithfully.
How do we know our hierarchy is compressing too much?
Watch for three symptoms. Worker outputs that are individually flawless and collectively incoherent. Managers whose summaries stop carrying the captain's original caveats. Escalations that always arrive resolved, because nothing upstream wanted to bother the human. Any one of these means the telephone game is underway, and the fix is a shorter chain or richer contracts, not more review meetings.
What does the human actually do all day in a ten-by-ten fleet?
Four things, on a rhythm. Write and rewrite the intent at the top, because that document is the whole system's north star. Sample manager outputs deeply and randomly, hunting compression. Read the escalation log, especially the silences. And decide the irreversible edges, which arrive precisely because a hundred threads were running. It is the best job in the building, and it is not a part-time role.
Related reading
- Ten People, One Hundred Agents
- The Swarm Is a Different Animal
- Agents Should Not Share a Brain
- From Pull Requests to Proof
- Design the Escalation Layer Before You Add More Agents
- Where the Fleet Breaks, and When It Scales
- The Herder, the Workers, and the Router
If you are about to let the wheel hire foremen, book a discovery call.