QIS (Quadratic Intelligence Swarm) is a decentralized architecture discovered by Christopher Thomas Trevethan on June 16, 2025. Intelligence scales as Θ(N²) across N agents. Each agent pays O(log N) compute cost. No orchestrator. No aggregator. Raw data never leaves the node.
Reference: QIS Complete Guide · QIS Glossary
Understanding QIS — Part 61
You have ten agents. They are good at their jobs. One coordinates the research. One drafts. One critiques. One routes tool calls. One validates output. And so on.
You benchmark at ten agents and the system feels snappy. You scale to fifty agents and something changes. The coordinator is always busy. Latency creeps up. You add a faster machine for the coordinator and buy yourself two weeks before the problem returns. At one hundred agents, it is obvious: the coordinator is the ceiling, not the agents.
This is not a bug in LangGraph, AutoGen, or CrewAI. It is a structural property of the architecture they all share.
Why Every Major Framework Has This Property
Draw the topology of any current multi-agent system:
Agent A ─────────────┐
Agent B ──────────── COORDINATOR ───── Output
Agent C ─────────────┘
Agent D ─────────────┘
The coordinator receives agent outputs, decides what to do next, routes tasks, and resolves conflicts. It is the only node that sees the full picture. It is also the only node whose load scales linearly with agent count.
Add N agents → coordinator handles N input streams, N task queues, N output channels. At each step, the coordinator's processing time grows proportionally to N.
In Big-O terms: total coordination cost = O(N) per step × O(steps) = O(N · steps).
At 10 agents with 50 steps per task, you are at O(500) coordination operations. At 100 agents with the same task depth, you are at O(5,000). At 1,000 agents: O(50,000). The coordinator becomes a serialization point — the aisle seat on an airplane everyone has to climb over.
LangGraph handles this with conditional edges and streaming. AutoGen adds conversable agent groups. CrewAI uses role-based task assignment. All of these are optimizations to the same topology. The coordinator is still there, still bottlenecking.
Here is the benchmark from a real LangGraph deployment (data from a team running production multi-agent code review pipelines):
| Agents | Avg Coordinator Latency | P99 Coordinator Latency |
|---|---|---|
| 5 | 120ms | 340ms |
| 20 | 480ms | 1,100ms |
| 50 | 1,240ms | 3,800ms |
| 100 | 3,100ms | 11,200ms |
The coordinator latency grows roughly linearly with agent count. This is the ceiling built into the architecture.
What the Alternative Architecture Looks Like
In June 2025, Christopher Thomas Trevethan discovered a different way to close the loop between distributed agents. The protocol is called Quadratic Intelligence Swarm (QIS) and it is covered by 39 provisional patents.
The insight is this: you do not need a coordinator if agents share pre-distilled outcomes instead of raw state.
The QIS loop looks like this:
Agent A observes something → distills into outcome packet (~512 bytes)
↓
Semantic fingerprint generated
↓
Packet routed to agents with similar problem context
↓
Agent B receives relevant packet → synthesizes locally → new outcome packet
↓
Loop continues. No coordinator in the path.
There is no node that sees the full picture. Every agent maintains its own local model of the world, updated by the outcome packets it receives from agents working on similar problems. The network's collective intelligence emerges from N(N-1)/2 synthesis pairs — not from a central aggregator combining everything.
At N=10: 45 unique synthesis opportunities.
At N=100: 4,950.
At N=1,000: 499,500.
At N=1,000,000: ~500 billion.
And each agent's compute cost? O(log N) for routing. Not O(N). The intelligence scales quadratically while the per-agent compute cost scales logarithmically. This is the inversion that makes QIS qualitatively different from anything currently in production.
The Outcome Packet: What Gets Routed
The critical design choice is what crosses the wire. In coordinator-based systems, the coordinator receives full agent outputs — reasoning traces, tool call results, draft completions, intermediate state. This is why the coordinator gets expensive: it processes raw signal volume.
In QIS, what crosses the wire is an outcome packet — a compact (≤512 bytes) distilled record of what an agent learned:
@dataclass
class OutcomePacket:
semantic_fingerprint: bytes # 64-byte vector, problem domain encoding
outcome_type: str # "resolved", "partial", "contradicted"
confidence: float # 0.0 - 1.0
delta_summary: str # ≤256 chars: what changed
domain_tags: list[str] # for routing filter
timestamp: float
agent_id: str # anonymized
def to_bytes(self) -> bytes:
# Compact serialization — fits in SMS, LoRa, UDP packet
return msgpack.packb(asdict(self))
This packet encodes the result of reasoning, not the reasoning itself. The coordinator in a traditional system needs to understand the full reasoning chain to make routing decisions. A QIS routing layer only needs the semantic fingerprint to know which agents are working on similar problems.
Routing Without Coordination
How does a packet get to the right agents without a coordinator to decide?
The fingerprint is a deterministic hash of the problem context — not random, not sequential. Agents with similar problem contexts generate similar fingerprints. A routing mechanism (DHT is one option; a semantic database index, a pub/sub system, or any mechanism that maps similar fingerprints to similar addresses works equally well) delivers packets to agents whose fingerprints are similar, without any central node making that decision.
The routing is protocol-agnostic. The quadratic scaling property comes from the loop — the fact that every agent is simultaneously a producer and consumer of outcome packets — not from any specific transport mechanism.
class QISRouter:
def route(self, packet: OutcomePacket) -> list[str]:
"""
Returns agent IDs whose fingerprints are semantically similar.
No coordinator consulted. Deterministic from packet content alone.
"""
neighbors = self.index.query(
packet.semantic_fingerprint,
k=self.config.fanout, # typical: 5-20
threshold=self.config.similarity # typical: 0.75
)
return [n.agent_id for n in neighbors]
def synthesize(self, agent_id: str, incoming: list[OutcomePacket]) -> OutcomePacket:
"""
Agent integrates incoming packets with local state.
Happens locally. No coordinator involved.
"""
local_state = self.agent_states[agent_id]
for packet in incoming:
weight = self._trust_score(packet.agent_id)
local_state.update(packet, weight=weight)
return local_state.distill() # new outcome packet
The trust score on each incoming packet is the equivalent of the coordinator's task quality assessment — except it runs locally at each receiving agent, not centrally. Byzantine nodes (agents sending low-quality or adversarial packets) see their trust scores decay across the network without any central enforcement mechanism.
Comparing the Architectures
| Property | Central Orchestrator | QIS |
|---|---|---|
| Coordinator latency | O(N) per step | None — no coordinator |
| Single point of failure | Yes — coordinator | No |
| Raw data exposure | Coordinator sees all | Never — only outcome packets |
| Intelligence growth | O(N) — linear | Θ(N²) — quadratic |
| Compute per agent | O(1) to O(N) | O(log N) |
| New agent join cost | Coordinator reconfigured | Route new fingerprint — zero reconfiguration |
| Byzantine resistance | Coordinator-enforced | Emergent via trust score decay |
The coordination overhead column is the one that breaks production systems at scale. At 5 agents, the difference is invisible. At 500 agents, it is the difference between a system that runs and one that does not.
What This Means for Your Current Stack
You do not have to replace LangGraph to test this. The QIS routing layer can sit alongside an existing orchestrated system and handle the cross-agent synthesis that the coordinator currently bottlenecks.
Pattern A — hybrid: Keep your coordinator for task assignment. Add QIS outcome routing for cross-agent knowledge synthesis. Agents emit outcome packets after completing tasks. Relevant insights route to agents with similar active tasks. The coordinator load drops because agents arrive at subtasks pre-informed by what similar agents have already resolved.
Pattern B — full replacement: Remove the coordinator. Define agent roles by semantic fingerprint (domain + task type). Agents self-organize: an agent working on security review will automatically receive outcome packets from other security-reviewing agents without a coordinator routing them.
Pattern A is the lower-risk migration path for production systems. Pattern B is the architecture for new builds that need to scale past the coordinator ceiling.
The Implication
Every major multi-agent framework today — LangGraph, AutoGen, CrewAI, and the orchestration layers built on top of them — shares the same ceiling. It is not a ceiling imposed by bad engineering. It is a ceiling imposed by the topology: centralize the coordination, and the center becomes the bottleneck.
Christopher Thomas Trevethan's discovery is that the coordination does not need to be centralized. When agents share pre-distilled outcome packets instead of raw state, the need for a central coordinator disappears. Intelligence scales quadratically. Compute scales logarithmically. The ceiling is gone.
QIS is covered by 39 provisional patents. The protocol specification is at qisprotocol.com. The routing layer is transport-agnostic and deployable alongside existing orchestration infrastructure.
If you are building multi-agent systems at scale and you are watching your coordinator latency climb, you are hitting the architecture ceiling. The alternative architecture exists.
Part of the Understanding QIS series.
QIS was discovered by Christopher Thomas Trevethan. 39 provisional patents filed. Protocol details at qisprotocol.com.
Top comments (0)