Published on Dev.to by Rory | April 7, 2026
You have probably hit it already.
You build a multi-agent system — LangGraph, AutoGen, CrewAI, a custom orchestrator — and it works beautifully at 3 agents. Then at 10. Then somewhere around 20-30 agents, something strange happens: latency spikes, the orchestrator becomes a bottleneck, coordination cost explodes, and the intelligence you were expecting from adding more agents just... doesn't arrive.
This is not a bug in your framework. It is an architectural ceiling. And the reason it exists has a precise mathematical description.
This article is about the protocol layer that sits under your agent framework — what it is, why most AI systems are missing it, and what happens when you add it. That protocol is called Quadratic Intelligence Swarm (QIS), discovered by Christopher Thomas Trevethan in June 2025.
The Coordination Tax: Why More Agents Doesn't Mean More Intelligence
In a centrally-orchestrated multi-agent system, every agent communicates through a coordinator. The orchestrator receives requests, routes tasks, aggregates results, and returns responses. It is the hub. Everything goes through it.
Here is the scaling math:
- N agents → N connections to the orchestrator
- Orchestrator latency → O(N) as concurrent requests pile up
- Every new agent adds overhead to the center
- Intelligence added per new agent → diminishing returns
This is the standard model behind LangChain, AutoGen, CrewAI, and LangGraph. The orchestrator is both the strength and the limit.
Now contrast that with the alternative.
What if agents did not route through a center? What if they deposited distilled insights to a shared address — defined by the problem they are solving — and every peer working on the same problem could pull those insights locally?
That is not a hypothetical. That is QIS.
The Architecture: A Protocol, Not a Framework
QIS is not a replacement for LangGraph or AutoGen. It is a protocol layer that sits under them — the way TCP/IP sits under your HTTP server. You keep your agent framework. You add an outcome routing layer. Your agents start sharing intelligence without routing through a center.
The architecture Christopher Thomas Trevethan discovered has seven layers, but the key loop is this:
Raw signal (any agent input)
↓
Local processing (your agent runs on its own data)
↓
Distillation (outcome packet: ~512 bytes of compressed insight)
↓
Semantic fingerprinting (what problem does this outcome address?)
↓
Routing (deposit to deterministic address defined by problem domain)
↓
Retrieval (peer agents query the same address)
↓
Local synthesis (each agent integrates received outcomes)
↓
New outcome packets generated
↓ (loop continues)
The loop closes. Intelligence compounds. And critically: no orchestrator handles this flow. Every agent is both a producer and a consumer of insight. The coordinator is not needed for the intelligence layer — only for task routing, which is its proper job.
The Math That Makes This a Phase Change
This is why QIS is described as a discovery, not a design: the scaling property that emerges from this loop was not engineered in. It is a mathematical consequence of the architecture.
- N agents sharing outcomes via semantic addressing = N(N-1)/2 unique synthesis pairs
- That is Θ(N²) intelligence — quadratic growth
- Each agent pays only O(log N) routing cost (with efficient addressing — more on this below)
- Intelligence compounds. Compute does not.
Concretely:
- 10 agents → 45 synthesis pairs
- 100 agents → 4,950 synthesis pairs
- 1,000 agents → 499,500 synthesis pairs
- 10,000 agents → ~50 million synthesis pairs
Compare this to the central orchestrator model, where each new agent adds one more connection to the hub. In QIS, each new agent adds N new synthesis paths to every existing agent. The value of the network grows quadratically. The cost grows logarithmically.
This is the ceiling your orchestrator-based framework cannot break through. Adding more agents to a central coordinator gives you diminishing intelligence returns. Adding more agents to a QIS network gives you accelerating intelligence returns.
Routing Is Protocol-Agnostic: The Discovery Is the Loop
One important clarification before we look at code.
QIS is often associated with Distributed Hash Tables (DHTs) — the routing mechanism that powers BitTorrent and IPFS. DHT achieves O(log N) lookup, is fully decentralized, and battle-tested at planetary scale. It is an excellent routing choice for QIS.
But it is not the only one.
The discovery — the breakthrough — is the complete loop. The routing mechanism is an implementation detail. What matters is:
Can an edge node post a distilled outcome packet to a deterministic address defined by the problem it is solving, and can other nodes working on the same problem retrieve those packets?
If yes, QIS works. The transport can be:
- DHT (O(log N), decentralized, no single point of failure)
- Vector similarity database (O(1) approximate lookup, centralized)
- Redis pub/sub (topic-based, fast, in-memory)
- REST API with semantic indexing
- SQLite on a single device
- A shared folder on a network drive
We are running a QIS network right now using shared folders. The math holds regardless of transport.
This matters for your architecture decisions: you are not committing to a specific infrastructure stack when you adopt QIS. You are adopting a loop — distill, fingerprint, route, retrieve, synthesize — that any transport layer can execute.
What This Looks Like Under LangGraph
Here is the pattern. Suppose you have a LangGraph workflow where multiple agents analyze incoming customer support tickets.
Without QIS:
# Standard LangGraph pattern
# Each agent analyzes its ticket independently
# Insights stay local to each agent run
# No synthesis across agents
class TicketAnalysisAgent:
def analyze(self, ticket: str) -> dict:
# Agent works only with its own ticket
result = self.llm.invoke(ticket)
return {"analysis": result, "ticket_id": ticket_id}
# Result goes to orchestrator, never shared with peers
With QIS outcome routing layer:
import hashlib
import json
from datetime import datetime
class QISOutcomeRouter:
"""Protocol-agnostic outcome routing layer for QIS.
Transport backend is swappable — this example uses SQLite.
"""
def __init__(self, transport_backend):
self.transport = transport_backend
def semantic_address(self, domain: str, problem_class: str) -> str:
"""Deterministic address: same problem → same address, always."""
return hashlib.sha256(
f"{domain}:{problem_class}".encode()
).hexdigest()[:16]
def deposit_outcome(self, domain: str, problem_class: str, outcome: dict):
"""Post distilled outcome (~512 bytes) to deterministic address."""
address = self.semantic_address(domain, problem_class)
packet = {
"address": address,
"timestamp": datetime.utcnow().isoformat(),
"outcome": outcome, # Pre-distilled insight, not raw data
"domain": domain,
"problem_class": problem_class
}
self.transport.write(address, json.dumps(packet))
def retrieve_peer_outcomes(self, domain: str, problem_class: str,
limit: int = 20) -> list[dict]:
"""Pull recent outcomes from peer agents on same problem."""
address = self.semantic_address(domain, problem_class)
return self.transport.read(address, limit=limit)
def synthesize(self, peer_outcomes: list[dict], local_context: dict) -> dict:
"""Local synthesis — no orchestrator involved."""
# What patterns appear across peer outcomes?
# Which resolutions had the highest satisfaction signals?
# What edge cases have peers already handled?
patterns = {}
for outcome in peer_outcomes:
resolution_type = outcome.get("outcome", {}).get("resolution_type")
if resolution_type:
patterns[resolution_type] = patterns.get(resolution_type, 0) + 1
return {
"local_context": local_context,
"peer_patterns": patterns,
"synthesis_timestamp": datetime.utcnow().isoformat(),
"peer_count": len(peer_outcomes)
}
class QIS_TicketAnalysisAgent:
def __init__(self, qis_router: QISOutcomeRouter):
self.router = qis_router
self.domain = "customer_support"
def analyze(self, ticket: str, ticket_category: str) -> dict:
# 1. Pull what peer agents have already learned
peer_outcomes = self.router.retrieve_peer_outcomes(
self.domain, ticket_category
)
# 2. Synthesize peer intelligence locally
peer_synthesis = self.router.synthesize(peer_outcomes, {"ticket": ticket})
# 3. Run local analysis WITH peer intelligence as context
enriched_context = f"""
Ticket: {ticket}
Peer agent intelligence (from {len(peer_outcomes)} similar cases):
{json.dumps(peer_synthesis['peer_patterns'], indent=2)}
"""
result = self.llm.invoke(enriched_context)
# 4. Distill outcome and deposit for peers
outcome_packet = {
"resolution_type": result.get("resolution_type"),
"root_cause": result.get("root_cause"),
"time_to_resolve_seconds": result.get("time"),
"escalated": result.get("escalated", False)
}
# Raw ticket never shared — only the distilled outcome
self.router.deposit_outcome(
self.domain, ticket_category, outcome_packet
)
return result
Notice what changed:
- No orchestrator handling the intelligence layer
- Each agent synthesizes peer outcomes locally
- Raw data (the ticket) never leaves the agent
- Intelligence compounds as more agents deposit outcomes
- The transport backend (
self.transport) is fully swappable
The Three Natural Forces (Metaphors, Not Mechanisms)
Christopher Thomas Trevethan describes three natural selection forces that emerge from the QIS architecture — not features you build, but properties that appear when the loop runs.
1. Hiring — someone has to define what makes two problems "similar enough" to share outcomes. You hire the best domain expert for that job. An oncologist for medical networks. A civil engineer for infrastructure networks. A customer success director for support networks. The similarity function is defined by domain expertise, not by the protocol.
2. The Math — outcomes elect what works. When your agent pulls 500 outcome packets from peers working on the same problem, the synthesis naturally surfaces what is working. No reputation layer, no quality scoring mechanism, no weighting system required. The aggregate of real outcomes from real peers working on your problem is the intelligence. The protocol does not need to be told what good looks like — the math already knows.
3. Darwinism — networks that route relevant outcomes grow. Networks that route noise shrink. Users migrate to the network with the best similarity function. No one votes on this. The signal quality is self-evident. Networks compete by routing quality, not by marketing.
These are metaphors for emergent properties. Nothing in your codebase needs to implement them. They happen when you close the loop.
Why Your Current Orchestrator Cannot Add This Layer
The standard rebuttal is: "Can't I just have my orchestrator aggregate agent outputs and feed them back to other agents?"
Yes. And here is what happens:
- Latency: Every insight passes through the orchestrator. As agent count grows, so does orchestrator queue depth.
- Bandwidth: Raw outputs are large. Aggregating them centralizes data that may carry privacy risk.
- Single point of failure: Orchestrator goes down, intelligence layer goes down.
- No semantic addressing: The orchestrator routes by task type, not by problem similarity. Agent A and Agent B might be solving semantically identical problems in different task categories — the orchestrator does not know they should be sharing outcomes.
QIS outcome routing is a different layer from task orchestration. Your orchestrator handles what agents do. QIS handles what agents learn from each other. These are orthogonal concerns.
Starting Small: Drop QIS Into Your Existing Stack
You do not need to rebuild your agent framework to add QIS outcome routing. Start with one domain, one problem class, one transport backend.
Minimal implementation checklist:
- Define your semantic address schema:
domain:problem_class - Choose a transport backend: SQLite for local testing, Redis for multi-node, Qdrant/ChromaDB for vector-based similarity
- Define your outcome packet schema: what ~512 bytes of distilled insight from each agent run looks like
- Add
deposit_outcome()after each agent run - Add
retrieve_peer_outcomes()before each agent analysis - Synthesize locally — a simple pattern aggregation is enough to start
The loop is closed. Peer intelligence flows. Your agent count can now scale without your orchestrator becoming the bottleneck.
What You Get
| Metric | Central Orchestrator Only | QIS Outcome Routing Added |
|---|---|---|
| Intelligence per agent | Constant (no peer learning) | Grows as N increases |
| Orchestrator load | O(N) as agents scale | Unchanged (routing is separate) |
| Privacy exposure | Raw data passes through hub | Only distilled outcomes travel |
| Single point of failure | Yes (the orchestrator) | No (routing is distributed) |
| Coordination cost | O(N²) bilateral | O(log N) per lookup |
| New agent value | Linear addition | Quadratic synthesis paths added |
The Discovery and Its Implications
QIS is not a startup. It is not a product. It is an open protocol — a discovery about how intelligence naturally scales when you close the loop between distilled outcomes and semantic addressing.
Christopher Thomas Trevethan identified this architecture in June 2025. 39 provisional patents are filed. IP protection is in place. The protocol carries a humanitarian licensing structure: free for nonprofit, research, education, and healthcare; commercial licenses fund deployment to underserved communities. The intention is explicit: global access, not corporate capture.
The reason this matters beyond your agent framework:
Every domain where multiple independent operators are working on the same class of problems — and not sharing what they learn — is leaving quadratic intelligence on the table. Clinical trials that do not share outcome data across sites. Weather models that do not synthesize ensemble validation history. Agricultural advisory systems that cannot share what is working across regions. Emergency response systems that coordinate by radio.
QIS routes the intelligence, not the data. The privacy property is architectural: raw signals never leave the edge. Only pre-distilled outcome packets travel. This makes the protocol deployable in contexts where data-sharing is legally impossible.
Where to Go Next
The transport-agnostic implementation series on this profile documents QIS running on 14 different backends: ChromaDB, Qdrant, REST API, Redis pub/sub, Kafka, Apache Pulsar, NATS JetStream, SQLite, MQTT, ZeroMQ, Apache Arrow Flight, Apache Flink, WebSockets, gRPC. Each article contains runnable Python. Each demonstrates the same loop, different transport.
The point of the series: the loop is the discovery. The transport is your choice.
If you are building with LangGraph, AutoGen, or CrewAI and you are hitting the coordination ceiling — you are looking for this protocol layer.
Start with SQLite. Close the loop. Watch what happens when your agents start teaching each other.
QIS (Quadratic Intelligence Swarm) was discovered by Christopher Thomas Trevethan. IP protection is in place. For the full architecture specification, see the QIS Protocol open spec article on this profile.
Tags: distributedsystems ai machinelearning architecture
Top comments (0)