The standard architecture for coordinating autonomous systems assumes a command node. Some central brain — whether human, software, or hybrid — receives information from distributed agents, makes decisions, and pushes commands back out. This works until the link goes down. Then you have a collection of expensive assets doing nothing useful, or worse, doing something independently that conflicts with what the others are doing.
For operations in contested environments, the link will go down. Count on it. Any peer adversary’s first move is degrading your communications. If your autonomous systems can’t function coherently without phoning home, they can’t function in the scenarios that matter most.
I’ve been building coordination architectures that don’t assume connectivity — systems where agents can arrive at collective decisions through local interaction, maintain coherent behavior as the network fragments and reforms, and degrade gracefully rather than catastrophically when isolated. This post covers the core problem and the approaches that actually work.
The Coordination Problem
Multi-agent coordination isn’t one problem. It’s several, and they have different solutions.
Spatial coordination — don’t collide, maintain formation, cover an area efficiently. This is the easiest class. Flocking algorithms, potential fields, and auction-based task allocation handle it reasonably well. Lots of mature work here.
Temporal coordination — synchronize actions across agents without a shared clock. Harder. Matters for anything involving simultaneous effects or sequenced operations.
Deliberative coordination — agents need to reason about goals, constraints, and each other’s likely actions to reach decisions that serve collective objectives. This is where most architectures fall apart without centralization.
The third category is where I’ve focused. When autonomous systems are informing or making decisions with real consequences — ISR cueing, resource allocation, engagement recommendations — you can’t reduce coordination to geometry. Agents need to actually reason, and that reasoning needs to cohere across the group without a central arbiter.
Why Centralization Fails in Contested Environments
The appeal of centralized coordination is obvious: one decision-maker means no conflicts, clear authority, simpler agents. The problems are equally obvious once you stress-test the assumption.
Single point of failure. Kill the coordinator, kill the swarm. This isn’t theoretical. Any adversary watching US investment in autonomous systems is thinking about how to decapitate the command node.
Comms dependency. Centralized architectures need low-latency, high-reliability links. In a Pacific scenario, in dense EW environments, in urban canyons — you don’t have that. Agents spend more time waiting for commands than acting.
Bandwidth scaling. The coordinator needs state from every agent and must push decisions to every agent. This scales poorly. A hundred-agent swarm might be tractable. A thousand probably isn’t. Replicator-scale deployments definitely aren’t.
Latency in the loop. Even when comms work, round-trip latency to a central node means decisions lag reality. In fast-moving tactical situations, stale decisions are wrong decisions.
Decentralized coordination trades some efficiency for resilience. You lose the clean optimality of central planning. You gain the ability to keep operating when conditions degrade.
Left: Single point of failure. Right: No single point of failure — the mesh survives node loss.
Consensus Without a Leader
The core technical challenge: how do agents agree on collective actions when no one’s in charge?
This isn’t unsolved. Distributed systems research has spent decades on consensus protocols. But most of that work assumes reliable networks with known participants — data centers, not battlefields. The relevant constraints for defense are harsher:
- Byzantine failures. Some agents might be compromised, spoofed, or feeding bad data. You can’t trust all inputs.
- Partial connectivity. The network graph is constantly changing. Some agents can talk to some others, but the topology shifts.
- Asynchrony. No global clock. Messages arrive out of order or not at all.
- Real-time requirements. Academic consensus protocols can take many rounds. Tactical decisions can’t wait.
What works under these constraints:
Local information aggregation. Each agent maintains a model of collective state based on what it observes directly and what neighbors report. Consistency is eventual, not immediate. Good enough for most coordination tasks.
Gossip-based dissemination. Information spreads through local exchanges. No broadcast required. Resilient to partitions — when the network fragments, each partition maintains local consistency and re-syncs when reconnected.
Belief propagation for collective estimation. Agents share probability distributions, not point estimates. Disagreement is explicit. You can reason about confidence in collective assessments.
Voting and auction mechanisms. For decisions that require discrete choices, lightweight voting protocols can produce majority decisions. Auction mechanisms allocate tasks without central assignment.
None of these require a coordinator. All of them degrade gracefully — partial connectivity means slower convergence, not failure.
Information spreads through local exchanges. No broadcast required. Each agent maintains an eventually-consistent view.
Structured Deliberation Across Agents
The harder problem is collective reasoning — when agents need to evaluate options, weigh tradeoffs, and commit to a course of action as a group.
My approach uses structured multi-agent debate. Each agent can propose actions, critique others’ proposals, and evaluate arguments. The process is adversarial by design — agents are encouraged to find flaws in each other’s reasoning. What survives the debate is more robust than what any single agent would produce.
This maps surprisingly well to military decision-making processes. MDMP, JOPPS, course of action analysis — they’re all structured deliberation. Multiple options generated, evaluated against criteria, war-gamed for weaknesses. The difference is doing it across machines without a human moderator forcing convergence.
Key mechanisms:
Proposal generation. Any agent can propose a collective action. Proposals include the action itself, the reasoning behind it, and expected outcomes.
Critique and refinement. Other agents evaluate proposals against their local information and objectives. Critiques must be specific — identify the flaw, provide counter-evidence, or propose an alternative.
Adaptive evaluation. Not all agents or arguments are weighted equally. Agents build local models of which peers provide reliable information and sound reasoning. Trust is earned through track record, not assigned by hierarchy.
Convergence criteria. The debate terminates when proposals stabilize — either consensus emerges or the group accepts that disagreement exists and falls back to predefined tiebreakers.
Causal reasoning. Agents reason about intervention effects, not just correlations. “If we do X, Y will likely happen because Z.” This makes the deliberation auditable — you can trace why the group reached a decision.
The output isn’t just a decision. It’s a decision with a reasoning trace, confidence levels, dissenting views, and identified uncertainties. This matters for human oversight. When the swarm recommends an action, commanders can inspect the argument structure, not just the recommendation.
Adversarial debate produces robust decisions. Proposals are stress-tested before commitment.
Safety Monitoring in Decentralized Systems
Decentralization makes oversight harder. No central node means no single point to enforce constraints. How do you ensure the collective doesn’t decide something that violates ROE or operational boundaries?
The answer can’t be “trust the agents.” Even well-designed agents can reach bad collective decisions through emergent dynamics. The answer also can’t be “require human approval for everything” — that defeats the purpose of autonomy.
What works is layered constraint enforcement:
Agent-level constraints. Every agent has hard-coded boundaries it won’t cross regardless of what the collective decides. These are the autonomy limits — the things an agent refuses to do even if instructed.
Collective decision validation. Before a group decision executes, each agent validates it against known constraints. Any agent can veto. This catches cases where the deliberation process produces something that’s locally acceptable to each participant but globally problematic.
Anomaly detection across the swarm. Monitor for behavioral patterns that suggest compromised agents, emergent pathologies, or drift from expected operating modes. This is a detection problem, not a prevention problem — you’re watching for signs that something’s going wrong.
Graceful authority recapture. When a human operator or higher echelon needs to override collective behavior, the architecture supports it cleanly. Commands propagate through the same gossip network used for coordination. Autonomy is delegated, not surrendered.
I’ve implemented this as a runtime monitoring layer that sits alongside the deliberation process — lightweight checks that don’t slow down coordination but catch the failure modes that matter.
constraints} L1 -->|Pass| L2{Collective
validation} L1 -->|Fail| B1[Blocked at source] L2 -->|Pass| L3{Anomaly
detection} L2 -->|Veto| B2[Any agent can block] L3 -->|Normal| E[Execute] L3 -->|Anomaly| A[Alert + increased monitoring] A --> E end H[Human Override] -.->|Authority recapture| D style B1 fill:#f66 style B2 fill:#f66 style A fill:#ff9
Defense in depth: multiple layers catch different failure modes. Humans can always recapture authority.
What This Looks Like Deployed
A realistic swarm coordination stack:
Perception layer. Each agent processes its local sensor feeds and builds a world model. Relevant observations propagate to neighbors.
Coordination layer. Agents exchange state, proposed actions, and critiques. The structured debate runs here.
Decision layer. Once convergence is reached, agents commit to their roles in the collective action. This includes handling the case where an agent’s role is “wait” or “observe.”
Execution layer. Agents act on their committed plans. Continuous monitoring detects when reality diverges from expectations.
Adaptation layer. When conditions change, agents signal that current plans are invalid. The coordination process re-triggers.
All of this runs locally on each agent. Network exchanges are small messages — proposed actions, critiques, state summaries. No high-bandwidth feeds to a central node.
When the network partitions, each fragment continues to coordinate internally. When fragments rejoin, state reconciliation runs automatically. The agents that were isolated for ten minutes don’t need a briefing — they catch up through gossip.
Sensor processing, world model] C[Coordination Layer
State exchange, debate, proposals] D[Decision Layer
Commitment, role assignment] E[Execution Layer
Action, monitoring] A[Adaptation Layer
Replan triggers] P --> C --> D --> E E --> A A -.->|Conditions changed| C end subgraph network [Network Partition Handling] direction LR G1[Group A] ---|Partition| G2[Group B] G1 --> G1C[Continues locally] G2 --> G2C[Continues locally] G1C -.->|Rejoin| R[State reconciliation] G2C -.->|Rejoin| R end
Each agent runs the full stack locally. Network partitions don’t halt operations — fragments coordinate independently and reconcile when reconnected.
Performance Characteristics
The tradeoffs are real and should be stated clearly:
Decision quality. Decentralized deliberation produces decisions that are more robust (stress-tested by debate) but potentially suboptimal (no global optimization). In stable environments, centralized planning wins on efficiency. In contested environments, the fragility of centralized planning costs more than suboptimality.
Convergence time. Multi-agent debate takes longer than single-agent decision-making. The more agents, the longer it takes. This is tunable — you can trade off deliberation depth against time — but it’s a real constraint for time-critical decisions.
Bandwidth requirements. Much lower than centralized architectures at scale. Instead of every agent talking to a coordinator, each agent talks to local neighbors. Scales roughly linearly with agent count rather than quadratically.
Failure tolerance. High. Losing individual agents degrades coverage, not function. Losing connectivity between groups doesn’t halt operations. The system bends rather than breaks.
The fundamental tradeoff: centralized systems optimize efficiency but sacrifice resilience. Decentralized systems sacrifice some efficiency for robustness under degraded conditions.
Where This Applies
The immediate applications:
Attritable swarms. Replicator-style mass deployment can’t rely on centralized control. Coordination needs to be built into each agent, robust to losses, scalable to large numbers.
Collaborative Combat Aircraft. CCA operating in contested airspace need to coordinate with minimal reliance on links back to manned wingmen or ground control.
Distributed maritime operations. Unmanned surface and subsurface vessels coordinating across wide areas where comms are unreliable.
Multi-domain ISR. Sensors across domains cueing each other, sharing information, prioritizing collection — without routing everything through a fusion center.
Logistics under attack. Autonomous resupply convoys adapting routes and priorities as conditions change and assets are lost.
The common thread: scenarios where you need coherent collective behavior from assets that can’t rely on constant connectivity to a command node.
Coordination)) Air Attritable swarms CCA formations ISR mesh Maritime USV coordination UUV networks Distributed sensing Ground Convoy adaptation Urban ISR Logistics under attack Multi-Domain Cross-domain cueing Sensor fusion Distributed C2
Limitations
Things I haven’t solved:
Trust bootstrap. How do agents start trusting each other in a new swarm? Current implementation assumes agents from the same deployment are initially trusted. Integrating agents from different sources at runtime — coalition scenarios — is harder.
Adversarial corruption. If an adversary compromises enough agents, they can potentially manipulate collective decisions. Byzantine fault tolerance helps but has limits. This needs more red-teaming.
Human-swarm interaction. The interface for humans to understand and influence swarm deliberation isn’t mature. Operators need to grasp collective reasoning quickly to provide meaningful oversight. Current tools are too slow and too detailed.
Heterogeneous capabilities. Current architecture assumes agents are roughly similar. Mixed swarms — UAVs with different sensors, different compute, different action sets — complicate the deliberation process.
Verification. Proving properties about emergent collective behavior is hard. You can simulate extensively, but formal guarantees remain elusive. T&E frameworks haven’t caught up with decentralized autonomy.
What Comes Next
Decentralized coordination isn’t optional for the future of autonomous systems. The comms environment won’t support centralized control at the scales and tempos that matter. Either autonomous systems learn to coordinate locally, or they remain dependent on infrastructure that adversaries will target.
The technical foundations are solid. Distributed consensus, gossip protocols, multi-agent reasoning — these aren’t speculative. The gap is in engineering these into production systems, validating them under realistic conditions, and building trust with operators and commanders.
That’s the work. The research is public, the code is open, and I’m interested in talking with anyone facing these problems operationally.
Working on autonomous coordination or multi-agent systems? Reach out at [email protected].