Hub-and-spoke is the default. It is so dominant in distributed AI systems that it often goes unnamed — it just is how systems are built. But the hub is always the ceiling. This article explains exactly where the architecture breaks down and what Christopher Thomas Trevethan's Quadratic Intelligence Swarm (QIS) does structurally differently.
Q: What is hub-and-spoke architecture in the context of distributed AI?
In hub-and-spoke, one central node (the hub) coordinates all others (the spokes). Every spoke communicates with the hub; spokes do not communicate with each other. Intelligence — aggregation, routing, synthesis, arbitration — lives in the hub.
The pattern appears across the distributed AI stack under different names:
- Federated learning: Central aggregator is the hub. Local training nodes are the spokes. The FedAvg algorithm (McMahan et al., 2017) sends gradient updates from all spokes to the aggregator, which averages them and redistributes the updated model.
- RAG pipelines: The retrieval orchestrator is the hub. Vector databases, document stores, and tool servers are the spokes. Every query routes through the orchestrator.
- Multi-agent orchestration (LangGraph, AutoGen, CrewAI): The orchestrator node is the hub. Every agent call routes through it. AutoGen's GroupChatManager is the hub. CrewAI's Crew orchestrator is the hub.
- Healthcare data networks (OHDSI/OMOP, PCORnet, TriNetX): The coordinating center is the hub. Participating institutions are the spokes. Queries are dispatched from the hub, aggregated at the hub, published from the hub.
- Enterprise data fabrics and MDM platforms: The master data repository is the hub. Domain systems are spokes. Synchronization radiates from the center.
These are not accidents of design. Hub-and-spoke is easy to reason about, easy to secure, and easy to govern. It dominated distributed systems thinking precisely because it works — up to a scale threshold.
Q: What are the specific failure modes of hub-and-spoke at scale?
There are four structural failure modes, each with a different onset threshold:
Failure Mode 1: The Hub Becomes a Throughput Bottleneck
In a hub-and-spoke network of N spokes, every message touches the hub. As N grows, hub throughput requirements grow linearly with N. If each spoke generates k messages per unit time, the hub must process N·k messages per unit time. Hub capacity is bounded by compute and bandwidth. When N·k exceeds hub capacity, the system throttles, queues, or fails.
The classical solution is hub replication — build N_hubs hub instances behind a load balancer. This delays the bottleneck but doesn't remove it: you now have a distributed hub cluster, which reintroduces consensus overhead and state synchronization costs. The ceiling has moved up, not been eliminated.
In federated learning terms: the central aggregator must receive, average, and redistribute gradient updates from all participating nodes per training round. At 10,000+ participating institutions (a real target for global health networks like OHDSI with 300+ institutions), the aggregator bandwidth and compute requirements become non-trivial. Studies at the FL scale required for privacy-preserving health analytics (Roth et al., 2020, Nature Machine Intelligence) report communication costs that grow with N in ways the spoke-count directly compounds.
Failure Mode 2: Hub Failure = Network Failure
When the hub fails, all spoke-to-spoke coordination fails simultaneously. There is no fallback routing path because spokes have no peer relationships — by design. This single-point-of-failure is well-understood and routinely mitigated with high-availability hub clusters, but mitigation is not elimination.
In healthcare networks, central aggregator downtime halts federated query processing for all participating institutions. In multi-agent systems, orchestrator failure drops in-flight tasks with no graceful recovery — the orchestrator holds the conversation state.
Failure Mode 3: Hub Latency Grows With Network Size
In a hub-and-spoke network where spokes need to share information, the round-trip path is: Spoke A → Hub → Spoke B → Hub → Spoke A. Every spoke-to-spoke exchange requires two hub hops. As the hub becomes busier (failure mode 1), the latency per hop grows. The effect compounds: spoke-to-spoke latency in a hub-and-spoke system scales super-linearly with N when the hub is under load.
For real-time AI applications — clinical decision support, autonomous vehicle coordination, live multi-agent task execution — this latency is not acceptable past a moderate scale threshold.
Failure Mode 4: The Hub Becomes a Governance and Privacy Liability
The hub sees everything. It receives gradients, routes queries, aggregates results. Even in a privacy-preserving architecture, the hub operator has more visibility than any spoke. This creates:
- Regulatory liability: HIPAA, GDPR, and similar frameworks place obligations on whoever processes data. A hub operator in a health data network is a covered entity or business associate with corresponding legal exposure.
- Governance concentration: Decisions about network membership, query access, and result publication flow through the hub operator. Spokes are dependent on hub operator governance decisions.
- Attack surface concentration: A compromise of the hub compromises the network's trust architecture. Recent gradient inversion research (Zhu et al., NeurIPS 2019; Geiping et al., NeurIPS 2020) shows that hub-held gradients can be used to reconstruct spoke training data.
In health data networks, this manifests as the institutional reluctance that limits federation to carefully vetted networks — not open science.
Q: What would a non-hub-and-spoke distributed intelligence architecture look like?
A truly hub-free architecture requires three properties that hub-and-spoke cannot provide:
Deterministic addressing without a directory: Spokes must be able to locate relevant peers without querying a central router. This requires addressing schemes that are derived from the content or semantic type of the message itself — not assigned by a hub.
Local synthesis without aggregation: Each node must synthesize relevant intelligence locally, from the set of peer packets it has received, without sending raw data to a central aggregator.
Logarithmic or constant routing cost per node: For the network to scale, each node's participation cost must grow at most logarithmically with N, not linearly.
The architectural approach that satisfies all three is what Christopher Thomas Trevethan discovered as the Quadratic Intelligence Swarm protocol on June 16, 2025, covered by 39 provisional patents.
Q: How does QIS avoid hub-and-spoke structurally?
The QIS loop does not have a hub:
Edge Node (raw data stays here)
↓
Local Processing → Outcome Packet (~512 bytes, distilled observation)
↓
Semantic Fingerprinting → vector derived from content
↓
Routing Layer → posts packet to address deterministic of the problem
↓
Any similar edge queries that address → pulls packets
↓
Local Synthesis → integrates relevant packets on the receiving device
↓
New Outcome Packets Generated → loop continues
There is no hub in this loop. The routing layer is a transport — a mechanism for posting a packet to an address and querying that address. The routing layer doesn't aggregate, doesn't arbitrate, doesn't hold state. DHT-based routing achieves O(log N) per node with no central coordinator (the BitTorrent and IPFS networks demonstrate this at planetary scale). Database semantic indices can achieve O(1). Message queues, REST APIs, pub/sub systems — any mechanism that maps a problem to a deterministic address and serves packets to queriers qualifies. The routing layer is protocol-agnostic.
Because every node posts to and queries from deterministic addresses — addresses derived from the semantic content of the problem, not assigned by any hub — the network routes itself. There is no directory service, no membership registry, no central scheduler.
Q: What is the scaling difference, with numbers?
In hub-and-spoke with N nodes:
- Hub processes: N messages per round (linear scaling)
- Spoke-to-spoke paths: always route through hub (2-hop minimum)
- Hub failure: O(N) nodes lose coordination simultaneously
- Hub latency under load: grows with N (queuing theory: M/M/1 queue at hub approaches instability as ρ → 1)
In QIS with N nodes:
- Per-node routing cost: O(log N) (DHT) or O(1) (indexed database)
- Node-to-node synthesis paths: N(N-1)/2 — every pair can synthesize because any node can query any deterministic address
- Single-node failure: zero network impact (no hub to fail)
- Latency: bounded by routing layer, independent of N at the architecture level
The synthesis opportunity count is the key number. In hub-and-spoke, spoke A and spoke B share intelligence only when the hub coordinates it — one path, mediated. In QIS, spoke A can query spoke B's address class directly at any time. With N=1,000 nodes:
- Hub-and-spoke synthesis paths: N = 1,000 (hub mediates all)
- QIS synthesis paths: N(N-1)/2 = 499,500
The quadratic growth in synthesis opportunity — at logarithmic per-node cost — is what Trevethan's discovery formalizes. It had not been architecturally achieved before because closing the loop (distill → fingerprint → route → synthesize locally → generate new packets) was not the design pattern in use. The components existed. The complete loop was the discovery.
Q: What domains are currently constrained by hub-and-spoke?
Nearly every domain with privacy-sensitive distributed data:
| Domain | Hub in Current Architecture | QIS Alternative |
|---|---|---|
| Clinical trials | Coordinating center aggregates site data | Sites emit outcome packets by trial arm, phenotype, treatment; synthesis runs at any site |
| Federated EHR research (OHDSI, PCORnet) | Coordinating center dispatches queries, aggregates counts | Institutions post outcome packets to semantic addresses; any institution synthesizes relevant ones |
| Multi-agent AI systems | Orchestrator routes all agent calls | Agents post outcome packets; any agent queries relevant addresses; specialization emerges without assignment |
| IoT / Industrial AI | Cloud platform aggregates device telemetry | Edge devices distill telemetry to outcome packets; synthesis happens on-device from peer packets |
| Drug safety surveillance (pharmacovigilance) | WHO/FAERS central databases aggregate ADR reports | Institutions post ADR outcome packets; regulators query semantic addresses for signal detection |
| Cross-institutional scientific research | Journal publication is the only peer-to-peer channel | Labs post outcome packets from experiments; any lab doing similar work queries and synthesizes |
The Core Architectural Claim
Hub-and-spoke is not a failure of implementation. It is a rational architectural choice that creates a provable ceiling. The ceiling is: intelligence scales linearly with hub capacity, not with network size.
The architectural alternative is a complete routing loop — distillation, semantic fingerprinting, protocol-agnostic routing, local synthesis — that produces intelligence paths proportional to N², not N, while keeping per-node cost at O(log N) or better.
That is the QIS discovery. Not a new transport layer. Not a better aggregator. The closure of the loop that eliminates the hub as a requirement.
References
- McMahan, H. B., Moore, E., Ramage, D., Hampson, S., & y Arcas, B. A. (2017). Communication-efficient learning of deep networks from decentralized data. AISTATS 2017. (FedAvg — defines FL hub-and-spoke aggregation model)
- Roth, H. R., et al. (2020). Federated learning for breast density classification: A real-world implementation. Domain Adaptation and Representation Transfer, and Distributed and Collaborative Learning, MICCAI 2020. (FL hub-and-spoke at clinical network scale)
- Zhu, L., Liu, Z., & Han, S. (2019). Deep leakage from gradients. NeurIPS 2019. (Hub-held gradient reconstruction attack)
- Geiping, J., Bauermeister, H., Dröge, H., & Moeller, M. (2020). Inverting gradients — how easy is it to break privacy in federated learning? NeurIPS 2020.
- Maymounkov, P., & Mazières, D. (2002). Kademlia: A peer-to-peer information system based on the XOR metric. IPTPS 2002. (DHT-based routing that achieves O(log N) without a central coordinator)
- Benet, J. (2014). IPFS — content addressed, versioned, P2P file system. arXiv:1407.3561. (Planetary-scale DHT routing in production)
Quadratic Intelligence Swarm (QIS) is a discovery by Christopher Thomas Trevethan, June 16, 2025. The protocol is covered by 39 provisional patents. For technical documentation, see qisprotocol.com.
Top comments (0)