The composer/orchestrator pair chapter named the two roles every act of coordinated work passes through. The composer's work chapter developed the three phases through which the composer authors the input script. This chapter develops the work on the other side of the boundary. The orchestrator's primary responsibility is performing the input script — inhabiting the role and running the loop. Authoring sub-scripts is part of the role, but secondary, surfacing only when the work calls for delegation.
Orchestrating at Every Scale
The orchestrator is the role inhabited by whoever is performing an input script. Performance happens at every scale of coordinated work, and its architectural shape does not change with scale. A coworker who took a quick request and delivered the answer has performed an input script. A team leader running a week of fieldwork has performed an input script. A federal agency carrying out a statute across a decade has performed an input script. The duration, the depth, the stakes, and the visible activity differ enormously across the three. What does not differ is the architectural shape.
What runs continuously while the role is held is the responsive loop the responsive-loop chapter named. Observation, evaluation, action — three phases dependency-ordered, running on the role's events, producing the role's work. The loop is a primitive of its own, distinct from role-playing. The role names what is being done; the loop is the mechanism through which the doing happens, moment by moment. The orchestrator's job is to inhabit the role and run the loop. Whatever the role — perimeter monitor, student researcher, team leader, federal regulator — the architectural shape is the same; what varies is the role and the work the loop produces.
Tasks
The work an orchestrator does in service of a role decomposes into tasks. The word carries its full pre-technical meaning here. A task is work assigned in service of a role — a piece of what the role requires, scoped to be done by a single performer across a bounded stretch of attention. Tasks are what composers assign and orchestrators perform. A teacher gives a student a task. A coach gives a player a task. A manager gives an employee a task. A volunteer coordinator gives a team member a task. Every reader has assigned tasks and been assigned them. The framework uses the word in this sense throughout the rest of the series.
The orchestrator inhabits the role for the role's duration and performs sub-tasks in service of it. A sub-task is a task that arises inside the role — work the role's performance calls for at that moment. The lifeguard intervening when a swimmer is in distress is a sub-task. The team leader briefing a team member at the start of the day is a sub-task. The teacher answering a question during the lesson is a sub-task. Most sub-tasks fit within a primitive act and are handled through direct performance. Some exceed primitive reach and require sub-composition. The two modes are what the rest of the chapter develops.
Direct Performance
The role is held continuously while the orchestrator orchestrates. Much of that holding is held-readiness — the responsive loop running, observation continuing, evaluation operating, no action firing yet. The responsive-loop chapter named what this stretch of the loop produces: readiness, continuity, accumulated observation, system status checks woven into the observation field. The lifeguard scanning the pool with no swimmer in trouble. The team leader monitoring the work with no question pending. The supervisor waiting for the team to call in. In the orchestrator's frame, all of those stretches are direct performance in its quietest mode — direct because no further authoring is required, performance because the role is being held and the loop is producing the readiness from which action will fire when conditions call for it. Events arriving during held-readiness — a text-message status report from a sub-performer, an email reply, a colleague stopping by with a question — are taken in by observation, processed by evaluation, and answered through direct performance: an acknowledgment, a follow-up, a decision to wait for more, a recognition that the next stage can begin.
Every act in direct performance fires only after evaluation has reached a conclusion. What varies is the depth of work the evaluation phase does. Some acts fire after a compressed evaluation that selects from a trained repertoire: the lifeguard sees the pattern of distress, evaluation matches it against what the lifeguard has been trained to recognize, the first move is selected, action fires. The whole loop runs in a fraction of a second, but observation, evaluation, and action are all present. The action is pre-scripted in the sense that the response was already in the role's repertoire ready to be selected; it is not pre-scripted in the sense that reasoning was bypassed.
What fires in those moments is the first move, not a full committed response. Trained responders are taught to move toward the situation first, not to commit to a specific intervention before reaching it. The dive toward the swimmer is itself observation — closer range, better angle, new information about whether the swimmer is conscious, breathing, panicking, sinking. The loop runs again on what the move revealed. The next act is selected on the basis of what the responder now knows that they did not know before. Direct performance unfolds as loop-act-loop-act, each act small enough that evaluation can run between acts on what the previous act produced.
Other acts fire after meaningful deliberation rather than compressed selection. The lifeguard observes a swimmer who looks tired but not in distress and works through whether to call them in. The team leader hears a question whose answer depends on facts the leader has to think through. The teacher sees a student's work and judges whether the right response is correction, encouragement, or a question back. Evaluation does extended work in those moments — drawing on training, on context, on judgment about the specific situation. When the orchestrator's own ground is uncertain, evaluation may reach for consultation: a quick exchange with a peer or supervisor whose perspective would inform the decision. Consultation that fits within the same stretch of attention as the deliberation is part of direct performance — a word across the room, a quick check-in, a momentary pause to ask. When consultation requires composing a formal request and waiting for a response, it crosses into sub-composition. The act that fires reflects what evaluation concluded after whatever input it gathered. Both compressed and deliberate evaluation produce direct performance, because what evaluation concluded was within what a primitive act can carry. The boundary between direct performance and sub-composition does not run between fast evaluation and slow evaluation; it runs between what one performer can carry in a bounded stretch of attention and what they cannot.
The intro chapter named three modes of performance: continuous micro-adjustment, recovery, and improvisation. All three run as direct performance when their acts fall within primitive reach — micro-adjustment as the small accommodations to what the moment requires, recovery as the bridge back to the script when something has gone wrong, improvisation as the substitution of something better when the script no longer fits. The boundary-conditions chapter named the latitude that lets all three happen without further authoring: the freedom a well-defined role grants. Direct performance is that freedom in operation.
Sub-Composition
When a sub-task exceeds what a primitive act can handle, direct performance is no longer enough. The conclusion that more is needed comes from evaluation. Sometimes plainly: the script's next step is obviously larger than primitive, and no weighing is needed. Sometimes through reasoning across alternatives: the situation presents multiple paths forward — different next steps that could each serve the role's goals — and evaluation has to weigh them first, choosing which one best fits what conditions now show, before the selected path can be acted on. Sometimes through recognizing that the orchestrator does not have enough ground to act alone: the script left a gap, conditions are uncertain, and consultation is needed before any path can be selected. Whichever way evaluation reaches the conclusion, when what it concludes lies beyond direct performance, the orchestrator composes a sub-script.
Sub-composition is the orchestrator taking on the composer role for the next layer down, running through specification, planning, and delegation, and producing an input script that names what the sub-task is for, how it will unfold, and who will perform it. The performer may be the orchestrator themselves, taking on a sub-role to handle the sub-task as a focused stretch of work. The performer may be someone working under the orchestrator, receiving the sub-script through a durable message and taking on the role at the layer below.
The volunteer team leader who has just discovered hidden electrical damage in the kitchen at 312 Maple faces a sub-task that exceeds direct performance. The team's briefing said remove the wet drywall, but the briefing did not anticipate hidden electrical damage, and pushing through with the removal would risk hurting someone. The team leader composes — specifies the sub-objective (find out whether it is safe to continue), plans (call the staging area, describe what was found, ask for guidance, hold the team back from the affected wall while waiting), and delegates (the team leader will make the call, the team will hold the wall). The composition takes seconds. The sub-script lives only as long as the situation requires. But every phase of composition was present, because the sub-task had grown past what a single primitive act could carry.
The teacher running the group project who has noticed that one group is going off track in a way that needs more than a quick redirect faces a similar threshold. The teacher composes — specifies the sub-objective (get this group back on track in a way that lets them recover the project), plans (sit with the group, listen to where they got lost, work through the next steps with them), and delegates (the teacher will do this themselves, taking on the sub-role of group consultant for the next ten minutes). What was a single sub-task in the role of teacher has spawned a sub-script the teacher will perform against, with its own bounded duration and its own sub-role.
Consultation is sub-composition with a particular shape. The sub-script asks for guidance rather than commissions work, and what comes back is information that shapes the orchestrator's continuing performance rather than finished work to receive. The volunteer team leader's call to the staging area is consultation — the request describes what was found, asks for guidance, and waits while the team holds the wall. The new manager who calls their own manager before making a personnel decision is consulting. The teacher who steps out to ask the principal how to handle a situation is consulting. The recipient may be the composer of the orchestrator's own input script — reaching back to whoever authored the role — or a peer with relevant expertise. Each consultation is dispatched through the same durable-message machinery as any other sub-script, awaiting a response that will inform what the orchestrator does next.
Each composed sub-script is itself an input script for the performer who receives it. The orchestrator who composed it is, at the moment of composing, in the composer role for the next layer down. The pair is recursive — the composer/orchestrator pair chapter named this; sub-composition is the recursion in operation.
Networks of Orchestrators
Sub-composition produces a chain of input scripts. At the top sits the founding script — performed by an orchestrator who composes sub-scripts for the layer below when the work exceeds direct performance. Orchestrators at each interior layer perform their parent's sub-script and compose further sub-scripts as their own work calls for them. At the leaves, orchestrators perform through direct performance alone, with the responsive loop running on primitive acts that need no further sub-composition. This is the script hierarchy the composer/orchestrator pair chapter named: within any sub-composition tree, a sub-script cannot violate what its parent specified, and the chain of containment runs from the root to every leaf.
The script hierarchy is a shape sub-composition produces — not a claim about how networks of orchestrators are organized as a whole. Every role has an origin: some composer authored the role description, some orchestrator dispatched it, some performer took it on, and the role traces back to whoever or whatever brought it into being. The script hierarchy that sub-composition produces is one form this takes — the originating composer retains command authority over the role they authored. But a role can also originate from an act that establishes no ongoing command relationship. A founder who established a standing position may be long gone while the position continues. A protocol that admits a participant into a network has no ongoing voice in what the participant does. A peer who invited a collaborator into a project may have no authority over the collaborator's work once the collaboration begins. Every role traces back to an origin; the command structure operating across roles is contingent on what the originating script established. The durable-message machinery the earlier chapters established was general from the start: messages flow wherever their addresses route them, upward to a composer who retains authority, downward to a sub-performer, laterally to a peer, outward to a collaborator, into networks shaped as trees, graphs, choreographies, or any combination the work requires. The orchestrator's job is the same in every case — inhabit the role, run the loop, perform sub-tasks through direct performance or sub-composition, communicate as the work calls for it.
A reader who has led work at any layer of any orchestration has been an orchestrator in this sense. The framework names what working orchestrators have always done — performing the script they received, handling sub-tasks directly when a primitive act will do, composing sub-scripts when it will not, communicating with peers and superiors and sub-performers as the work requires — in vocabulary that travels.