Multi-robot coordination and swarms

One robot doing one task is a solved problem. N robots doing related tasks is its own field with its own math, software stacks, and failure modes. From bimanual humanoids to 1000-drone light shows to warehouse fleets of 100 AGVs, multi-robot systems are an increasing share of robotics in 2026. Here's the working knowledge.

The three coordination patterns

1. Centralized

One brain controls all robots. Knows everyone's state, plans for everyone, sends commands.

Strengths: optimal coordination; easy to reason about; one point to debug.

Weaknesses: single point of failure; doesn't scale (the brain becomes the bottleneck); high communication bandwidth.

Use for: small teams (2–10 robots) with reliable comms. Bimanual robots, small drone shows, structured warehouses.

2. Decentralized

Each robot makes its own decisions based on local observations + neighbor communication. No central planner.

Strengths: scales to 1000s; robust to individual failures; no single bottleneck.

Weaknesses: globally optimal behavior is hard; emergent behavior can surprise.

Use for: large drone swarms, search-and-rescue, biological-inspired flocking.

3. Hierarchical

Local autonomy with high-level coordination. Each robot is autonomous within its zone; a top-level planner allocates tasks to robots.

Strengths: balance scalability and optimality; production-friendly.

Weaknesses: interface design between layers is tricky.

Use for: warehouse fleets (10–500 robots), agricultural fleets, autonomous trucks platooning.

Task allocation

The fundamental question: who does what?

Auction-based

Each robot bids on each task; central auctioneer picks winners. Bid = cost-to-complete (distance, time, capability fit). Variants: single-item auctions, combinatorial auctions, sequential auctions.

Used in warehouse robotics (Amazon's predecessor Kiva system). Simple, near-optimal in practice.

Consensus-based

Robots negotiate task assignment via local communication. Distributed; no auctioneer.

Theoretical literature is rich (Bertsekas's auction algorithms, distributed Hungarian algorithm). Production deployments are rarer than auction.

Market-based

Each robot has a "budget"; tasks are priced; robots trade tasks. Often used in research; rarer in production.

RL-learned allocation

Treat task allocation as an RL problem; train a policy that allocates tasks given system state. Recent direction; practical for medium-scale fleets.

Communication architectures

• WiFi mesh: cheapest; works for 10–100 robots; bandwidth degrades with distance.
• 5G / LTE: reliable, broad coverage; needs cellular subscription per robot.
• UWB beacons: precise relative localization (~10 cm) at short range; useful for swarms.
• Optical / IR: line-of-sight only; very fast (gigabit possible); used in indoor swarms.
• Acoustic (underwater): AUV swarms; very narrow bandwidth.

For most ground / air robotics in 2026: WiFi mesh + ROS 2's DDS or Zenoh. For long-range outdoor: 5G + iceoryx.

The classical algorithms

Reynolds boids (1986)

Three rules per agent:

• Separation: avoid neighbors that are too close.
• Alignment: match neighbors' velocity.
• Cohesion: move toward neighbor average.

Produces flocking. Used in modern drone shows; basis for many swarm algorithms.

Optimal Reciprocal Collision Avoidance (ORCA)

Each robot picks a velocity that's safe assuming all neighbors do likewise. Provable collision-free under perfect comms; widely used in crowd simulation.

Hungarian algorithm

Optimal task-to-agent assignment in O(n³). Used in warehouse fleet managers.

Auction algorithms (Bertsekas)

Distributed Hungarian. Each agent bids on tasks; iterates until equilibrium.

The MARL approach

Multi-Agent Reinforcement Learning trains policies that coordinate via shared experience. Each agent observes its local state (+ optionally neighbors); acts; receives reward.

• Centralized training, decentralized execution: train with full info; deploy with local-only.
• Communication learning: agents learn what to communicate.
• Cooperative multi-agent: shared reward; agents work together.
• Competitive: zero-sum; agents adversarial (rare in robotics).

MARL is research-active in 2026. Production fleets still mostly use auction-based allocation + collision avoidance — MARL hasn't conclusively displaced classical methods at scale.

Production deployments

Domain	Architecture	Scale
Amazon warehouse	Centralized fleet manager + auction allocation	100s–1000s of AGVs
Drone shows (Intel, EHang)	Pre-computed centralized choreography	100–10000 drones
Highway truck platoons	Decentralized; lead vehicle broadcasts	3–5 vehicles
Agricultural fleets	Hierarchical; per-zone autonomy	10–50 robots

The communication-bandwidth tradeoff

What each agent broadcasts shapes coordination:

• Position only: cheap; supports separation/cohesion.
• Position + velocity: enables predictive coordination.
• Full state (battery, task, etc.): enables auction allocation.
• Local maps: enables shared SLAM; bandwidth-heavy.

Design principle: broadcast the minimum that enables coordination. More data = more bandwidth = more comms failures.

Common gotchas

• Network partitioning: WiFi connectivity drops; sub-groups operate independently. Each group must handle alone gracefully.
• Time synchronization: actions across robots need synchronized clocks. NTP, PTP, or GPS time.
• Identity conflicts: two robots with same ID; one disappears. Use UUIDs.
• Liveness detection: if a robot dies silently, others assume it's still there. Heartbeats; timeouts.
• Swarm size scaling: an algorithm that works for 5 robots might fail for 50; communication explodes.

The 2026 frontier

• Foundation models for swarms: shared learned representations across agents.
• Heterogeneous fleets: drones + ground robots + arms cooperating on shared tasks.
• Soft swarms: many soft / compliant robots in physical contact (modular robotics, robot collectives).
• Multi-robot VLAs: a single VLA model controls multiple coordinated agents.

Open libraries and frameworks

• Crazyswarm2: research swarm framework; Crazyflie hardware; Python.
• ROS 2 multi-robot examples: namespace-based separation; standard patterns.
• RVO2: ORCA-based collision avoidance library.
• Buzz: research-focused programming language for swarms.
• UTSwarm / Mavros multicopter: drone-specific swarm control.

Where to start

1. Read Reynolds' boids paper (~10 pages; foundational).
2. Implement boids in 2D Python sim. Watch the flocking emerge.
3. Move to Crazyswarm with a few Crazyflies (~$200 each).
4. Do a 5-drone show coordinated by a central PC.
5. Add task allocation; have drones split work.

The progression from "two robots" to "robot swarm" is intellectually clean; the engineering is in handling communication failures and identity correctly.

Exercise

In a 2D Python sim with 50 agents, implement Reynolds boids. Tune separation/alignment/cohesion weights. Watch flocking emerge. Then add a goal point each agent should reach; observe how flocking + goal-seeking interact. Multi-robot coordination intuition in an afternoon.

Next

Soft robotics — the assumption-breaking field where everything you learned about rigid robots needs adaptation.