Decentralized Coordination via Local Graph Neural Networks

This direction is split into other directions: emergent collective behavior. Its last version stays readable and citable here.

Version 1 of 1421 papers534 conceptsfrozen 2026-10-04

In traditional multi-agent systems, coordination is often treated as a centralized optimization problem. A "global brain" collects the states of every robot, computes a joint plan, and beams instructions back to the fleet. While effective for small groups, this approach collapses under its own weight as the number of agents grows. The communication bandwidth explodes, the computational complexity becomes intractable, and a single point of failure can paralyze the entire swarm.

A growing body of research suggests a more resilient alternative: Decentralized Coordination. By leveraging Graph Neural Networks (GNNs) and local message-passing, researchers are proving that complex global behaviors—like flocking, formation control, and collision-free navigation—can emerge from purely local interactions.

The Graph as a Communication Topology

The core intuition behind this research direction is to treat a multi-agent system not as a list of coordinates, but as a dynamic graph. In this framing, each agent is a node, and an edge exists between two agents if they are close enough to communicate or sense one another.

As Fernando Gama, Amanda Prorok, and their colleagues demonstrate in Decentralized Control with Graph Neural Networks, GNNs are the natural mathematical tool for this structure. Because GNNs operate through local message passing, each agent only needs to process information from its immediate neighbors. This mirrors the physical reality of decentralized robotics, where a drone might see its three closest peers but has no idea what a drone a mile away is doing.

Why GNNs Work: Permutation Invariance and Locality

Why are GNNs specifically so effective for this task? The answer lies in two properties:

  1. Permutation Invariance: In a swarm, it shouldn't matter if "Robot A" is to your left and "Robot B" is to your right, or vice versa. GNNs are designed to be indifferent to the ordering of neighbors, allowing the learned policy to focus on the spatial relationships rather than agent IDs.
  2. Locality: Because the architecture is built on K-hop neighborhoods, the computation required for one agent remains constant regardless of whether there are 10 or 10,000 agents in the total system.

This locality allows for remarkable zero-shot scalability. Elijah S. Lee and Alejandro Ribeiro showed in Learning Decentralized Strategies for a Perimeter Defense Game with Graph Neural Networks that policies trained on small teams can be deployed on much larger groups without retraining, maintaining performance even as the environment scales.

From Local Rules to Global Emergence

The transition from local sensing to global coordination is often modeled as a "Neural Cellular Automaton." In Learning Graph Cellular Automata, Daniele Grattarola and Lorenzo Livi illustrate how GNNs can learn local transition rules that drive a collection of nodes to self-organize into complex geometric structures.

This "local-to-global" pipeline is visible across various domains:

Negotiate-then-Commit: The Human Element

In unstructured environments, decentralized coordination often looks less like rigid optimization and more like social negotiation. Dequan Wang and colleagues, through the Berkeley DeepDrive Drone (B3D) dataset, propose a "negotiate-then-commit" framework. Instead of predicting every other agent's move, agents use local state sensing to reach a consensus, mimicking how human drivers navigate busy, unregulated intersections.

By shifting the focus from global oversight to local intelligence, this research direction provides a blueprint for swarms that are not just larger, but more robust, adaptive, and computationally efficient. The "intelligence" of the swarm is no longer in a single server, but in the very connections between the agents themselves.

Papers in this version

Showing 60 of 421 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_decentralized_coordination_via_local_gra_99cdde74,
  title = {Decentralized Coordination via Local Graph Neural Networks},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/decentralized-coordination-via-local-graph-neural-networks/rdr_99cdde7401714d478653f9f787253085},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_decentralized_coordination_via_local_gra_99cdde74_v1,
  title = {Decentralized Coordination via Local Graph Neural Networks},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/decentralized-coordination-via-local-graph-neural-networks/rdr_99cdde7401714d478653f9f787253085/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}