Authority Doesn't Compose: Why Coordinated Agents Need a Coordinator With Its Own Band

A procurement agent sees a switchgear supplier offering a slot that shaves six weeks off a 140-week lead time, at a small premium well inside its approved spend threshold. It takes the slot. Correct call, inside its authority. At the same time, a logistics agent re-sequences the delivery schedule to land that switchgear earlier, re-slotting a transformer delivery to make room - also a small change, also inside its threshold. Correct call, inside its authority. And a commissioning agent, seeing both upstream changes, pulls the energization milestone forward three weeks to match. Each inside its limits.

The composite is a decision no one made and no one was authorised to make: the project's critical path has been rewritten, a 100-megawatt energization milestone moved, and three vendor commitments re-cut, on the strength of three individually-trivial approvals that no human and no single agent ever evaluated as one decision. Then the switchgear slot slips - they do - and the re-sequenced transformer is now the long pole, except its slot was given away. The schedule is worse than if nobody had optimised anything. Three correct, in-bounds actions composed into a wrong, out-of-bounds one.

This is the failure the buildout use case is uniquely prone to, and it is a different shape from every failure in this series so far. In cooling, SRE, placement, and power, the question was always about one agent: what band is this agent in, and is it acting past it? Here, every agent stayed inside its band and the system still produced an action that should never have been taken autonomously. The danger did not come from an agent exceeding its authority. It came from authorities adding up.

This is Part 6 of the series. Part 1 set out the Operational Authority Gradient (OAG): four bands - Observe, Advise, Act-within-bounds, Closed-loop - assigning authority by an action's irreversibility and blast radius. Parts 2 through 5 placed single use cases on it. Buildout - the construction, commissioning, and supply chain of the data center itself - is the multi-agent use case, and it exposes a gap the single-agent gradient does not cover.

The thesis: authority does not compose

Every prior article applied the OAG to one agent at a time. That is the natural unit, and for a single cooling or placement or power agent it is the right one. But the buildout is not run by one agent. It is run by a coordinated system of them - a procurement agent, a logistics agent, a commissioning agent, a scheduling agent - each specialised, each with its own bounded authority.

Here is the claim this article owns: authority does not compose. The fact that every agent in a coordinated system is acting inside its own band tells you nothing about whether the system's combined action is inside any band at all. Two Act-within-bounds agents can produce a composite action whose blast radius and irreversibility put it squarely at Advise - a band lower than either agent's own, one no acting agent held - and because each agent only sees its own slice, no agent perceives the composite, and no agent's gate catches it. The gradient was built to govern an agent. A coordinated buildout needs something the gradient did not provide: a coordinator that owns the authority band of the combined action, not the sum of the parts.

This is not a refinement of the earlier articles. It is the missing dimension. The OAG, applied per-agent, is necessary and insufficient for multi-agent systems. The composite needs its own band, assigned by the blast radius of what the agents do together, and enforced by a coordinator that can see across all of them - because the one thing each specialised agent structurally cannot see is the others.

Why this matters: the buildout is coordination under brutal constraints

The reason this lands hardest in the buildout is that the buildout is, right now, the most coordination-intensive and least forgiving problem in the entire boom.

The binding constraint has moved. It is no longer capital, and no longer chips - the gating factor is the physical electrical layer: transformers, switchgear, and battery systems. The numbers are sobering: high-voltage transformer lead times have stretched from roughly 50 weeks in 2021 to 120 weeks in 2024, with large substation and step-up transformers now ranging from 80 to 210 weeks. These are not items you re-order on a whim; a procurement decision today commits a slot two to four years out. And the coupling is pervasive: construction schedules must align civil work, structural installation, and equipment energization with precision, and a delay in any one package can stall commissioning across the entire facility. A single late transformer does not delay the transformer. It delays the building.

That combination - multi-year lead times on coupled components where any one slip stalls everything - is why the buildout is being handed to coordinated agents in the first place. The coordination load is beyond what human planners can hold in their heads in real time, and the agentic supply-chain pattern fits: a procurement agent negotiating lead times while a logistics agent optimises routing, a commissioning agent sequencing energization, all reacting to live disruption signals. The IDC read is that distributed AI for supply chains is heading for majority enterprise adoption by 2030. The pattern is real and it is coming to the buildout.

But the same properties that make coordination valuable make composed authority dangerous. When decisions are this tightly coupled and the stakes are multi-year and facility-wide, the composite of several small, correct, in-bounds adjustments is exactly the kind of high-blast-radius action that must not happen autonomously - and it is exactly the kind that a system of independently-bounded agents will produce without anyone deciding to.

The failure is emergent, and it is already documented

The composed-authority failure is not a thought experiment. The clearest published version comes from logistics, and it is worth stating precisely because it is the same mechanism the opening failure runs on.

Consider a major shipping canal that suddenly closes. A logistics agent for one carrier calculates the most cost-effective alternative route - correct, in-bounds. At the same millisecond, fifty other logistics agents make the identical calculation. The result is massive port congestion at secondary hubs, cascading delays, and soaring fuel costs. Every agent was right. The system was catastrophically wrong. The core issue named in that work is that the agents are strictly competitive and local - each optimises its own objective with no representation of the composite it is helping create.

Note the structure, because it is the same as the buildout's. The failure is emergent: it exists only at the level of the composite, and is invisible at the level of any individual agent's decision. No agent exceeded its authority. No agent hallucinated. No single decision was wrong. The wrongness is a property of the set of decisions, and the set is precisely what no individual agent can see. This is why "make every agent well-behaved" - the entire project of Parts 2 through 5 - is necessary but cannot by itself prevent the failure. A system of perfectly well-behaved agents produces it anyway.

The wrong way: well-governed agents, no coordinator

The naive multi-agent buildout does exactly what the series so far would seem to recommend: it gives every agent a clean band and a tight envelope, and lets them act.

# The seductive, wrong shape: each agent is individually well-governed,# and the system is assumed to be safe because its parts are.async def run_buildout(signal: DisruptionSignal, agents: list[Agent]) -> list[Action]:    actions = []    for agent in agents:                       # procurement, logistics, commissioning...        proposal = await agent.plan(signal)        if agent.within_band(proposal):        # each checks ITS OWN authority            actions.append(await agent.execute(proposal))        else:            actions.append(escalate_to_human(proposal))    return actions                              # composite never evaluated

Every line of this is locally correct. Each agent plans, checks its own band, acts if it is within authority, escalates if not. It is the OAG applied faithfully, per agent. And it produces the opening failure every time, because the composite - the three approvals that together rewrite the critical path - is never assembled and never evaluated against anything. within_band(proposal) is asking the right question about the wrong unit. Each agent's proposal is in-band. The bundle is not, and the bundle is what ships. There is no line in this code where the combined action is checked, because there is no representation of the combined action at all.

The right way: a coordinator that owns the composite band

The correct architecture adds a layer the per-agent gradient does not have: a coordinator that assembles the agents' proposals into the composite action they actually constitute, computes the band of that composite, and gates on it - before any agent executes.

# The coordinator assembles proposals into the composite they form, scores the# composite's blast radius, and gates on THAT - not on the parts.async def run_buildout(signal: DisruptionSignal, agents: list[Agent]) -> Result:    # 1. Agents propose. Nobody executes yet.    proposals = [await a.plan(signal) for a in agents]    # 2. The coordinator assembles the composite and scores ITS blast radius -    #    coupling effects the individual agents could not see.    composite = coordinator.assemble(proposals)    band = authority_for(        action=composite,        blast_radius=coordinator.coupled_impact(composite),   # critical-path,        irreversibility=coordinator.lead_time_lock(composite), # slot commitments,    )                                                          # milestone moves    # 3. The composite's band governs, even when every part was in-bounds.    if band is Band.ACT_WITHIN_BOUNDS and coordinator.within_envelope(composite):        # Composite stays inside policy: small, decoupled, reversible changes.        return await coordinator.commit(composite, agents)    # 4. Composite exceeds any single agent's authority -> human owns the bundle.    #    Not three separate approvals. One decision, evaluated as one.    return escalate_composite_to_human(composite, proposals)

The differences are the whole argument. No agent executes on its own; they propose, and the coordinator commits. The band is computed on the composite, using coupled_impact and lead_time_lock - exactly the cross-agent effects no individual agent can perceive, because each sees only its own slice. And the escalation is of the bundle as one decision, not three separate approvals a human rubber-stamps in sequence without seeing they form a critical-path rewrite. The coordinator's whole job is to be the thing that sees the composite and owns its authority. This is the orchestration-agent pattern the field already gestures at - an orchestrator coordinating task-specific agents with high-impact trade-offs escalated - made rigorous: the orchestrator is not a router, it is the holder of the composite's band.

One caveat keeps this honest: the coordinator does not dissolve the problem, it relocates it. coupled_impact and lead_time_lock are the hard part now. They need a live critical-path model - the digital twin Part 1 pointed at - and a stale or wrong coupling model reproduces the very failure, this time shipped with the coordinator's blessing and a false sense of safety. The coordinator is itself a fallible component. Two things bound that risk: default to escalation whenever the coupling estimate is uncertain, and watch the composite-violation rate, because a coordinator that is quietly mis-scoring the composite shows up there first.

Composed Authority

The pattern is worth naming, because it is the dimension the single-agent gradient is missing and it generalises to any multi-agent system, not just the buildout.

Call it Composed Authority: in a coordinated multi-agent system, the authority of the composite action is not the sum, the maximum, or any simple function of the agents' individual authorities - it must be computed fresh on the composite, because coupling creates blast radius that exists only at the system level. Three agents each authorised to move a small lever can, by moving them together, move a large one. The composite's irreversibility and blast radius can exceed every component's, and routinely does in tightly-coupled domains, because coupling is precisely the mechanism by which small local changes produce large global effects.

Composed Authority has a corollary that matters for design: you cannot make a multi-agent system safe purely bottom-up. Tightening every agent's individual band does not bound the composite, because the composite's band is not a function of the parts' bands. There must be a top-down element - a coordinator with visibility across agents and authority over the bundle - or the system has a category of action that nothing governs. This is the multi-agent generalisation of the series' recurring rule. In the single-agent articles, the boundary had to be enforced outside the agent because the agent could not be trusted to judge its own limit. Here, the boundary has to be enforced outside every agent, because no agent can even perceive the limit that matters - the limit is a property of the set, and no member of the set sees the set.

This also reframes what the orchestrator is for. It is tempting to think of an orchestrator as plumbing - a router that hands work to the right specialist and collects results. Composed Authority says the orchestrator's primary job is not routing. It is holding the authority band of the composite, the band no specialist can hold because no specialist can see the composite. An orchestrator that only routes, and lets each agent self-gate, is the wrong-way code: it has all the coordination and none of the authority.

Where each buildout action sits

The band placement for the buildout's real actions, with the unit of analysis made explicit - because in a multi-agent system the unit is sometimes the agent and sometimes the composite, and conflating them is the whole error.

Routine reordering of a stocked, short-lead, fungible component inside a policy threshold, with no critical-path coupling, is Act-within-bounds for the individual procurement agent. This is the genuine single-agent case: decoupled, reversible, small blast radius. It is also the only buildout action that safely stays a single-agent decision.

Any action that changes a long-lead-item slot - the 80-to-210-week components - is Advise at the composite level, even when the individual reorder is inside an agent's spend threshold, because a slot change on a coupled critical-path item has a blast radius measured in facility-energization weeks, not dollars. The spend threshold is the wrong envelope; the schedule impact is the right one, and only the coordinator can see it.

Any re-sequencing of the commissioning or energization plan is Advise at the composite level, full stop. Energization milestones are where every package's slippage converges; moving one is a facility-scale decision regardless of how small the triggering change looked.

Any bundle of individually-in-bounds actions that together move the critical path, re-cut multiple vendor commitments, or shift a milestone is Advise at the composite level - escalated as one decision. This is the opening failure, and the rule that prevents it is simply: the coordinator evaluates the bundle, not the parts.

Continuous monitoring, disruption detection, and surfacing early risk signals are Observe - and this is where the multi-agent system is genuinely, immediately valuable and safe, exactly as in SRE. Watching the whole coupled system for early signs of a slipping slot is high-value, read-only, and the right place to start.

The adoption sequence

The order follows the same logic as the rest of the series - capture the safe, high-value read-only work first - but with the multi-agent twist that the coordinator has to exist before any agent is allowed to act on a coupled decision.

Start with the coordinated system in pure Observe: many specialised agents watching procurement, logistics, and commissioning, surfacing coupled risks a human planner would miss, with zero execution authority. The value here is large and the risk is nil, because nothing acts. Then build the coordinator before granting any execution - the assembler that can see the composite and compute its band. Without it, granting even one agent execution authority on a coupled action is granting the system an ungoverned composite. Then allow single-agent Act-within-bounds only for the genuinely decoupled, short-lead, reversible reorders - the narrow set where the composite is the part. Everything coupled, everything long-lead, everything that touches the critical path or a milestone, stays Advise at the composite level, escalated as one decision to a human who sees the whole bundle. And measure how often the agents' individually-approved proposals would have composed into an out-of-bounds bundle if the coordinator had not caught them - that composite-violation rate is the multi-agent analogue of the false-positive and false-deadline rates from earlier parts, and it is the number that tells you whether your coordinator is earning its place.

Composed Authority checklist

Before you let a coordinated buildout system act on anything coupled, confirm:

• The composite is assembled, not just the parts. Some layer builds the bundle of proposals into the single action they form, before any agent executes.
• The composite has its own band. Its authority is computed on coupled blast radius and irreversibility - not read off, summed from, or maxed over the agents' individual bands.
• The coordinator holds the band, not the agents. Agents propose; the coordinator commits or escalates. An orchestrator that only routes and lets agents self-gate does not count.
• Coupled and long-lead actions escalate as one decision. Any slot change on an 80-to-210-week item, any milestone move, any critical-path rewrite goes to a human who sees the whole bundle - never three approvals in sequence.
• The composite-violation rate is measured. You track how often individually-approved proposals would have composed out-of-bounds if the coordinator had not caught them. That number tells you the coordinator is earning its place.

If any box is unchecked, the system has a category of action that nothing governs - the ungoverned composite at its center.

Where this lands

The buildout is the use case that breaks the single-agent frame, and breaking it is the point. Through five articles the question was always "what band is this agent in." The buildout forces the harder question: what band is the system in, when every agent in it is behaving perfectly. The answer is that you cannot read the system's authority off its agents' authorities, because authority does not compose. Coupling manufactures blast radius at the system level that exists nowhere in the parts, and a system of well-governed agents with no coordinator is a system with an ungoverned composite at its center.

The discipline is to add the layer the gradient did not have. Put the coordinated system in Observe and reap the coordination value safely. Build a coordinator that assembles proposals into the composite they form and owns the composite's band. Let single agents act alone only on the decoupled, reversible, small-blast-radius decisions where the part is the whole. And escalate every coupled bundle as one decision, to a human who can see what no agent in the system can - the shape of the thing they would build together.

Part 7 closes the series on the layer that makes all of this enforceable: AgentOps, the machinery of auditing, isolation, signed skills, and access control that turns every band assignment in this series from a diagram into a control - including, now, the coordinator's authority over the composite.

References

Agentic supply-chain orchestration and multi-agent coordination

• "Agentic AI In Supply Chain: 7 Trends For 2026" - Prolifics (Feb 2026). Source for the procurement-agent / logistics-agent multi-agent pattern, exception escalation, and the IDC 60%-by-2030 distributed-AI adoption projection.
• Bhushit, "Solving the Multi-Agent Coordination Problem in Global Supply Chains" (Mar 2026). Source for the shipping-canal scenario, the fifty-agents-identical-calculation emergent failure, and the strictly-competitive-and-local diagnosis.
• "Supply Chain Trends for 2026 - From Agentic AI to Orchestration" - SAP. Source for agents triggering corrective actions within trusted guardrails and the human-plus-machine exception model.
• "Procurement AI Agents in 2026" - JADA (2026). Source for negotiate-within-guardrails, escalate-compliance-issues, and multi-agent sourcing orchestration.
• "Autonomous Orchestration: A Multi-Agent Framework for Enterprise Supply Chain Intelligence" (2026). Source for the orchestration reference architecture with policy-grounded decision briefs, human-in-the-loop oversight, and digital-twin-validated plans.

The buildout constraint (lead times, coupling, coordination)

• "Why AI Data Center Projects Face Years of Delays After Approval" - Data Center Knowledge (2026). Source for the 50-to-120-week transformer lead-time growth, the 80-210-week range, and the PJM engineering-procurement/construction figures.
• "Key Data Center Construction Trends in 2026" - CMiC (Jan 2026). Source for "delays in any one package can stall commissioning across the entire facility" and the civil/structural/energization alignment requirement.
• "U.S. AI Data Center Delays: 7 GW Capacity Crisis" - Tech Insider (2026). Source for the binding-constraint shift to the physical electrical layer and "no single company can resolve [it] alone."
• "The Data Center Boom: Reality Check, Structural Bottlenecks, and Contractor Strategy" - DANAOS Projects (2026). Source for long-lead electrical equipment as the largest margin threat and the owner-furnished / escalation-clause coordination structures.

Related Articles

Agentic AI

• AgentOps: The Band Assignment Is a Comment Until Something Enforces It
• Cooling Is the Most Mature Agentic Use Case. That Is Exactly Why It Is the Most Misread.
• Agentic AI in the Data Center Boom: A Unified Map of Where Agents Actually Run the Building
• At the Grid Boundary, Being Right Doesn't Grant Authority