The Team Member Who Hires
The last part left the engineer supervising a coding agent, and called that the existence proof: a human already doing, full time and out of necessity, the supervisory work the rest of the book has been describing. That was the small case, and the leading edge is moving past it, not because every team is there but because the tooling that makes the next step possible is now shipping. The agent frameworks of 2026, OpenAI’s Agents SDK with its handoffs and agents-as-tools, Claude Code’s subagents and its experimental agent teams, the matured orchestrator-and-worker patterns that LangGraph and CrewAI grew into from their earlier single-agent roots, all make it possible for an agent to decompose a task and delegate pieces to other agents. The maturity varies and the limits are real, some platforms cap how deep the nesting can go, some keep multi-agent teams experimental and off by default, and I want to be precise about that rather than paint a fleet on every desk that does not have one yet. But the direction is unmistakable, and the move it points at is not a difference of degree. It is the moment the entire structure of this book folds back on itself, because the thing being supervised becomes a thing that supervises.
It is worth knowing that this is not a frontier the book is imagining alone; the research has been here for a while, and it has already given the structure names. The field sorts multi-agent systems into a few topologies, and the one this chapter is about, an orchestrator directing specialized workers, is the hierarchical pattern, the same shape as an org chart, with a planning agent on top and execution agents below. Worked systems make the rank literal: research builds put coding and testing agents under explicit senior management agents, and the protocols that let one agent hand work to another, Anthropic’s Model Context Protocol and Google’s agent-to-agent standard among them, are the delegation policy of this chapter written as a spec. The evaluator has its own line of work too, the LLM-as-judge maturing into an agent that plans and checks and is itself surveyed as a category. And the part of the literature closest to this book’s spine is the part on tiered oversight, hierarchical multi-agent systems built specifically so that higher agents watch lower ones, including in healthcare, where the stakes made someone formalize it first. So rank in a fleet is not a metaphor borrowed from human teams. It is the architecture, and the field has the diagrams. What the diagrams mostly do not have is the human at the top of them. The papers optimize the agent hierarchy, for accuracy, for cost, for how cleanly the work decomposes, and they are nearly silent on who is accountable when the tiered system fails as a whole, and on how a human organization is supposed to wrap around an agent organization that now has a rank structure of its own. That silence is the same one this book has tracked from its first chapter, reached from the other direction: the field has learned to build the agent org chart faster than it has learned who answers for it, and the seat at the top of the human ladder, the one the previous part showed an agent can never climb to because accountability does not ride up with autonomy, is exactly the seat the multi-agent literature leaves blank.
Picture the engineer from the last part, the one who learned to read an agent’s output in code, to catch its drift, to onboard it through a guidance file. Their job worked because there was a clean relationship: a human above, an agent below, the human watching the agent. Now the agent below has agents below it. The engineer asks the orchestrator to build a feature, and the orchestrator decomposes the work and hands pieces to sub-agents, a planning agent, a coding agent, a test-writing agent, a review agent, and those agents call each other, check each other, and assemble a result the engineer never watched being made. The engineer is still responsible. But the thing they are responsible for is no longer an agent they supervise. It is a small organization of agents that supervise each other, and the engineer is supervising the organization, which is a different and much harder job, and almost no one has named what it requires.
The member you never hired is hiring
There is a line from the last part worth repeating because it is the whole of this one: the team member you never hired is now hiring team members you have never met. When an orchestrator spins up a sub-agent to handle a piece of work, it has made a staffing decision. It decided that this task needed a worker, defined what that worker could do, gave it access to tools and data, and set it loose, and it did all of that in milliseconds, without asking anyone, and in a complex task sometimes dozens of times over. Every one of those is a hiring decision the agent made on the team’s behalf, and every one of them carries the same questions the team learned to ask about the first agent. What is this worker allowed to do. What is its blast radius. Who is watching it. What happens when it is wrong. Except now no human is in the loop for any individual answer, because the orchestrator is making the decisions at machine speed and the human is supervising the orchestrator, one level up, where the individual hires are invisible.
This is the supervision paradox raised a level, and raised in the worst possible way. The paradox in the foundations said a human supervising a reliable agent is trained out of vigilance by the agent’s reliability. Now the human is supervising an orchestrator that is itself supervising sub-agents, and the orchestrator is more reliable than any single agent, because it checks its workers, retries their failures, and assembles a clean result. So the human, watching the orchestrator produce good output, is trained out of vigilance faster, because the orchestrator’s self-correction hides the individual failures that a single agent would have surfaced. The sub-agent that went wrong was caught by the review agent, and the human never saw either, and learned, one more time, that the system handles itself. The reliability that erodes the supervisor is now manufactured by a layer of agents whose entire job is to make the system look like it does not need supervising. The better the agents get at watching each other, the less the human watches the agents, and the less ready the human is on the day the mutual watching fails in a way none of the agents was built to catch.
Every surface recurses
The cleanest way to see what agents-building-agents does to the team is to take the four surfaces of Channel 2 from the foundations, the autonomy boundary, the approval moment, the audit surface, the recovery workflow, and watch what each becomes at fleet scale. Three of them recurse: they exist twice now, at two levels, and the team that built one has built half. The fourth does something stranger, and it is the hinge of the whole part, so it goes last.
The autonomy boundary was the line between what the agent may do alone and what it must hand to a human. Now there is a second boundary inside the system, what one agent may authorize another to do, and it needs an artifact the single-agent team never built: a delegation policy, the rule for which credentials and capabilities an orchestrator may pass down and which it may never. When the orchestrator hands a sub-agent a token, that is a boundary decision made by an agent about an agent, and if nothing constrains the delegation, the orchestrator passes down whatever it holds. The production-database deletion from the failures part, the coding agent that wiped a company’s database and its backups in nine seconds through an over-scoped token, happened with a human one step away; the fleet version happens with no human anywhere near the trigger, the same kind of over-scoped credential handed agent-to-agent at machine speed, which is why the delegation policy has to be a built constraint and not a hope.
The audit surface was the record of what the agent did and why. Now it has to be a record of what the whole fleet did, and it needs an artifact most logging was never built for: an agent lineage trace, the record of which agent called which, what each was allowed to touch, and why the orchestrator spun up the sub-agent that caused the problem. Almost no team’s logs can answer the question that fleet incidents turn on, which of my agents hired the one that did this, and a team that cannot answer it cannot do the postmortem, because it cannot find the hire.
The recovery workflow was the path back when the agent did one wrong thing. Now the wrong thing may have been done by a sub-agent three layers down and discovered after the orchestrator already built on top of it, so the artifact is a rollback tree rather than an undo: a way to unwind a branching set of actions that compounded, not a single reversible step. The team that has a rollback for the agent rarely has one for the fleet, and the difference shows up at the worst moment, when the thing to reverse is a structure and the tool reverses a step.
And then the approval moment, the place a consequential action paused for a human, and the one that does not recurse at all. It cannot, because the entire point of agents building agents is that the human stepped out of the per-action loop; you cannot approve each thing a hundred cooperating agents do, that is the speed you bought. So the approval moment does not double. It dissolves, and what it dissolves into is the subject of the rest of this part. The human stops approving actions and starts setting the conditions under which agents may act on each other at all, which is a different kind of design with a different name, the name the book has been building toward: governance, the rules of behavior that hold when no one is watching the individual act, because no one can be. Three surfaces recurse and one dissolves into governance, and that dissolution is where supervision, the thing this book spent five parts teaching, quietly stops being enough.
The hiring decision no one is making
Step back and the shape of the new problem is clear, and it is worth naming as itself before the rest of the part works on it. Every staffing decision a team labored over for the first agent, what it may do, what it may touch, who watches it, what happens when it is wrong, is now being made by an agent, in milliseconds, many times a task, with no human in the loop for any single one. The team did not stop making hiring decisions. It delegated them, wholesale and invisibly, to the orchestrator, and a team without an explicit governance function has usually never noticed that this is what it did, which is exactly the problem. The blank seat is not a new role this time. It is the recognition that the hiring itself has moved inside the machine, and that the judgment the team used to apply one agent at a time now has to be built into the conditions under which agents hire each other, because the alternative is that the conditions are whatever the framework defaulted to, which for delegation is usually everything. The single-agent team learned to ask the four questions before it deployed an agent. The fleet team has to answer them once, structurally, for hires it will never individually see, and that is a different discipline, and the rest of this part is what it takes.