The Limits of the Hub-and-Spoke Architecture
Standard federated learning relies on a star topology: a single central server orchestrates thousands of edge devices. While conceptually simple, this architecture suffers from a fundamental scalability flaw. As the client pool expands, the central server must handle concurrent uploads and downloads for every individual participant. As Zichang Liu et al. point out in Efficient and Less Centralized Federated Learning, this star-topology constraint creates a severe bandwidth bottleneck at the primary server, strictly limiting the system's scalability.
This bottleneck manifests as poor "weak scalability"—a phenomenon where adding more participants causes communication costs to skyrocket even if the local workload per client remains fixed. In their empirical evaluation on supercomputing clusters, Gianluca Mittone et al. demonstrated in Benchmarking Federated Learning Frameworks' Scalability that communication time quickly eclipses actual training time as the network scales. Furthermore, as Zhifeng Jiang argues in Towards Efficient Synchronous Federated Training: A Survey on System Optimization Strategies, while client-side constraints are heavily studied, the central aggregator inevitably becomes the ultimate bottleneck when model sizes and participant numbers scale to millions.
Hierarchical Aggregation: Introducing Middle Management
To alleviate the pressure on the central server, one prominent strategy restructures the network into a tree-like hierarchy. Instead of every device communicating directly with a distant cloud server, devices are grouped into local clusters managed by intermediate edge nodes.
The intuition here is a "divide-and-conquer" approach to data aggregation. For instance, in cellular networks, Mehdi Salehi Heydar Abad et al. proposed in Hierarchical Federated Learning ACROSS Heterogeneous Cellular Networks an architecture where mobile users first synchronize with local small cell base stations. These edge nodes perform a preliminary aggregation before transmitting the combined updates to a central macro base station. By filtering and merging updates locally, this approach achieves massive communication speedups without sacrificing global model accuracy.
However, hierarchical systems introduce a new trade-off: the bottleneck is shifted rather than entirely eliminated. As the authors of SCALE: Self-regulated Clustered federAted LEarning in a Homogeneous Environment observe, if edge devices themselves act as temporary cluster heads, the increased computational and communication load of merging numerous local updates can quickly overwhelm their local battery and processing constraints.
Decentralized Topologies: Eliminating the Coordinator
A more radical departure from the star topology removes the central coordinator entirely, transitioning to a peer-to-peer (P2P) or decentralized architecture. In these systems, models are updated via localized consensus mechanisms where devices only exchange information with their immediate neighbors.
Consider the communication complexity of model aggregation. In a standard centralized setup, scaling to $N$ devices requires substantial server bandwidth. By contrast, the authors of MAR-FL: A Communication Efficient Peer-to-Peer Federated Learning System demonstrate that an iterative, group-based P2P aggregation scheme can reduce communication overhead significantly, enabling training across massive networks without a single point of failure. Similarly, Xiaopeng Jiang et al. developed a zone-based framework in Zone-based Federated Learning for Mobile Sensing Data that partitions geographical space into localized zones, allowing gradients to diffuse naturally between neighbors rather than routing through a central hub.
Yet, decentralization introduces severe security vulnerabilities. In a centralized system, the server can inspect updates to filter out malicious behavior. In a decentralized architecture like Ring-All-Reduce—where updates are passed sequentially in a circle—this global oversight is lost. As Minghong Fang et al. note in Byzantine-Robust Federated Learning over Ring-All-Reduce Distributed Computing, a single malicious "Byzantine" client can easily poison the entire model because no single entity has the visibility required to detect and isolate the attack.
Physical-Layer Aggregation: Merging Signals in the Air
Rather than changing the network topology, another paradigm bypasses the communication bottleneck by rethinking how data is transmitted over wireless channels. Traditional wireless protocols rely on orthogonal communication, meaning each client is assigned a unique time or frequency slot to avoid interference. As a result, the time required to collect updates scales linearly ($O(N)$) with the number of devices.
Over-the-Air (OTA) computation turns the problem of wireless interference into a solution. Because wireless transmissions naturally superimpose when broadcast simultaneously on the same frequency, the physical medium itself acts as an analog aggregator. Deniz Gunduz et al. exploited this property in One-Bit Over-the-Air Aggregation for Communication-Efficient Federated Edge Learning: Design and Convergence Analysis by combining one-bit gradient quantization with broadband digital aggregation. Because all devices transmit at the exact same time, the communication latency remains entirely constant, completely decoupling the scaling of the participant pool from the time required to complete a training round.
Key Foundational Work
Throughput-Optimal Topology Design for Cross-Silo Federated Learning (2020) — contributed 1 concept elements to this direction.
Hierarchical Federated Learning Across Heterogeneous Cellular Networks (2020) — contributed 1 concept elements to this direction.
BACombo—Bandwidth-Aware Decentralized Federated Learning (2020) — contributed 1 concept elements to this direction.