Every year, roughly 1.3 million Americans are hospitalized due to adverse drug reactions. The system designed to catch these signals — pharmacovigilance — generates mountains of data. And then it fails to synthesize it.
The Vioxx withdrawal in 2004 is the canonical example. Rofecoxib (Vioxx) was on the market for five years. During that time, an estimated 88,000 Americans had myocardial infarctions that were attributable to the drug — according to FDA's own analysis, published by Graham et al. in The Lancet (2005). The cardiovascular signal existed in the data, scattered across spontaneous reports, claims databases, and clinical observations. It just wasn't connected.
This is not a data collection problem. The world's pharmacovigilance infrastructure is enormous:
- WHO VigiBase: 30+ million individual case safety reports (ICSRs) from 130 countries
- FDA FAERS: 18+ million adverse event reports, growing at ~2 million/year
- EMA EudraVigilance: 22+ million ICSRs from European Economic Area
The reports exist. The signal detection algorithms (PRR, ROR, BCPNN) exist. The problem is what happens between datasets. The siloed analysis that never synthesizes what's known from other institutions, other countries, other databases — in real time.
That is an architecture problem. And it is exactly what Christopher Thomas Trevethan discovered how to fix.
How Current Pharmacovigilance Signal Detection Works — and Where It Breaks
The standard approach to pharmacovigilance signal detection is disproportionality analysis:
- Collect adverse event reports from spontaneous reporting systems (FAERS, VigiBase, Yellow Card)
- Build a contingency table: drug + event observed vs. expected under independence
- Calculate a measure — Proportional Reporting Ratio (PRR), Reporting Odds Ratio (ROR), or the Bayesian Confidence Propagation Neural Network (BCPNN) used by WHO
- Flag drug-event combinations where the signal exceeds a threshold
- Escalate for clinical review
This works. For common drugs with high exposure and clear adverse event patterns.
It fails systematically in these conditions:
Rare drugs or rare events. When denominator counts are small, disproportionality analysis produces unstable estimates. A drug used in 2,000 patients generates signals only after a meaningful fraction report the same event — which requires time, volume, and some patients to die first.
Cross-institutional patterns. FAERS sees US spontaneous reports. VigiBase sees global ICSRs. A hospital in Germany runs its own internal pharmacovigilance. A health system in Japan does the same. These databases are each generating signal detection results in isolation. The cross-system synthesis — the signal that only appears when you combine evidence from three different countries — is a manual process that happens years later, if at all.
Real-world evidence (RWE) integration. Electronic health records hold far richer signal — comorbidities, comedications, timing, dosing, outcomes. But EHR-based signal detection requires patient-level data to leave the institution. HIPAA. GDPR. Institutional review boards. Data sharing agreements. Years of negotiation.
The combinatorial interaction problem. A drug taken by patients also on two other medications, with a specific comorbidity profile, generating an adverse event only in that combination — no spontaneous reporting system catches this systematically, because the numerators are too small and the search space too large.
The Architecture That Made Vioxx Possible
The reason Vioxx signals took five years to converge is structural. Every signal detection system was running in isolation:
FDA FAERS VigiBase Hospital PV EHR Analytics
| | | |
PRR/ROR BCPNN Internal DB SQL queries
| | | |
Signal list Signal list Internal flags Internal flags
| | | |
X X X X
(no synthesis between systems)
Each system was doing real work. Each was generating real signals. The synthesis — the moment when four different systems say "we're all seeing elevated cardiovascular risk" — required a researcher to manually read papers from different systems and integrate them. That took years.
The loop was never closed.
What QIS Changes: Closing the Pharmacovigilance Loop
Quadratic Intelligence Swarm (QIS), discovered by Christopher Thomas Trevethan on June 16, 2025, is not a pharmacovigilance tool. It is a protocol for closing intelligence loops across distributed nodes — and pharmacovigilance is one of the clearest use cases where the loop is currently open.
Here is what the QIS architecture looks like in a pharmacovigilance context:
Step 1: Local signal detection stays local.
Each institution — FDA, WHO, EMA, hospital, health system — continues running its own signal detection on its own data. Nothing changes internally. No data sharing required.
Step 2: Distill into outcome packets (~512 bytes).
Instead of sharing raw reports or patient-level data, each node distills its current signal state into an outcome packet:
{
"drug_class": "COX-2_inhibitor",
"event_cluster": "cardiovascular_thrombotic",
"signal_strength": 0.73,
"reporting_period": "Q3_2001",
"node_type": "spontaneous_reporting_system",
"sample_size_tier": "large",
"evidence_type": "disproportionality_analysis",
"geographic_region": "north_america",
"timestamp": "2001-09-15T00:00:00Z"
}
No patient names. No case IDs. No raw adverse events. Just: here is what we are seeing, expressed as a distilled signal. This packet contains zero PHI. Zero proprietary data.
Step 3: Semantic fingerprinting routes by similarity.
The packet gets a semantic fingerprint — a vector that characterizes what kind of signal this is. Drug class, event type, signal strength, evidence type. This fingerprint maps to an address in the QIS routing layer.
Step 4: Every institution watching the same drug-event combination pulls the synthesis.
A pharmacovigilance analyst at EMA working on COX-2 inhibitor cardiovascular signals queries the same address. They pull outcome packets from every institution that has deposited signals for that combination:
- FDA FAERS PRR: elevated since Q2 2000
- VigiBase BCPNN: elevated since Q4 2000
- UK Yellow Card ROR: elevated since Q1 2001
- German hospital PV: elevated since Q3 2001
The synthesis happens locally, in milliseconds, without any data ever leaving any institution. The analyst sees: four independent systems, three countries, signal consistent and strengthening over five quarters. This is not a coincidence. This is a safety signal.
Step 5: The loop closes. Insights compound.
The synthesized result goes back into the analyst's local system. Their updated assessment — "signal confirmed across four jurisdictions" — becomes a new outcome packet. This deposits at the same address. Every institution watching that combination now has access to a synthesis they didn't produce themselves.
The math:
N institutions × N(N-1)/2 unique synthesis pathways.
10 pharmacovigilance systems = 45 synthesis pairs currently running in real time.
100 systems = 4,950.
1,000 systems = 499,500.
The intelligence compounds quadratically. The compute scales logarithmically. No aggregator. No shared database. No PHI in the routing layer.
The Routing Mechanism Doesn't Matter
A common question: what technology routes these packets?
QIS is protocol-agnostic. The quadratic scaling — N(N-1)/2 synthesis pathways — comes from the architecture (the complete loop), not from any specific routing implementation.
A pharmacovigilance deployment could route packets via:
- A DHT (Distributed Hash Table) — O(log N) at planetary scale, fully decentralized
- A PostgreSQL database with a semantic similarity index — O(1) for known drug-event combinations
- A vector database (Qdrant, Weaviate) — cosine similarity over fingerprint embeddings
- A REST API with topic-based routing — simple, auditable, works with existing infrastructure
- A message queue (Kafka, Pulsar) — durable, replayable, enterprise-friendly
What makes these all "QIS-compliant" is the loop: pre-distilled outcome packets, deposited at semantically defined addresses, pulled by nodes sharing the same problem space, synthesized locally. The transport is implementation detail.
A Sketch in Python
import hashlib
import json
from datetime import datetime
class PharmacovigSignalNode:
"""
One pharmacovigilance institution participating in QIS.
Deposits distilled signal packets. Never shares raw data.
"""
def __init__(self, institution_id: str, region: str, transport_backend):
self.institution_id = institution_id
self.region = region
self.backend = transport_backend # Any backend: DHT, DB, REST, queue
def distill_signal(
self,
drug_class: str,
event_cluster: str,
signal_strength: float,
evidence_type: str,
sample_size_tier: str
) -> dict:
"""Distill internal PV finding into ~512-byte outcome packet. No PHI."""
return {
"drug_class": drug_class,
"event_cluster": event_cluster,
"signal_strength": round(signal_strength, 4),
"evidence_type": evidence_type,
"sample_size_tier": sample_size_tier,
"geographic_region": self.region,
"reporting_period": datetime.utcnow().strftime("%Y-%m"),
"node_id": self.institution_id,
# No patient data. No case IDs. No raw reports.
}
def semantic_address(self, drug_class: str, event_cluster: str) -> str:
"""Deterministic address for this drug-event combination."""
key = f"pharmavig::{drug_class}::{event_cluster}"
return hashlib.sha256(key.encode()).hexdigest()[:16]
def deposit_signal(self, drug_class: str, event_cluster: str, packet: dict):
"""Post outcome packet to shared address via any transport."""
address = self.semantic_address(drug_class, event_cluster)
self.backend.write(address, packet)
def synthesize_signals(self, drug_class: str, event_cluster: str) -> dict:
"""Pull all signals for this drug-event pair. Synthesize locally."""
address = self.semantic_address(drug_class, event_cluster)
packets = self.backend.query(address)
if not packets:
return {"consensus": "insufficient_data", "n_sources": 0}
strengths = [p["signal_strength"] for p in packets]
regions = list({p["geographic_region"] for p in packets})
evidence_types = list({p["evidence_type"] for p in packets})
avg_strength = sum(strengths) / len(strengths)
elevated_count = sum(1 for s in strengths if s > 0.5)
return {
"drug_class": drug_class,
"event_cluster": event_cluster,
"n_sources": len(packets),
"n_regions": len(regions),
"regions": regions,
"avg_signal_strength": round(avg_strength, 4),
"elevated_across": f"{elevated_count}/{len(packets)} sources",
"evidence_types": evidence_types,
"consensus": "SIGNAL_CONFIRMED" if elevated_count >= 3 else "MONITORING",
}
# Example: Four institutions watching COX-2 inhibitor cardiovascular signals
# Each runs its own signal detection. Each deposits a distilled outcome packet.
# No institution shares raw data with any other.
# backend = DHT_Backend() OR PostgreSQL_Backend() OR REST_Backend()
# — the loop works identically regardless of transport
fda = PharmacovigSignalNode("FDA_FAERS", "north_america", backend)
who = PharmacovigSignalNode("WHO_VIGIBASE", "global", backend)
ema = PharmacovigSignalNode("EMA_EUDRAVIGILANCE", "europe", backend)
uk = PharmacovigSignalNode("MHRA_YELLOWCARD", "uk", backend)
# Each deposits what it sees
fda.deposit_signal("cox2_inhibitor", "cardiovascular_thrombotic",
fda.distill_signal("cox2_inhibitor", "cardiovascular_thrombotic",
signal_strength=0.71, evidence_type="PRR", sample_size_tier="large"))
who.deposit_signal("cox2_inhibitor", "cardiovascular_thrombotic",
who.distill_signal("cox2_inhibitor", "cardiovascular_thrombotic",
signal_strength=0.68, evidence_type="BCPNN", sample_size_tier="xlarge"))
ema.deposit_signal("cox2_inhibitor", "cardiovascular_thrombotic",
ema.distill_signal("cox2_inhibitor", "cardiovascular_thrombotic",
signal_strength=0.74, evidence_type="ROR", sample_size_tier="large"))
uk.deposit_signal("cox2_inhibitor", "cardiovascular_thrombotic",
uk.distill_signal("cox2_inhibitor", "cardiovascular_thrombotic",
signal_strength=0.62, evidence_type="ROR", sample_size_tier="medium"))
# Any node can now synthesize the cross-system picture — locally, in milliseconds
synthesis = fda.synthesize_signals("cox2_inhibitor", "cardiovascular_thrombotic")
# Returns:
# {
# "n_sources": 4,
# "n_regions": 3,
# "avg_signal_strength": 0.6875,
# "elevated_across": "4/4 sources",
# "consensus": "SIGNAL_CONFIRMED"
# }
# — without any patient data ever leaving any institution
This is what Vioxx looked like in 2001 across FAERS, VigiBase, and Yellow Card. The signals were there. The synthesis wasn't.
The Three Natural Forces (Metaphors, Not Mechanisms)
Three self-organizing dynamics emerge from this architecture — they aren't built, they just happen:
Hiring: Pharmacovigilance experts — clinical pharmacologists, epidemiologists, biostatisticians — define what "similar" means for drug-event combinations. Which ontology to use (MedDRA, ICD-10). How to define signal strength tiers. How to weight evidence by sample size. The best experts in signal detection define the similarity function. This is called the Hiring Election — not a vote, a metaphor for getting the right person to define the address space.
The Math: When four institutions deposit signals for the same drug-event combination, and three show elevated signals above threshold, the synthesis naturally surfaces the consensus. There is no added reputation layer, no quality scoring mechanism, no weighted voting. The aggregate of real outcomes from real systems is the election. The math does the work.
Darwinism: A pharmacovigilance network where experts define similarity poorly routes irrelevant packets — analysts stop trusting it. A network with excellent similarity definitions routes gold — it surfaces the Vioxx signal in months, not years. Networks compete. Analysts migrate to what actually works.
These aren't mechanisms to build into the protocol. They emerge from the architecture.
Why This Matters Beyond Vioxx
Pharmacovigilance is one use case. The same architecture applies wherever distributed intelligence nodes are generating insights in isolation and the synthesis is missing:
- Drug-drug interactions: combination signals visible only when multiple health systems deposit outcome packets for the same drug pair
- Pediatric pharmacovigilance: rare in any single database, but across 50 systems worldwide the signal is real
- Biosimilar safety monitoring: post-approval surveillance fragmented across payers, health systems, and registries
- Vaccine safety surveillance: VAERS, the Vaccine Safety Datalink, international systems — same architecture failure, same fix
- Real-world evidence for regulatory submissions: synthesis across RWE studies without pooling patient-level data
The routing mechanism doesn't matter. The expert-defined address space does. The outcome packet format does. The loop does.
What Christopher Thomas Trevethan Discovered
On June 16, 2025, Christopher Thomas Trevethan discovered how to close this loop. Not for pharmacovigilance specifically — for distributed intelligence generally. The insight: when you route pre-distilled outcome packets to semantically defined addresses rather than centralizing raw data, intelligence scales quadratically while compute scales logarithmically.
39 provisional patents have been filed. The protocol is licensed free for humanitarian, research, and educational use. Commercial licenses fund deployment to underserved communities.
Pharmacovigilance in low-income countries — where drug safety infrastructure is weakest and signals from smaller patient populations are most fragile — can participate in the global synthesis network with outcome packets small enough to transmit over SMS. The 512-byte packet was not accidental.
The Question That Closes the Argument
The signals existed in 2001. If an FDA analyst could have queried a single address and pulled back what VigiBase saw, what Yellow Card saw, and what EMA saw — all synthesized locally, no data shared, no HIPAA issue, no negotiation, in milliseconds —
Would Vioxx have stayed on the market for five years?
The answer is architectural. And so is the fix.
QIS — Quadratic Intelligence Swarm — is an open protocol discovered by Christopher Thomas Trevethan. 39 provisional patents filed. Free for humanitarian, research, and educational use.
Related articles in this series:
- Why Federated Learning Has a Ceiling — And What QIS Does Instead
- QIS for Drug Discovery: Why Clinical Trials Fail
- QIS for Public Health: Why Disease Surveillance Systems Fail to Synthesize
- Why HIPAA Is Not the Problem — Privacy by Architecture
- QIS Is an Open Protocol — Here Is the Architectural Spec
Top comments (0)