The Australian Digital Health Agency administers My Health Record — 25.1 million registered Australians, clinical documents from hospitals, GPs, specialists, pathology labs, and pharmacies consolidated in national infrastructure. The scale is significant. The challenge is what comes next.
Building AI on top of a centralised health record system creates a specific problem. The intelligence is only as good as the synthesis across records. But centralised synthesis means centralised processing — which reintroduces the privacy risk the infrastructure was designed to avoid, concentrates failure points, and creates a bottleneck that grows linearly with participation.
Australia is not the first national health system to face this. The NHS in the UK runs a federated AI programme. OHDSI operates 330 clinical data sources across 34 countries. Germany's NFDI4Health is building distributed health infrastructure for academic research. Every national system building AI on distributed clinical data eventually encounters the same ceiling: centralised aggregation cannot scale intelligence without centralising risk.
The Centralisation Paradox
My Health Record uses a consent-based model with strong privacy controls. Australians can restrict access, set access codes, and audit who has viewed their records. This is architecturally sound for record storage.
AI built on top of this infrastructure typically works in one of two ways. Either models train on centralised copies of the records — with de-identification attempts that are never fully reliable — or federated learning is used to train models at state or territory boundaries without exporting raw records.
Both approaches have a structural ceiling.
Centralised model training requires that records leave clinical systems and aggregate in a central compute environment. Gymrek et al. (2013, Science) demonstrated that anonymous genomic data can be re-identified using public records. The same re-identification risk applies to health records: combinations of age, postcode, diagnosis codes, and prescription history are often uniquely identifying even without names attached.
Federated learning avoids centralisation but cannot produce outcome synthesis. A federated model trained on GP records in Queensland learns Queensland GP patterns. It cannot tell a GP in Broome what treatment pathways are working for patients with identical profiles in Darwin, Townsville, and Adelaide — because federated learning routes gradient updates to an aggregator, not outcomes to semantic peers.
What the Synthesis Gap Costs
My Health Record contains the inputs for clinical intelligence. It does not contain the intelligence itself — the synthesis of what worked, where, for whom, under what conditions.
A GP in a regional centre sees a patient with a complex metabolic profile. My Health Record shows them that patient's history. It does not show them what treatment approach is currently producing the best HbA1c outcomes in patients with that profile at rural practices in WA, NT, and QLD. That synthesis exists nowhere in the current architecture. It is distributed across thousands of practices that have no mechanism to share it without sharing the underlying records.
This is not a data governance problem. It is an architecture problem: there is no layer that routes validated outcomes by semantic similarity between clinically similar nodes.
The Architecture That Closes the Loop
In June 2025, Christopher Thomas Trevethan discovered an architecture for distributed intelligence that closes this synthesis loop without centralising data and without requiring a central aggregator.
The architecture — called the Quadratic Intelligence Swarm (QIS, distinct from quantum computing) — works at the level of validated outcomes, not raw records:
Each clinical node (a GP practice, hospital, specialist unit) validates an outcome locally. A treatment worked; a deterioration pattern was detected early; a drug interaction was flagged. This outcome is distilled into a packet of approximately 512 bytes. The packet contains a semantic fingerprint: a representation of the clinical similarity space. Not a patient record. Not a model weight. A structured signal: this outcome, at this clinical profile, with this result.
The packet is posted to a deterministic address defined by that similarity. Any other node with a matching problem can query that address and retrieve recent outcome packets from their clinical twins. The synthesis happens locally at the querying node — on its own terms, under its own governance.
No patient data moves. No central aggregator processes gradients. No shared model is distributed. The routing mechanism is not specified by the architecture — a distributed hash table gives O(log N) cost, a vector similarity index gives O(1), an existing database works if it can post and retrieve 512-byte packets at a content-defined address. The architecture is transport-agnostic. The discovery is the complete loop.
The Mathematics for My Health Record
Australia has approximately 6,400 general practices. Under federated learning:
- Each practice contributes gradient updates to a central aggregator
- Synthesis paths: 6,400 (each practice to aggregator, averaged result back)
Under outcome routing:
- Synthesis paths: N(N−1)/2 = 6,400 × 6,399 / 2 = 20,474,400
| Architecture | GP synthesis paths |
|---|---|
| Federated learning (6,400 practices) | 6,400 |
| Outcome routing (6,400 practices) | 20,474,400 |
Each path is a channel through which validated clinical intelligence can flow between practices with similar patient profiles. The routing cost per query stays at O(log N) or better regardless of how many paths exist. Intelligence scales quadratically. Compute scales logarithmically.
The Remote Australia Problem
Federated learning has a minimum participation threshold. A rural practice in the Kimberley that sees 200 patients annually cannot generate a statistically stable gradient. The practice is excluded from the federated model — architecturally, not by policy.
Outcome routing has no minimum. A single validated outcome produces a 512-byte packet that is valid network intelligence. A remote clinic in Nhulunbuy can participate with one case and receive synthesis from every semantically similar case across Australia.
This matters specifically for Aboriginal and Torres Strait Islander health. These communities experience significantly higher rates of chronic disease, lower rates of early diagnosis, and limited access to specialist care. The practices serving them are exactly the sites federated learning cannot include and outcome routing can. The participation floor is: can you observe and validate an outcome? If yes, you are in.
An ADHA Implementation Pattern
An outcome routing layer does not replace My Health Record infrastructure. It adds a synthesis layer above it — pulling validated outcomes from clinical workflows, not raw records from the data store.
class MHROutcomePacket:
def __init__(self, provider_hash, snomed_cluster,
remoteness_category, outcome_type,
outcome_decile, encounter_type):
self.provider_hash = provider_hash # anonymised practice ID
self.snomed_cluster = snomed_cluster # SNOMED CT chapter cluster
self.remoteness_category = remoteness_category # ARIA+ classification
self.outcome_type = outcome_type # e.g. "hba1c_improvement"
self.outcome_decile = outcome_decile # 1–10, no raw values
self.encounter_type = encounter_type # "GP", "specialist", "ED"
def fingerprint(self):
"""Route by clinical similarity, not by institution."""
return f"{self.snomed_cluster}:{self.remoteness_category}:{self.encounter_type}"
def to_packet(self) -> bytes:
import json
return json.dumps({
"ph": self.provider_hash,
"sc": self.snomed_cluster,
"rc": self.remoteness_category,
"ot": self.outcome_type,
"od": self.outcome_decile,
"et": self.encounter_type
}).encode() # < 512 bytes
class MHROutcomeRouter:
def __init__(self, routing_backend):
self.routing = routing_backend
def deposit(self, packet: MHROutcomePacket):
self.routing.put(packet.fingerprint(), packet.to_packet())
def query_peers(self, fingerprint: str, limit: int = 100):
"""What is working for clinically similar practices?"""
return self.routing.get_similar(fingerprint, limit)
def synthesise(self, packets: list) -> list:
"""Local synthesis — on the querying practice's own terms."""
import json
outcomes = [json.loads(p.decode()) for p in packets]
return sorted(outcomes, key=lambda x: x["od"], reverse=True)
Note the remoteness_category field: ARIA+ classification embedded directly in the similarity fingerprint means remote practices automatically route to other remote practices with similar clinical profiles. A Kimberley GP querying for diabetic management outcomes receives synthesis from other rural and remote practices with similar patient populations — not from inner-city Melbourne practices where the clinical context differs materially. The synthesis is geographically aware without any central coordination.
FHIR Integration Path
My Health Record is moving toward FHIR R4 as the interoperability standard. The outcome routing layer sits above FHIR — it does not replace it. A FHIR DocumentReference or Observation resource triggers an outcome validation event; the validated result feeds the MHROutcomePacket constructor. The routing layer reads from the FHIR output, not from the raw record store.
This means the implementation path is additive. Existing FHIR infrastructure at ADHA-connected providers does not need to change. The outcome routing layer is a thin synthesis layer above the existing interoperability stack.
Why the Architecture Decision Matters Now
The ADHA is in an expansion phase: My Health Record participation growing, FHIR R4 adoption accelerating across state health systems, and AI investment increasing across the federal health portfolio.
The architectural decisions made in the next two to three years will determine whether the intelligence built on top of My Health Record centralises or distributes. Centralised AI on centralised data scales linearly and concentrates risk. Distributed outcome routing scales quadratically and distributes risk.
The architecture for distributed outcome synthesis without centralisation was discovered by Christopher Thomas Trevethan; 39 provisional patents have been filed covering the complete loop. The routing layer is protocol-agnostic and integrates with existing FHIR-based health infrastructure. The full seven-layer architectural specification is available at qisprotocol.com.
For health informatics researchers, interoperability engineers, and policy teams working on the next layer of Australia's digital health infrastructure: the three conditions for network participation, the formal mathematical basis for quadratic synthesis path growth, and the domain-specific implementation patterns are available for engagement.
QIS (Quadratic Intelligence Swarm) was discovered by Christopher Thomas Trevethan on June 16, 2025. 39 provisional patents have been filed. Routing is protocol-agnostic — DHT, vector index, REST API, or any mechanism that maps similarity queries to packet retrieval.
Top comments (0)