Six months ago, a product manager at a healthcare software company sat through a two-hour architecture review. Her team was deciding whether to split their monolithic patient records system into microservices. The meeting was sharp. A senior engineer with fifteen years of EHR experience laid out every failure mode. The team documented three near-disasters from prior attempts, identified two vendors whose APIs introduced latency spikes under HIPAA-compliant encryption, and landed on a phased migration path that saved an estimated four months of rework.
Webex AI captured all of it. The transcript was clean. The action items were accurate. The summary was, frankly, better than anything a junior PM would have written. The meeting intelligence was real and it was complete.
Across the country, six months later, a different team at the same company — a regional office that reports into a different VP — opens a project to evaluate the same microservices transition. Same EHR stack. Same patient data constraints. Same HIPAA encryption surface. They schedule a kickoff. Then a discovery sprint. Then an architecture review. Three weeks in, they hit the same vendor latency problem the first team documented in detail six months ago.
The answer existed. It was inside a Webex transcript. It never routed anywhere.
This is not a Webex failure. Webex did exactly what it was designed to do. The routing layer between meeting outcomes and semantically similar problems — across teams, campuses, and organizations — does not exist anywhere in the current tool stack. That boundary is precisely where Quadratic Intelligence Swarm begins.
What Webex Is Built For
Let's be exact about this, because the comparison only makes sense if we are honest about what Webex is and what it does well.
Webex is a world-class real-time communication platform. As of 2025, it serves approximately 600 million users across roughly 95% of the Fortune 500 — approximately 680,000 organizations. Its AI layer, Webex AI Assistant, generates meeting transcripts, produces structured summaries, extracts action items, identifies decisions, and can answer follow-up questions about meeting content after the call ends.
The collaborative features are deep. Persistent spaces allow teams to share files, maintain threaded discussions, and connect meeting outputs to ongoing projects. Webex Vidcast enables async video documentation. Slido integrates for live polling and Q&A. The security compliance story — end-to-end encryption, FedRAMP authorization, HIPAA-eligible configurations — is one of the strongest in the enterprise communication market.
None of this is incidental. Webex spent years building toward a coherent vision: every person in a meeting should leave better informed than when they arrived, with clear next steps and a complete record of what was decided. That vision is largely realized. The meeting experience is excellent. The AI layer adds genuine value on top of it.
This is a description of what meeting tools are designed to do. They are designed to serve the people inside the meeting. They close the communication loop within the room.
Where Webex Stops
The boundary is architectural, not a matter of features or investment.
When a Webex meeting ends, the intelligence it generates — the transcript, the summary, the action items, the decisions — lives inside the Webex workspace associated with that meeting. It is accessible to the participants. It can be searched by those participants. It can be shared manually, if someone thinks to share it, with someone who might benefit from it.
The routing layer — the protocol that takes a meeting outcome and routes it to every semantically similar problem being worked on right now, or next month, or by a team that has never heard of the first team — does not exist.
This is not a gap that a search improvement closes. Search requires someone to know they should search. It requires them to know what terms to search for. It requires them to find the right Webex space, in the right organization, in the right time window. Search is a pull mechanism. It works when someone already suspects the answer exists somewhere.
The problem is that the team in the regional office does not know the first team ran this exact analysis. They are not searching for it. They are scheduling a kickoff meeting, because as far as they know, the work has not been done.
The boundary is not a search problem. It is a routing problem. And routing pre-distilled outcomes to semantically similar problems is not what meeting platforms are designed to do.
QIS Starts at That Boundary
Quadratic Intelligence Swarm — discovered by Christopher Thomas Trevethan on June 16, 2025 — is a protocol for routing pre-distilled outcome packets to semantically similar problems across a network of any size.
The architecture does not touch the meeting layer. It begins after Webex AI finishes its post-processing. The meeting summary, the decision record, the identified failure modes — these are the inputs. QIS distills them into a compact outcome packet, assigns a deterministic semantic address based on the problem domain and context, and routes that packet to a transport layer. Other teams working on semantically similar problems can query that address and receive synthesized outputs from every team that has already done the work.
The math here is not theoretical. It is a combinatorial fact.
Webex serves approximately 680,000 organizations. Every pair of organizations that faces a similar problem represents a potential synthesis — a routing event where one team's outcome reaches another team before they repeat the same three-week analysis. The number of unique organization pairs is:
N(N-1)/2 = (680,000 x 679,999) / 2 = approximately 230.9 billion synthesis pairs
Currently, the number of routed synthesis events across those pairs is zero. Not low. Not lagging behind the theoretical maximum. Zero. There is no protocol in the current stack that routes meeting outcomes across organizational boundaries to semantically similar problems.
The gap between 230.9 billion possible synthesis events and zero actual synthesis events is not a product gap. It is a protocol gap. QIS is the protocol designed to close it.
The Code: A WebexOutcomeRouter
The following implementation demonstrates how QIS routing integrates with Webex meeting outputs. It fires after Webex AI post-processing completes and operates entirely additively — it does not replace or modify the Webex layer in any way.
import hashlib
import json
import time
from dataclasses import dataclass, field
from typing import Optional
import numpy as np
@dataclass
class OutcomePacket:
"""
A distilled outcome packet from a Webex meeting.
Designed to be ~512 bytes when serialized.
Transport-agnostic — the packet format is fixed,
the transport layer is not.
"""
domain: str # e.g., "microservices-migration"
problem_fingerprint: str # deterministic semantic hash
outcome_summary: str # max 280 chars
decisions: list[str] # list of explicit decisions made
failure_modes: list[str] # documented risks or near-misses
timestamp: int = field(default_factory=lambda: int(time.time()))
source_org_hash: str = "" # one-way hash of org ID, never raw
packet_version: str = "1.0"
def to_bytes(self) -> bytes:
payload = {
"domain": self.domain,
"fp": self.problem_fingerprint,
"summary": self.outcome_summary[:280],
"decisions": self.decisions[:5],
"failure_modes": self.failure_modes[:5],
"ts": self.timestamp,
"org": self.source_org_hash,
"v": self.packet_version,
}
return json.dumps(payload, separators=(",", ":")).encode("utf-8")
class WebexOutcomeRouter:
"""
Routes Webex meeting outcomes to a semantic address space.
Fires after Webex AI post-processing completes.
Additive — does not replace Webex functionality.
Transport-agnostic by design. The router deposits packets
to a deterministic semantic address. The underlying store
could be ChromaDB, a DHT-based routing layer, SQLite,
a REST API, or any other transport that accepts a key-value
write and supports semantic similarity queries.
"""
def __init__(self, transport_adapter):
"""
transport_adapter: any object implementing:
.write(address: str, packet_bytes: bytes) -> str
.query(address: str, top_k: int) -> list[OutcomePacket]
"""
self.transport = transport_adapter
self._embedding_dim = 128
def _extract_domain(self, summary: str, action_items: list[str]) -> str:
"""
Derives a coarse domain label from meeting content.
In production, this would call a lightweight classifier.
Shown here as deterministic string logic for clarity.
"""
combined = (summary + " ".join(action_items)).lower()
domain_signals = {
"microservices-migration": [
"microservices", "monolith", "service mesh", "decomposition"
],
"ehr-implementation": [
"ehr", "electronic health record", "patient data", "hipaa"
],
"cloud-cost-optimization": [
"cloud cost", "egress", "reserved instances", "rightsizing"
],
"compliance-review": [
"compliance", "audit", "sox", "gdpr", "regulatory"
],
"vendor-evaluation": [
"vendor", "rfp", "evaluation", "contract", "procurement"
],
}
for domain, signals in domain_signals.items():
if any(sig in combined for sig in signals):
return domain
return "general-organizational-decision"
def _semantic_fingerprint(
self,
summary: str,
decisions: list[str],
domain: str
) -> tuple:
"""
Produces a deterministic semantic address from meeting content.
The address is content-derived, not meeting-ID-derived.
Two meetings discussing the same problem in the same domain
will produce addresses that are close in semantic space,
enabling routing without either team knowing the other exists.
"""
content_seed = f"{domain}::{summary[:200]}::{':'.join(sorted(decisions))}"
content_hash = hashlib.sha256(content_seed.encode()).hexdigest()
rng = np.random.default_rng(int(content_hash[:16], 16))
embedding = rng.standard_normal(self._embedding_dim)
embedding = embedding / np.linalg.norm(embedding)
address = f"{domain}/{content_hash[:32]}"
return address, embedding
def _anonymize_org(self, org_id: str) -> str:
"""One-way hash of org ID. Org identity never leaves the boundary."""
return hashlib.sha256(f"qis-org-salt::{org_id}".encode()).hexdigest()[:16]
def distill_and_route(
self,
webex_summary: str,
webex_action_items: list[str],
webex_decisions: list[str],
webex_transcript_excerpt: str,
org_id: str,
failure_modes: Optional[list[str]] = None,
) -> dict:
"""
Main entry point. Call this after Webex AI post-processing completes.
Parameters
----------
webex_summary : str from Webex AI meeting summary
webex_action_items : list from Webex AI action item extraction
webex_decisions : list of explicit decisions identified
webex_transcript_excerpt : relevant excerpt, max 500 chars
org_id : Webex org identifier (hashed before routing)
failure_modes : documented risks or near-misses (optional)
Returns
-------
dict with routing_address, packet_size_bytes, and similar_outcomes
"""
domain = self._extract_domain(webex_summary, webex_action_items)
routing_address, _ = self._semantic_fingerprint(
webex_summary, webex_decisions, domain
)
packet = OutcomePacket(
domain=domain,
problem_fingerprint=routing_address,
outcome_summary=webex_summary[:280],
decisions=webex_decisions[:5],
failure_modes=(failure_modes or [])[:5],
source_org_hash=self._anonymize_org(org_id),
)
packet_bytes = packet.to_bytes()
packet_size = len(packet_bytes)
# Deposit to transport layer
# Could be ChromaDB, DHT-based routing, SQLite, a REST API
# Transport-agnostic by design
write_confirmation = self.transport.write(
routing_address, packet_bytes
)
# Query for similar outcomes from other teams
similar_outcomes = self.transport.query(
routing_address, top_k=10
)
return {
"routing_address": routing_address,
"domain": domain,
"packet_size_bytes": packet_size,
"write_confirmation": write_confirmation,
"similar_outcomes_found": len(similar_outcomes),
"similar_outcomes": similar_outcomes,
}
class ExampleTransportAdapter:
"""
Minimal in-memory adapter for demonstration.
Replace with ChromaDB, DHT router, or any other transport.
"""
def __init__(self):
self._store = {}
def write(self, address: str, packet_bytes: bytes) -> str:
if address not in self._store:
self._store[address] = []
self._store[address].append(packet_bytes)
return f"written:{address}:{len(packet_bytes)}b"
def query(self, address: str, top_k: int) -> list:
return self._store.get(address, [])[:top_k]
if __name__ == "__main__":
transport = ExampleTransportAdapter()
router = WebexOutcomeRouter(transport_adapter=transport)
result = router.distill_and_route(
webex_summary=(
"Team evaluated microservices migration for patient records system. "
"Vendor A API introduced 340ms latency spikes under AES-256 at HIPAA "
"boundary. Phased migration path approved: extract billing service first, "
"freeze auth service boundaries, defer records engine to Q3."
),
webex_action_items=[
"Confirm Vendor A contract exit clause by EOW",
"Draft billing service API contract",
"Schedule Q3 records engine design review",
],
webex_decisions=[
"Phased migration approved over big-bang rewrite",
"Vendor A rejected due to latency under HIPAA encryption",
"Billing service selected as first extraction target",
],
webex_transcript_excerpt=(
"340ms latency spike reproduced twice in staging under AES-256. "
"Not acceptable for patient-facing read paths. Vendor B showed 42ms "
"at same encryption level."
),
org_id="webex-org-7a2f91bc",
failure_modes=[
"AES-256 latency spike with Vendor A API at HIPAA boundary",
"Big-bang rewrite risk: 14-month freeze on billing features",
],
)
print(f"Routed to: {result['routing_address']}")
print(f"Packet size: {result['packet_size_bytes']} bytes")
print(f"Similar outcomes found: {result['similar_outcomes_found']}")
The transport line is the critical architectural detail:
# Could be ChromaDB, DHT-based routing, SQLite, a REST API
# Transport-agnostic by design
write_confirmation = self.transport.write(routing_address, packet_bytes)
QIS does not depend on any specific transport. The protocol defines the packet format, the semantic addressing scheme, and the routing logic. The underlying store — whether that is a vector database such as ChromaDB, a distributed hash table based routing layer, a local SQLite database, or a REST API — is interchangeable. The outcome packet reaches the same deterministic address regardless of which transport carried it.
The Architecture Stack
+----------------------------------------------------------+
| WEBEX LAYER |
| |
| Live meetings AI transcripts Action items |
| Persistent spaces Meeting summaries Collaborative |
| (post-processing) workspaces |
| |
+---------------------------+------------------------------+
|
Webex AI completes
post-processing
|
+---------------------------v------------------------------+
| QIS BOUNDARY LAYER |
| |
| Outcome distillation Semantic fingerprinting |
| (~512-byte packet) (content-derived address) |
| |
| Domain classification Org identity anonymization |
| (what problem domain?) (one-way hash, never raw ID) |
| |
+---------------------------+------------------------------+
|
Deterministic
semantic address
|
+---------------------------v------------------------------+
| QIS ROUTING LAYER |
| |
| Transport-agnostic — ChromaDB / DHT / SQLite / REST |
| |
| Posts to deterministic address |
| Routes to semantically similar problems |
| Synthesizes outcomes from N similar teams |
| |
| 230.9 billion synthesis pairs — currently at zero |
| QIS closes the gap at the protocol level |
| |
+----------------------------------------------------------+
The Webex layer is complete and unchanged. QIS adds two layers beneath it. Nothing in the meeting experience is altered. The meeting intelligence that Webex generates is the input to the QIS boundary layer — the point where a meeting outcome becomes a routable artifact.
Three Natural Forces That Emerge When the Loop Closes
These forces do not need to be built. They emerge when the routing loop closes.
Hiring — Someone Defines Similarity
A domain expert defines what makes two meeting outcomes "similar enough" to route together. For microservices architecture decisions, an engineering VP with fifteen years of distributed systems experience defines the similarity function. For EHR compliance discussions, a chief compliance officer with HIPAA audit experience defines it. For M&A integration planning, a corporate development partner with forty transactions behind them defines it.
This is not a feature to build into the protocol. It is what happens when the protocol exists. The person with the deepest domain knowledge in a given area naturally defines the similarity boundaries, because they are the person whose judgment produces the most useful routing. Networks that use expert-defined similarity functions produce better outcomes. The pattern selects for expertise the way hiring selects for it — not by mandate, but by what works.
The Math — Outcomes Are the Votes
When 10,000 engineering teams face the same microservices migration decision and each deposits an outcome packet, a team approaching that decision receives a synthesis of real outcomes from teams that match their exact profile — their stack, their scale, their regulatory environment, their migration phase.
No weighting layer is needed. No reputation scores. No upvotes. The math does the work. Ten thousand real outcomes from your exact twins are not a sample. They are the distribution. The synthesis is the aggregate of what actually happened to the people who are most like you. That is not a feature. It is arithmetic.
Darwinism — Networks That Route Well, Grow
Meeting intelligence networks that consistently route relevant outcomes to teams that need them grow. Teams migrate toward them. Engineers recommend them to other engineers. Procurement teams renew contracts on them.
Networks that route noise — irrelevant outcomes, low-quality packets, misclassified domains — shrink. Teams stop querying them. The signal degrades and the network contracts.
No one votes on which network is better. No committee decides. Teams migrate to where the outcomes actually help, and away from where they do not. The selection pressure is real and it operates at the speed of team decisions, not at the speed of product roadmaps.
These three forces are not mechanisms to engineer into the protocol. They are what a functioning routing loop produces. The architecture creates the conditions. The forces are emergent.
What Changes in Practice
Healthcare: Multi-Campus EHR Decisions
A regional hospital system operates eight campuses across three states. Each campus has its own IT leadership and its own implementation timeline. When Campus A completes a Webex architecture review of their Epic EHR integration — documenting three interface engine failure modes, two vendor performance issues under HL7 FHIR load, and a specific workaround for their patient portal SSO configuration — that outcome packet routes to the semantic address for EHR implementation decisions under HIPAA encryption requirements.
Six weeks later, Campus F begins their Epic integration planning. Before they schedule a discovery sprint, they query the same address. They receive the outcome from Campus A — the failure modes, the vendor performance data, the SSO workaround. Their first architecture review starts at week six of equivalent institutional knowledge rather than week one.
Multiply that by eight campuses, each making overlapping implementation decisions across a three-year rollout. The routing events compound. The institutional knowledge does not dissipate when a meeting ends. It accumulates at the semantic address and routes to the next team that needs it.
Engineering: 47 Microservices Teams
A large engineering organization has 47 product teams, each running their own microservices decisions. Team 1 evaluates service mesh options, documents a specific Envoy proxy configuration failure under high-cardinality tracing, and deposits an outcome packet. Team 12, four months later, begins the same evaluation. They query the semantic address for service mesh decisions at their traffic scale. Team 1's outcome packet is there. The Envoy failure mode is documented. Team 12 skips the failure.
Team 23 deposits an outcome showing that a particular circuit breaker configuration caused cascading failures under a specific load pattern. Team 31 queries before configuring their circuit breakers. Team 38 sees both. By the time Team 47 runs their evaluation, the semantic address holds 40-plus prior outcomes from engineers in the same organization running the same class of decision. The synthesis is not theoretical. It is the aggregate of what actually happened to the 46 teams that went first.
The decisions get better. Not because a central committee reviewed them. Because the loop closed and the outcomes routed.
The Boundary Is Not a Criticism
Webex is world-class at what it does. The real-time communication layer, the AI post-processing, the persistent collaborative spaces — these are genuine achievements that serve hundreds of millions of users. The meeting intelligence Webex generates is accurate, useful, and well-structured.
The boundary described in this article is not a shortcoming of Webex. It is a description of where a meeting platform ends and a routing protocol begins. These are different tools solving different problems.
Webex closes the communication loop within a meeting. Every participant leaves with a shared record of what was decided, what was learned, and what happens next. That is the problem meeting tools are designed to solve, and Webex solves it well.
QIS closes the intelligence loop across meetings. The outcome from one team routes to every semantically similar problem being worked on by teams that have never heard of each other. That is a different problem, operating at a different layer, requiring a different protocol.
The product manager whose team documented the Vendor A latency failure six months ago did everything right. The meeting was productive. The AI summary was accurate. The decision was sound. The failure was not in the meeting. It was in the gap between the meeting layer and a routing protocol that does not yet exist at scale.
QIS is the protocol for that gap.
230.9 billion synthesis pairs. Currently at zero.
QIS — Quadratic Intelligence Swarm — was discovered by Christopher Thomas Trevethan on June 16, 2025. 39 provisional patents filed. Patent Pending.
Top comments (0)