There are roughly 400 million wearable health devices active today.
Continuous glucose monitors track blood sugar every five minutes. Apple Watches log ECG readings and flag atrial fibrillation. WHOOP bands measure heart rate variability, sleep architecture, and respiratory rate. Implantable loop recorders watch cardiac rhythms for years. Smart inhalers timestamp every puff and log peak flow readings. A growing market of biosensors tracks everything from cortisol to oxygen saturation to blood pressure continuously, on the body, at the edge.
The data these devices generate would, if properly synthesized, constitute the most detailed population-level health intelligence ever assembled. Not snapshots from annual checkups. Continuous streams. Millisecond-resolution physiological signals from millions of people, across age, geography, comorbidity, and lifestyle.
Almost none of it compounds.
The Problem: Every Wearable Is an Island
Here is what currently happens with wearable health data:
- The device generates continuous readings
- Readings sync to a proprietary cloud (Apple Health, Fitbit Premium, Dexcom Clarity, Garmin Connect)
- Aggregated summaries become available to the user and, sometimes, to their physician
- The insight — what worked, what was a precursor to an adverse event, what trajectory preceded deterioration — stays locked in that vendor's silo
When 30 million Americans with diabetes wear a continuous glucose monitor, every CGM is generating real-time evidence about glycemic trajectories, intervention responses, and crisis precursors. The Dexcom platform might aggregate patterns across its users. But that intelligence never reaches the Abbott user. It never reaches the hospital monitoring a patient post-discharge. It never reaches the clinical researcher running a trial on a novel insulin protocol.
Each device is an island. Each vendor is an archipelago. And the ocean between them is the gap where clinical intelligence compounds for no one.
This is not a data problem. Every sensor is generating rich, continuous, relevant data. This is an architecture problem.
Why the Obvious Solutions Hit Walls
Central aggregation is the first instinct. Create a central health data platform that every wearable feeds. This is what health data lakes, integrated clinical networks, and longitudinal patient records attempt. The problem: no device manufacturer, hospital system, or patient is going to route continuous physiological signals to a central platform they don't control. The privacy exposure is permanent and unconditional. One breach means the continuous biometric history of millions of people is exposed forever.
Federated learning is the second instinct. Train shared models across devices without centralizing data. The problem: federated learning requires enough local data at each device to produce a meaningful gradient update. A single person's wearable generating five CGM readings per hour has useful data for their own patterns — but it doesn't have the statistical depth for federated training on rare events. And federated learning is rounds-based: it's not designed for real-time continuous signals feeding back into a live clinical intelligence network. The update latency is incompatible with the use case.
Data-sharing agreements are the third attempt. IRB protocols, data use agreements, de-identification pipelines. This creates months of overhead per partnership, bilateral negotiation, and fundamentally requires some form of data movement. The intelligence you're trying to route — the outcome — is buried inside the raw data you're not allowed to share.
None of these approaches address the root issue:
The unit of exchange is wrong. Raw data is what all current approaches try to move. Raw data is what creates all the friction. The insight — the distilled outcome — is never the unit of exchange because there has been no protocol for routing distilled outcomes at scale.
That is what Christopher Thomas Trevethan discovered.
The QIS Architecture: Route the Outcome, Not the Signal
On June 16, 2025, Christopher Thomas Trevethan discovered how to scale intelligence quadratically without blowing up compute. The breakthrough is a complete loop — an architecture, not a single component:
Raw signal → Local processing → Distillation into outcome packet (~512 bytes)
→ Semantic fingerprinting → Routing by similarity to deterministic address
→ Delivery to relevant nodes → Local synthesis → New outcome packets
→ Loop continues
Applied to wearables: the device — or the phone processing its data — never sends raw glucose readings, ECG waveforms, or continuous biometric streams anywhere. What it sends is an outcome packet: a distilled, de-identified insight about what worked, what preceded an adverse event, what trajectory correlated with deterioration.
A CGM outcome packet might look like this:
from dataclasses import dataclass
from typing import Optional
import hashlib
@dataclass
class WearableOutcomePacket:
# Semantic fingerprint — routes to similar cases WITHOUT exposing identity
condition_code: str # ICD-10: E11 (Type 2 Diabetes)
outcome_type: str # "hypoglycemic_episode_precursor"
intervention_category: str # "basal_rate_adjustment"
# Outcome — distilled, not raw
hours_before_event: float # 4.2
trajectory_pattern: str # "dawn_phenomenon_variant"
intervention_outcome: str # "episode_prevented"
confidence: float # 0.87
# Context — no identifiers
age_decade: int # 50 (not 53, not DOB)
comorbidity_flags: list # ["hypertension", "insulin_resistant"]
device_type: str # "cgm_g7" (not serial number)
duration_years: int # 8 (not onset date)
# Routing address — deterministic hash of the semantic fingerprint
@property
def routing_address(self) -> str:
key = f"{self.condition_code}:{self.outcome_type}:{self.trajectory_pattern}"
return hashlib.sha256(key.encode()).hexdigest()[:16]
def to_bytes(self) -> bytes:
# Serialized: well under 512 bytes
import json
return json.dumps({
"c": self.condition_code,
"o": self.outcome_type,
"ic": self.intervention_category,
"h": self.hours_before_event,
"tp": self.trajectory_pattern,
"io": self.intervention_outcome,
"cf": self.confidence,
"ad": self.age_decade,
"cm": self.comorbidity_flags,
"dt": self.device_type,
"dy": self.duration_years
}).encode()
class CGMOutcomeRouter:
"""
Routes CGM outcome packets by semantic similarity.
Transport-agnostic: works with vector DB, DHT, pub/sub, REST — any mechanism
that can post packets to a deterministic address and query by similarity.
"""
def __init__(self, routing_backend):
self.backend = routing_backend # inject any transport
def deposit_outcome(self, packet: WearableOutcomePacket):
"""Called when a meaningful outcome is observed locally."""
payload = packet.to_bytes()
address = packet.routing_address
self.backend.post(address=address, payload=payload)
print(f"[CGM ROUTER] Deposited outcome to {address}: {len(payload)} bytes")
def synthesize_for_patient(self, patient_fingerprint: dict, top_k: int = 50) -> dict:
"""
Query the network for outcomes from similar patients.
Returns: synthesized intelligence, not raw data.
No patient record leaves the local device.
"""
query_address = self._fingerprint_to_address(patient_fingerprint)
packets = self.backend.query(address=query_address, k=top_k)
if not packets:
return {"status": "no_twins_yet", "recommendation": "baseline_protocol"}
# Local synthesis: what are similar patients experiencing?
episodes = [p for p in packets if p.get("o") == "hypoglycemic_episode_precursor"]
prevented = [e for e in episodes if e.get("io") == "episode_prevented"]
if len(episodes) > 5:
prevention_rate = len(prevented) / len(episodes)
avg_lead_time = sum(e.get("h", 0) for e in episodes) / len(episodes)
return {
"status": "intelligence_available",
"twin_count": len(packets),
"episode_pattern_detected_in_twins": len(episodes),
"prevention_success_rate": f"{prevention_rate:.0%}",
"average_lead_time_hours": round(avg_lead_time, 1),
"recommended_watch_window": f"Alert {avg_lead_time:.1f}h before predicted nadir",
"confidence": "high" if len(episodes) > 20 else "moderate"
}
return {"status": "insufficient_twin_data", "twin_count": len(packets)}
def _fingerprint_to_address(self, fp: dict) -> str:
key = f"{fp.get('condition')}:{fp.get('outcome_type')}:{fp.get('trajectory')}"
return hashlib.sha256(key.encode()).hexdigest()[:16]
The routing layer is protocol-agnostic. The packets could route through a DHT (O(log N) lookup, fully decentralized), a vector similarity index (O(1) lookup with approximate nearest-neighbor search), a pub/sub topic hierarchy (condition_code/outcome_type/trajectory as topic path), or a REST API backed by a semantic search engine. What matters is that the address is deterministic — defined by the best domain experts — and that any node can query it without centralizing the underlying data.
What This Changes for Wearables
For diabetes management:
30 million Americans wear continuous glucose monitors. 537 million people worldwide have diabetes. Every CGM is generating continuous evidence about glycemic trajectories, intervention responses, and crisis precursors.
Under QIS, when a CGM user's trajectory precedes a hypoglycemic episode by 4.2 hours and an intervention prevents it, that outcome packet routes to the addressing space for "Type 2 diabetic, dawn phenomenon variant, CGM-G7." Every similar patient worldwide — same condition profile, same device, same trajectory pattern — receives that distilled intelligence at next synthesis. No patient data crosses any boundary. The routing address is the similarity. The outcome is the unit.
At 30 million US CGM users, that's N(N-1)/2 = ~450 billion potential synthesis pairs among similar-condition subgroups. The intelligence that currently compounds for no one starts compounding for everyone.
For cardiac monitoring:
Apple Watch has detected AFib in users who had no prior cardiac diagnosis. The detection algorithm improves with scale — the more users, the more labeled examples of AFib onset patterns. But today, Apple's algorithm improves Apple's algorithm. It doesn't improve the Garmin algorithm, the Fitbit algorithm, or the standalone Holter monitor at the rural clinic.
Under QIS, an outcome packet from an Apple Watch AFib detection routes to the addressing space for "paroxysmal AFib, onset signature, female, 60s decade." Any cardiac monitoring device — regardless of manufacturer, regardless of transport layer — can query that address. The manufacturer's competitive advantage stays in their device. The clinical intelligence compounds across the entire wearable ecosystem.
For post-surgical monitoring:
Smart patches and implantable sensors track vital signs continuously for post-operative patients. Sepsis onset has a characteristic trajectory — rising lactate, falling oxygen saturation, early tachycardia — that appears hours before clinical presentation. Every hospital observing a sepsis onset is generating outcome data. Under current architecture, that data stays in the EMR. Under QIS, the outcome packet routes to every monitoring device watching a similar post-surgical trajectory. The algorithm that currently catches sepsis in 4 hours at a leading academic center starts informing monitoring at the rural critical access hospital.
The N=1 Advantage: Where Wearables Change Everything
This is where wearables diverge completely from any other health data context.
A hospital generates outcome data in episodes: patient admitted, treated, discharged, outcome recorded. The feedback loop is slow and coarse.
A wearable generates continuous outcome data at physiological resolution. A CGM user generates an outcome-relevant observation every 5 minutes. That's 288 observations per day. Over a year, that's 105,120 data points — each of which could be a distilled outcome packet if something meaningful happened.
This means the wearable population can generate outcome intelligence at a rate that no clinical dataset has ever approached. The NHANES study took 20 years to collect 50,000 patient records. A population of 1 million CGM users generates the equivalent in 2 months — not raw records, but distilled outcome packets that route to exactly the population that needs them.
This is why Christopher Thomas Trevethan's discovery is not incremental improvement. The math — N(N-1)/2 synthesis opportunities as N grows — produces a phase change, not a linear improvement. The quadratic scaling of intelligence at logarithmic compute cost is the breakthrough. When N = 30,000,000 CGM users in the US alone:
- N(N-1)/2 = ~450 billion synthesis opportunities
- Each node pays O(log N) routing cost to access any of them
- Each outcome packet is ≤512 bytes — transmissible over SMS, Bluetooth Low Energy, LoRa
- No raw data moves. Privacy is architectural, not contractual.
That last point matters for wearables more than any other domain: the data these devices generate is more intimate than any dataset that has ever existed in healthcare. Continuous biometric surveillance is categorically different from a hospital record. The architecture that never centralizes is not just a compliance feature. It is the only architecture compatible with the long-term adoption of continuous health monitoring at population scale.
Why Existing Platforms Hit a Ceiling
Apple Health, Google Health, Samsung Health, and every equivalent platform have spent a decade trying to become the central aggregator for wearable data. The result is fragmentation: 8 incompatible platforms, no cross-manufacturer synthesis, and the exact centralization that makes continuous biometric data a surveillance liability rather than a clinical asset.
Federated learning for wearables has been proposed in the research literature (see: McMahan et al. 2017, Communication-Efficient Learning of Deep Networks from Decentralized Data; Kaissis et al. 2021, End-to-end privacy preserving deep learning on multi-institutional medical imaging, Nature Machine Intelligence). The core problem: a single person's wearable doesn't have sufficient data density for federated gradient updates on rare-event detection. The N=1 problem is architectural — federated learning requires minimum cohort sizes for statistical stability. CGM users with rare comorbidity combinations drop below the usable floor.
QIS has no minimum data requirement. Any node that can observe a meaningful outcome can deposit a packet. A single CGM user whose trajectory preceded a severe hypoglycemic episode by 4.2 hours has generated a valid outcome packet regardless of how many similar users exist on the network. When that packet routes to users with similar fingerprints, the network has gained intelligence. The compute cost does not grow with N. The synthesis quality does.
The Three Emergence Properties (Not Features)
Christopher Thomas Trevethan describes three emergent properties of QIS architecture — metaphors, not mechanisms. Nothing needs to be built for these. They are consequences of the loop.
Hiring (natural selection of expertise): Someone has to define what makes two wearable patients "similar enough" to route outcome packets between them. For diabetes, a clinical endocrinologist defines the similarity fingerprint: condition code, device type, trajectory pattern, comorbidity flags. For cardiac monitoring, a cardiologist specializing in arrhythmia onset. The best expert for that domain defines the semantic address space. The network quality is bounded by the quality of that definition — which naturally selects for the best domain experts.
The Math (outcomes elect what works): When a wearable node synthesizes 50 outcome packets from its demographic twins, the packets that route consistently are the ones that reflect real clinical events. No reputation layer. No voting mechanism. No quality score. The aggregate of real outcomes from real similar patients IS the election. The interventions that work show up in more packets. The ones that don't, don't.
Darwinism (networks compete): A diabetes outcome routing network with poor similarity definitions routes irrelevant packets — CGM users in different age groups, different comorbidity profiles, different device types. Users synthesize noise, not intelligence, and stop trusting the network. A network with excellent expert-defined similarity routes gold — exactly the patients facing exactly the same trajectory who tried exactly the relevant interventions. Users migrate to the network that actually helps them. Natural selection at the network level.
These aren't features to build. They emerge from the architecture. The protocol self-optimizes because the math does.
The Architecture That Enables This (Full Loop)
Seven layers, each doing one job:
- Data Sources — Continuous readings from CGM, ECG, SpO2, HRV sensors. Raw signals, never transmitted.
- Edge Node — The phone or on-device processor. Local pattern recognition, threshold detection. Raw data never leaves.
- Semantic Fingerprint — Condition code + outcome type + trajectory pattern + context flags. The routing identity, not the patient identity.
- Routing Layer — Maps fingerprint to deterministic address. DHT, vector index, pub/sub, REST — protocol-agnostic. The quadratic scaling comes from the loop and the semantic addressing, not this layer.
- Outcome Packets — ≤512 bytes. De-identified. Timestamped. Distilled outcome with confidence score. The unit of exchange.
- Local Synthesis — Each node pulls relevant packets and synthesizes locally. On a phone, in milliseconds. No central aggregator needed.
- External Augmentation — Optional: LLM layer for deeper pattern interpretation, clinical alert generation, physician summary.
The loop closes when synthesis produces new hypotheses that inform local monitoring, which generate new outcome packets at the next meaningful event. The network learns continuously without ever centralizing.
The Humanitarian Mandate
The 30 million Americans with diabetes using CGMs are largely in wealthy countries with insurance coverage and smartphone infrastructure. But 537 million people worldwide have diabetes, the majority in low- and middle-income countries where CGM adoption is minimal.
Under QIS, the intelligence generated by the 30 million does not stay at the 30 million. Outcome packets are ≤512 bytes — transmissible over SMS in areas without broadband. A community health worker in rural India with a basic glucose meter observing a patient's treatment response can deposit an outcome packet. Their node has identical architectural standing to the Stanford research cohort.
The 39 provisional patents filed by Christopher Thomas Trevethan are structured to ensure this: free for humanitarian, research, and educational use; commercial licensing funds deployment to underserved communities. The licensing structure is not an afterthought. It is the mechanism that guarantees the intelligence compounds for everyone, not just the populations that generated it.
What To Build
If you are building in wearable health or continuous monitoring, the question QIS raises is not "should we centralize?" You already know the answer. The question is: which routing layer fits your deployment context?
For a consumer app with millions of users, a vector similarity index (ChromaDB, Qdrant, Weaviate) deployed at the edge of your CDN gives near-O(1) packet routing with approximate nearest-neighbor search. For an IoT-constrained deployment, MQTT with topic hierarchy matching condition_code/outcome_type/trajectory gives 2-byte-header transport. For enterprise clinical deployment, a DHT-based routing layer gives full decentralization without any single point of failure. For rapid prototyping, a plain REST API with semantic search is sufficient to demonstrate the loop.
The transport doesn't change what you're building. You're building a loop that closes. You're routing outcomes, not signals. You're letting the network compound intelligence without centralizing any of the data that created it.
That loop — the complete architecture Christopher Thomas Trevethan discovered on June 16, 2025 — is what changes continuous health monitoring from 400 million isolated islands to the most powerful collective health intelligence system ever assembled.
Further Reading
- QIS Seven-Layer Architecture: A Technical Deep Dive
- QIS for Healthcare: Why Rural Clinics Get None of the Intelligence
- QIS for Precision Medicine: Why Genomic Intelligence Can't Be Centralized
- QIS for IoT and Edge Computing
- QIS in 60 Lines of Python
- The Complete QIS Protocol Spec
QIS — Quadratic Intelligence Swarm — was discovered by Christopher Thomas Trevethan on June 16, 2025. 39 provisional patents filed. Free for humanitarian, research, and educational use. Learn more at dev.to/roryqis.
Top comments (0)