A Fleet Is Not a Bigger Agent
One autonomous agent has a single decision point. You can reason about its failure modes, trace its proposals, and explain why it did what it did. The governance problem is tractable.
A fleet is not that problem at a larger size. It is a different problem. Decisions interact. Agent A's action rewrites the state Agent B is reasoning about. Agent C waits on output A is still producing while handling something unrelated. An external signal lands while several decisions are mid-flight. The fleet is a distributed system, and distributed systems fail in ways no single component can anticipate or prevent.
Without governance, the failure modes are depressingly predictable: redundant decisions stacking into oversized positions, agents pursuing conflicting strategies that cancel each other out, cascades running down dependency chains, resource exhaustion from independent allocation, and epoch desync where agents at different speeds act on incompatible views of the same world. These are not corner cases. They are the baseline behavior of an uncoordinated fleet.
Governance Without a Central Dictator
The naive fix is a master coordinator that hands each agent its orders. That buys you a single point of failure. If the coordinator dies, the fleet dies. If it is slow, the fleet is slow. And to give good orders, it needs a complete model of every agent's behavior, which is the original problem moved up one level and made harder.
The governed fleet works differently. Agents do not coordinate with each other. They coordinate with a shared governance layer, and that layer does not direct behavior. It constrains it.
Each agent proposes independently. The governance layer evaluates all proposals against fleet-level constraints: total leverage, total resource use, coherence with shared state, authorization integrity. It approves, modifies, or rejects. Approved proposals execute, fleet state updates, receipts are logged. Agents stay independent at the proposal stage. Governance is centralized at the authorization stage. Execution is distributed. The fleet behaves as one coherent thing without any agent knowing what the others are doing.
The Constraints Only the Fleet Can See
Some constraints are meaningless at the level of a single agent. They exist only at the fleet level, and only the fleet layer can enforce them.
Leverage is the textbook case. Agent A proposes a position taking its individual exposure to 80% of allocation. Fine, on its own. Agent B proposes something similar. Also fine, on its own. Together they have consumed more collective exposure than policy permits, and neither one can detect it. Only the governance layer, holding both proposals at once, can enforce the fleet constraint.
Resource allocation works the same way. Give a fleet a fixed compute budget and let five agents each request a quarter of it, and someone has to resolve the oversubscription. That resolution cannot happen at the agent level, because no agent knows what the others are asking for. The governance layer does.
Regime-level vetoes are a third case. When the market tips into high volatility, the right fleet response may be to allow exits but forbid new entries across every agent at once. That is a fleet-wide decision. Individual agents cannot implement it without coordination. The governance layer implements it as a single policy check applied to every incoming proposal. None of this is hard once the architecture is right. All of it is impossible if agents run autonomously with no shared authorization layer.
Sharding Governance Without Losing Its Properties
A single governance layer fielding proposals from many agents becomes a throughput bottleneck if you are careless about it. The answer is to shard governance into two tiers without giving up its guarantees.
Local gates run on each agent. They check individual constraints: is the proposal well-formed, is it inside the agent's own allocation, does it violate any agent-specific policy? A proposal that fails a local gate never reaches the fleet layer. This drops most invalid proposals at the source.
Global gates run on the governance layer. They check fleet constraints: aggregate leverage, collective resource use, coherence, authorization integrity. They only ever see proposals that already cleared local gates.
The result is that the governance layer's workload tracks the number of valid proposals, not the total. Local gates absorb the noise. Global gates make the calls only the fleet can make. And the sharding does not weaken safety: a proposal that somehow skips a local gate still must clear the global gates. There is no path to execution that bypasses global governance.
Epoch-Based Synchronization
Synchronization across agents is one of the hardest problems in distributed systems. The classical answer is consensus: agents exchange messages, vote on state, and converge. Those protocols are expensive, brittle under partition, and slow at scale.
A governed fleet sidesteps most of it with epoch-based operation. An epoch is a discrete window in which agents generate proposals. At the boundary, proposals are collected, governance evaluates them together, approved ones execute, the ledger updates, and the new state is broadcast to every agent. Then the next epoch opens.
Agents never have to synchronize with each other while generating proposals. They work in parallel, independently. Synchronization happens once per epoch, at the governance layer, which is the single authoritative source of truth for system state.
That erases a whole class of coordination bugs. There is no split-brain, because there is only one brain making authorization decisions. There is no stale-state problem inside an epoch, because every agent starts the epoch from the same broadcast. There is no execution race, because every execution happens after governance has resolved the full proposal set. The cost is latency: proposals wait for the boundary. For high-frequency systems, make epochs short. For systems where correctness outranks speed, make them longer. The guarantee is identical either way.
Heterogeneous Agents Under One Governance
Real fleets are rarely uniform. A live fleet might mix agents with different risk profiles, timescales, strategies, and authorization levels. Managing that spread without governance is chaos. With governance it is routine.
Role-based authorization handles it cleanly. Each agent operates under a role that fixes its constraints: maximum position size, allowed asset classes, minimum hold duration, leverage limits. Governance checks each proposal against that agent's role, not against one flat fleet-wide rule.
Fleet constraints then sit on top of role constraints. An agent might be individually cleared for a large position, but if that position pushes fleet leverage out of bounds, the global gate rejects it regardless of role. The outcome is structured diversity. Each agent has its own parameters. The fleet has its own. Governance enforces both at once, and no agent needs to know any other agent's role or current position.
What Governed Fleets Make Possible
The properties that emerge here are not reachable any other way.
Fault tolerance: if one agent dies, the rest keep running under the same governance. The dead agent's authorization is suspended, and when it recovers it rejoins under the same layer without disrupting anyone.
Diversity without risk amplification: agents with genuinely different strategies can coexist. Their diversity produces uncorrelated decisions, and the governance layer keeps their combined behavior inside fleet constraints. You get the analytical benefit of many independent views without the danger of uncoordinated execution.
Scalable auditability: the receipt chain spans the whole fleet. Every proposal, gate decision, and execution lands in one coherent record. Adding agents does not fragment the trail. The governance layer is the trail.
Operational scalability: adding an agent means connecting it to the governance layer, defining its role, and configuring its local gates. The existing infrastructure does not change. The fleet simply inherits the new agent's proposals under the same regime.
The Architecture Is the Coordination
Fleet coordination is not a communication problem. Agents do not need to talk to each other. They need to run under the same authoritative governance layer.
When every agent shares the same governance code, the same authorization function, and the same broadcast state, they are coordinated by construction. No voting rounds. No consensus protocol. The governance layer decides, and every agent accepts it. That is consensus without the communication overhead.
The principle holds: let intelligence be distributed and independent. Let governance be centralized and authoritative. The fleet's coherence is a property of the governance layer, not of the agents. That is how chaos becomes order.