Mitigating Communication Overhead in Multi-Agent Systems

61 concepts60 papers2 proposals

In multi-agent systems (MAS), cooperation is traditionally achieved through information sharing. Whether a team consists of autonomous drones mapping a disaster zone, robotic arms assembling a vehicle, or large language model (LLM) agents solving a data science problem, coordination requires agents to know what their peers are doing.

For a long time, theoretical frameworks bypassed the logistics of this exchange by operating under a "zero-cost communication" assumption, treating bandwidth as infinite and latency as zero (Martin Allen et al. in Language Learning in Multi-Agent Systems; Junning Shao et al. in Learning with Limited Shared Information in Multi-agent Multi-armed Bandit).

In reality, communication is often the primary system bottleneck. Samuel Wiggins et al. demonstrated that in multi-agent reinforcement learning (MARL), inter-agent communication protocols and data dependencies can consume up to 70% of total execution time (Characterizing Speed Performance of Multi-Agent Reinforcement Learning). When every agent broadcasts its state to every other agent, networks quickly saturate, packets collide, and agents become flooded with redundant "noise" (Ziluo Ding et al. in Learning Individually Inferred Communication for Multi-Agent Cooperation; Diyi Hu et al. in Learning Practical Communication Strategies in Cooperative Multi-Agent Reinforcement Learning). Furthermore, in modern LLM-based multi-agent workflows, excessive communication translates directly into unsustainable token costs and API latency (Lingfeng Zhou et al. in Credit-Budgeted ICPC-Style Coding: When Agents Must Pay for Every Decision).

To build scalable multi-agent systems, researchers have shifted from maximizing information exchange to minimizing communication overhead. The core insight driving this research direction is simple: communication should be treated as a strategic, costly action. Agents must only communicate when the expected value of the information exceeds the physical or computational cost of transmitting it.


Quantifying the Utility of Communication

To limit communication, agents must first evaluate whether a message is worth sending. A foundational approach to this problem is the Recursive Modeling Method (RMM) introduced by Piotr J. Gmytrasiewicz et al. in The Utility of Communication in Coordinating Intelligent Agents. Instead of blindly transmitting data, an agent uses RMM to compute the "Utility of Communication"—the expected increase in the group's payoff resulting from a message minus the cost of the bandwidth consumed. If the message will not alter the recipient's optimal action, it is suppressed.

Another way to minimize online overhead is to pre-calculate communication boundaries before deployment. In Efficient Offline Communication Policies for Factored Multiagent POMDPs, João V. Messias et al. analyze the mathematical structure of decentralized tasks offline. By identifying "safe" environmental states—where an agent's local observations are mathematically guaranteed to be sufficient for optimal decision-making—the agents can completely skip data sharing during execution without sacrificing performance.


Spatial and Structural Sparsity: Who to Talk To

In a large network, broadcasting messages to all participants scales poorly. Effective frameworks reduce overhead by enforcing structural sparsity, ensuring agents only communicate within localized sub-networks.

Locality of Interaction

In many scenarios, an agent only needs to coordinate with its immediate neighbors. Ranjit Nair et al. formalized this via Networked Distributed POMDPs (ND-POMDPs), which map coordination constraints as a graph (Networked Distributed POMDPs: A Synthesis of Distributed Constraint Optimization and POMDPs). Agents only exchange policy information with entities that directly affect their local reward functions. Similarly, Hangyu Mao et al. utilize Graph Convolutional Networks to align the internal representations of nearby agents, achieving "neighborhood cognition consistency" without global data broadcasting (Neighborhood Cognition Consistent Multi-Agent Reinforcement Learning).

Causal Pruning

Even within a local neighborhood, not all information is relevant. Ziyuan Ma developed a protocol called Decision Causal Communication (DCC) for multi-agent pathfinding (Learning Selective Communication for Multi-Agent Path Finding). Instead of sharing positions with every nearby robot, an agent performs a causal check to determine which neighbors' trajectories actually influence its own pathing choices. If no causal dependency exists, the communication channel remains closed.

This concept of sparse dependency is mirrored in dynamic game theory, where the authors of Policies with Sparse Inter-Agent Dependencies in Dynamic Games: A Dynamic Programming Approach demonstrate that Feedback Nash Equilibria can be maintained even when agents ignore the real-time states of non-critical participants.

[Standard Broadcast]
Agent A ------> B, C, D, E, F (High Overhead / Noise)

[Causal / Local Sparsity]
Agent A --(Causal Check)--> Only Agent B (Minimal Overhead)

Temporal Sparsity: When to Talk

Continuous state streaming rapidly depletes battery life and network capacity. To achieve temporal sparsity, systems must transition from continuous updates to discrete, intent-driven communication.

Event-Triggered Control

Instead of communicating at every clock tick, agents can use event-triggered mechanisms. As highlighted by Mengru Ma et al. in New advances in complex motion control for single robot systems and multi-agent systems, event-triggered coordination forces agents to remain silent until a specific threshold is crossed—such as a significant deviation from a planned trajectory. This is demonstrated effectively in spatial coverage tasks, where robots update their neighbors only when their local Voronoi partitions change beyond a set tolerance, drastically reducing wireless bandwidth consumption (Distributed Event- and Self-Triggered Coverage Control with Speed Constrained Unicycle Robots).

Predictive Partner Modeling

If an agent can accurately predict what its teammates will do, it doesn't need to ask them for updates. Chenhang Xu et al. designed the Decentralized Adaptive Partner Modeling (DAPM) framework, which uses fictitious self-play to let agents simulate partner behavior internally (Decentralized multi-agent cooperation via adaptive partner modeling). An adaptive rollout mechanism tracks the expected error of this internal simulation; real-world communication is triggered only when the simulation error bounds are violated.

By blending these shared "intentions" with heuristic-based predictions, single-author work by Minglong Li shows that decentralized Monte Carlo Tree Search can maintain high coordination accuracy while using a fraction of the standard bandwidth (Integrating Decision Sharing with Prediction in Decentralized Planning for Multi-Agent Coordination under Uncertainty).


Information Bottlenecks and Representation Coarseness

When communication is necessary, the message itself should be as compact as possible. In deep learning-based MAS, this is often achieved by passing continuous vector representations through a discrete bottleneck.

Dianbo Liu et al. expanded this concept by introducing Dynamic Vector Quantization (DVQ) (Adaptive Discrete Communication Bottlenecks with Dynamic Vector Quantization for Heterogeneous Representational Coarseness). Recognizing that different environmental states require varying levels of detail, DVQ adaptively adjusts the tightness of the communication bottleneck based on the complexity of the immediate situation. Agents send highly compressed, coarse codes during routine tasks, but dynamically scale up message complexity when encountering novel or difficult scenarios.

Similarly, Variance Based Control (VBC), proposed by Sai Qian Zhang et al., cuts down overhead by monitoring the variance of sub-channel communications, pruning out low-variance elements that contribute little to the receiver's policy update (Efficient Communication in Multi-Agent Reinforcement Learning via Variance Based Control). To guarantee safety in tight control loops without saturating networks, Mo Yang et al. leverage System Level Synthesis (SLS) to relax control constraints into a convex rank minimization problem, cutting inter-agent messages by up to 94% (Safe Control of Multi-Agent Systems with Minimal Communication -> /paper/art_04ef75890d184e939d58864b59bb49bb).


Modern Extensions: Token Optimization in LLM Swarms

The problem of communication overhead has re-emerged prominently in LLM-based multi-agent systems. When multiple specialized LLM agents operate via a "broadcast-and-volunteer" mechanism—such as a shared blackboard system—operational costs skyrocket because every agent must independently process every shared request to evaluate its own relevance (Alireza Salemi et al. in LLM-based Multi-Agent Blackboard System for Information Discovery in Data Science).

To mitigate this, researchers are applying classical hierarchical and structural coordination principles to language models. For instance, Stefan Nielsen et al. introduced The Conductor, a specialized 7B-parameter model trained via reinforcement learning to act as a centralized manager for a pool of larger worker models (Learning to Orchestrate Agents in Natural Language with the Conductor). Instead of allowing free-form, redundant dialogue between agents, The Conductor explicitly decomposes tasks and designs sparse, targeted communication flows.

This structural constraint mirrors early insights from Michael J. Wooldridge et al., who noted that balancing agent granularity against communication protocols is essential to prevent distributed software from spending more resources on synchronization than on actual execution (Software Engineering with Agents: Pitfalls and Pratfalls). By embedding explicit tool-calling objectives directly into task graphs rather than relying on open-ended consensus negotiation, modern frameworks like GeoFlow achieve significant performance gains while simultaneously reducing token consumption fourfold (Amulya Bhattaram et al. in GeoFlow: Agentic Workflow Automation for Geospatial Tasks).

Key Foundational Work

The Clarke Tax as a Consensus Mechanism Among Automated Agents (1991) — contributed 1 concept elements to this direction.
The Utility of Communication in Coordinating Intelligent Agents (1991) — contributed 1 concept elements to this direction.
Predictability Versus Responsiveness: Coordinating Problem Solvers in Dynamic Domains (1988) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_inter_agent_communication_overhead_e1ef7c82,
  title = {inter-agent communication overhead},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/inter-agent-communication-overhead/rdr_e1ef7c8235ee4bd18889ead54763ed6d},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_inter_agent_communication_overhead_e1ef7c82_v1,
  title = {inter-agent communication overhead},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/inter-agent-communication-overhead/rdr_e1ef7c8235ee4bd18889ead54763ed6d/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake