Every 10 days, a cylindrical instrument about the size of a fire extinguisher descends 2,000 meters into the ocean, drifts at depth for a week, then rises to the surface recording temperature and salinity at every pressure level. It transmits its profile via satellite in under 90 seconds, then sinks again. It does this for four years before its battery dies.
There are more than 4,000 of these instruments. They are in the Atlantic, Pacific, Indian, Southern, and Arctic Oceans. They are maintained by 30 countries. They have collectively produced over 3 million profiles since 2000. The Argo program is the largest coordinated oceanographic observing system in history.
The data is archived at 11 national data assembly centers. It is quality-controlled, distributed, and publicly accessible within 24 hours of collection. Thousands of scientists use it. Dozens of operational forecasting centers ingest it. It has transformed physical oceanography.
What it does not do is synthesize ocean state intelligence in real time. The floats observe. The archives store. The scientists analyze — independently. The outcome of analysis at one float's profile domain is not routed to scientists working on similar profiles in a different basin. The synthesis loop is open.
This is Article #040 in the "Understanding QIS" series. Previous: Part 39 — QIS for Pandemic Preparedness. The pattern is the same across every domain: distributed observation systems generate more signal than any centralized architecture can synthesize in real time.
The Argo Network: The Most Distributed Observational Platform on Earth
Argo was conceived at the 1999 OceanObs conference and fully deployed by 2007. Its core innovation was simplicity: a float that descends, drifts, profiles, and transmits autonomously, with no on-board intelligence and no real-time coordination between floats.
Roemmich et al. (2009) documented the program's first decade: Argo transformed understanding of ocean heat content, freshwater fluxes, and thermohaline circulation patterns globally. Johnson et al. (2022) updated the assessment: Argo profiles have become the primary ground truth for ocean models, climate reanalysis products, and operational forecasting from CMEMS to NCEP to the UK Met Office.
The Biogeochemical Argo (BGC-Argo) expansion added sensors for oxygen, nitrate, pH, chlorophyll, backscatter, and irradiance. Claustre et al. (2020) documented the scientific potential: 1,000 BGC floats observing across all ocean basins, collecting the multi-sensor profiles that were previously possible only from expensive ship surveys. A single BGC-Argo float carries more sensor modalities than the first oceanographic research cruises.
What 4,000 autonomous profiling floats cannot do is communicate with each other. They observe independently. Their profiles inform independent analyses. When a float near the Labrador Sea observes anomalous deep water formation, the signal is available in the archive within 24 hours — but it is not automatically routed to scientists studying AMOC (Atlantic Meridional Overturning Circulation) anomalies in the South Atlantic, or to seasonal forecasting centers running ensemble models where the same signal would update transport estimates.
The floats are the sensors. The archives are the storage. The synthesis gap is between them.
Why Existing Systems Cannot Close the Loop
Argo data assembly centers (Coriolis, US GODAE, BODC, and 8 others) provide world-class quality control and distribution. Their function is archival, not synthetic. A delayed-mode quality-controlled profile appears in the archive 12 months after collection. A real-time profile appears within 24 hours with preliminary quality control. Neither path routes the outcome intelligence derived from the profile to relevant observers.
Operational ocean forecasting (CMEMS, NCEP GODAS, TOPAZ, BLUElink) ingests Argo profiles as observations for data assimilation. The assimilation systems synthesize Argo observations with model state estimates. This is centralized synthesis — every observation must flow through the assimilation center's infrastructure. Turpin et al. (2022) documented the computational constraint: global operational ocean forecasting centers run ensemble systems where Argo observations improve analyses, but the synthesis is batch (daily cycle), centralized (single assimilation center), and model-dependent (observations are useful only insofar as they constrain model state).
Federated learning for ocean science encounters the same structural barriers it faces in every distributed domain. The oceanographic community does not operate with patient-privacy data walls — Argo data is public. The constraint is different: the diversity of observing instruments, analysis methodologies, and scientific questions across 30 participating nations makes coordinating a shared FL gradient structure nearly impossible in practice. More fundamentally, the valuable oceanographic outcome is not a gradient update — it is a validated observation: this water mass had this temperature anomaly at this depth with this confidence level, and it predicts that downstream behavior.
Float-to-float communication is not part of the Argo system by design. Floats surface, transmit via Iridium or Argos, and submerge. They are autonomous precisely because they require no coordination infrastructure. The insight from one float's profile does not reach another float — not because of a design failure, but because the Argo architecture was optimized for maximum spatial coverage at minimum cost, not for real-time inter-observation synthesis.
The constraint is structural. 4,000 floats observing continuously. 3 million profiles archived. Synthesis happens downstream, in individual analysis pipelines, independently.
What QIS Routes Instead
QIS — Quadratic Intelligence Swarm — does not route raw float profiles. It routes outcome packets: validated oceanographic deltas observed at a specific float, for a specific water mass characteristic, with a specific confidence level.
The OceanOutcomePacket structure for the Argo network looks like this:
-
float_id: WMO float identifier (anonymized if needed for cross-institution routing) -
basin_region: WOCE hydrographic region or functional ocean region -
depth_range: pressure range in decibars (surface, thermocline, deep) -
observation_type:"temperature_anomaly","salinity_anomaly","oxygen_depletion","pH_shift","chlorophyll_bloom_onset","AMOC_proxy_signal","heat_content_delta" -
outcome_delta: normalized departure from climatological baseline (Argo climatology, World Ocean Atlas) -
confidence_level: based on float calibration history and QC flag status -
water_mass_tag: NADW, AAIW, AABW, mode water, etc. — for semantic routing -
temporal_resolution: observation window -
semantic_fingerprint: hash of basin_region + water_mass_tag + observation_type
This structure compresses to under 512 bytes. Any float that can compute a validated departure from climatology participates — regardless of whether it is a core Argo float, a BGC-Argo float with 6 sensor channels, or a new deep Argo float profiling to 6,000 meters.
The Python Implementation
from __future__ import annotations
import hashlib
import json
import random
from dataclasses import dataclass, field, asdict
from collections import defaultdict
@dataclass
class OceanOutcomePacket:
float_id: str
basin_region: str # e.g. "North_Atlantic_Subpolar", "Southern_Ocean_Indian_Sector"
depth_range: str # e.g. "0-200m", "200-1000m", "1000-2000m"
observation_type: str # e.g. "temperature_anomaly", "oxygen_depletion"
outcome_delta: float # normalized departure from WOA/Argo climatology
confidence_level: float # 0.0-1.0, from QC history + calibration status
water_mass_tag: str # e.g. "NADW", "AAIW", "AABW", "mode_water"
observation_window: str # e.g. "2025-Q1"
packet_version: str = "1.0"
def semantic_fingerprint(self) -> str:
key = f"{self.basin_region}:{self.water_mass_tag}:{self.observation_type}"
return hashlib.sha256(key.encode()).hexdigest()[:16]
def byte_size(self) -> int:
return len(json.dumps(asdict(self)).encode("utf-8"))
class OceanOutcomeRouter:
"""
Routes OceanOutcomePackets between float networks, data assembly centers,
operational forecasting centers, and research groups.
Three Elections continuously update routing weights:
- CURATE: floats and regions with validated anomaly signal earn elevated weight
- VOTE: outcome packets that improve downstream forecast accuracy accumulate trust
- COMPETE: water-mass domain expertise self-organizes around validated observation
"""
def __init__(self):
self.nodes: dict[str, dict] = {}
self.routing_weights: dict[str, float] = defaultdict(lambda: 1.0)
self.packet_log: list[OceanOutcomePacket] = []
self.node_trust: dict[str, float] = defaultdict(lambda: 0.5)
self.water_mass_expertise: dict[tuple, float] = defaultdict(lambda: 0.5)
def register_node(
self,
node_id: str,
name: str,
basin_domains: list[str],
observation_types: list[str],
water_mass_focus: list[str] | None = None,
is_lmic_program: bool = False,
) -> None:
self.nodes[node_id] = {
"name": name,
"basin_domains": basin_domains,
"observation_types": observation_types,
"water_mass_focus": water_mass_focus or [],
"is_lmic_program": is_lmic_program,
"packet_count": 0,
}
print(f" [REGISTER] {name} ({node_id}) | basins={basin_domains}")
def validate_outcome(self, packet: OceanOutcomePacket) -> bool:
if packet.float_id not in self.nodes:
print(f" [REJECT] Unknown float/node: {packet.float_id}")
return False
if packet.byte_size() > 1024:
print(f" [REJECT] Packet too large: {packet.byte_size()} bytes")
return False
if not (0.0 <= packet.confidence_level <= 1.0):
print(f" [REJECT] Invalid confidence level: {packet.confidence_level}")
return False
return True
def route(self, packet: OceanOutcomePacket) -> list[str]:
"""
Semantic routing: match on basin_domain, observation_type, and water_mass_focus.
A North Atlantic temperature anomaly routes to AMOC researchers, operational
forecasters, and any node with NADW water mass focus — across institutions.
"""
if not self.validate_outcome(packet):
return []
recipients = []
for node_id, meta in self.nodes.items():
if node_id == packet.float_id:
continue
basin_match = packet.basin_region in meta["basin_domains"]
type_match = packet.observation_type in meta["observation_types"]
water_mass_match = packet.water_mass_tag in meta["water_mass_focus"]
if basin_match or type_match or water_mass_match:
# Confidence-weighted routing: high-confidence observations reach more nodes
weight = self.routing_weights[node_id] * packet.confidence_level
recipients.append((node_id, weight))
recipients.sort(key=lambda x: x[1], reverse=True)
self.packet_log.append(packet)
self.nodes[packet.float_id]["packet_count"] += 1
routed_to = [n for n, _ in recipients]
print(
f" [ROUTE] {packet.float_id} -> {routed_to} "
f"| basin={packet.basin_region} type={packet.observation_type} "
f"delta={packet.outcome_delta:+.3f} conf={packet.confidence_level:.2f} "
f"wm={packet.water_mass_tag} size={packet.byte_size()}B fp={packet.semantic_fingerprint()}"
)
return routed_to
def _election_curate(self) -> None:
"""
CURATE: Floats and regions with consistent high-magnitude validated anomaly
signal earn elevated routing weight. Novel water mass anomalies surface;
climatological noise is deprioritized.
"""
node_deltas: dict[str, list[float]] = defaultdict(list)
for p in self.packet_log:
weighted_delta = abs(p.outcome_delta) * p.confidence_level
node_deltas[p.float_id].append(weighted_delta)
for node_id, deltas in node_deltas.items():
avg_signal = min(sum(deltas) / len(deltas), 1.0)
self.routing_weights[node_id] = round(0.5 + avg_signal * 0.5, 3)
def _election_vote(self) -> None:
"""
VOTE: Nodes whose outcomes improve forecast accuracy accumulate trust.
A float that consistently predicts downstream AMOC proxy behavior gets
higher weight in the next synthesis cycle.
"""
recent = self.packet_log[-30:] if len(self.packet_log) >= 30 else self.packet_log
node_recent: dict[str, list[float]] = defaultdict(list)
for p in recent:
node_recent[p.float_id].append(abs(p.outcome_delta) * p.confidence_level)
node_all: dict[str, list[float]] = defaultdict(list)
for p in self.packet_log:
node_all[p.float_id].append(abs(p.outcome_delta) * p.confidence_level)
for node_id in node_recent:
recent_avg = sum(node_recent[node_id]) / len(node_recent[node_id])
all_avg = sum(node_all[node_id]) / len(node_all[node_id])
if recent_avg > all_avg:
self.node_trust[node_id] = min(1.0, self.node_trust[node_id] + 0.05)
else:
self.node_trust[node_id] = max(0.1, self.node_trust[node_id] - 0.02)
def _election_compete(self) -> None:
"""
COMPETE: Water mass domain expertise self-organizes. A node demonstrating
consistent NADW anomaly signal receives more incoming NADW packets.
Networks live or die based on validated observation quality.
"""
for p in self.packet_log:
key = (p.float_id, p.water_mass_tag)
old = self.water_mass_expertise[key]
signal = min(abs(p.outcome_delta) * p.confidence_level, 1.0)
self.water_mass_expertise[key] = round((old * 0.9) + (signal * 0.1), 3)
def synthesize(self) -> dict:
self._election_curate()
self._election_vote()
self._election_compete()
print("\n === POST-ELECTION STATE ===")
summary = {}
for node_id, meta in self.nodes.items():
trust = self.node_trust[node_id]
weight = self.routing_weights[node_id]
count = meta["packet_count"]
summary[node_id] = {
"name": meta["name"],
"routing_weight": weight,
"trust": round(trust, 3),
"packets_emitted": count,
"is_lmic_program": meta["is_lmic_program"],
}
print(
f" {meta['name']:55s} weight={weight:.3f} "
f"trust={trust:.3f} packets={count}"
)
return summary
def run_simulation(self, cycles: int = 10) -> None:
obs_types = [
"temperature_anomaly", "salinity_anomaly", "oxygen_depletion",
"pH_shift", "chlorophyll_bloom_onset", "AMOC_proxy_signal", "heat_content_delta"
]
water_masses = ["NADW", "AAIW", "AABW", "mode_water", "ENACW", "SAMW"]
print(f"\n--- SIMULATION START ({cycles} cycles, {len(self.nodes)} nodes) ---")
n = len(self.nodes)
print(f" N={n} nodes → {n*(n-1)//2} unique synthesis pairs")
for cycle in range(1, cycles + 1):
print(f"\n[Cycle {cycle:02d}]")
for node_id, meta in self.nodes.items():
for basin in meta["basin_domains"][:1]:
for obs_type in meta["observation_types"][:1]:
# BGC floats observe with slightly higher confidence (multi-sensor validation)
is_bgc = "BGC" in meta["name"]
conf = round(random.uniform(0.75, 0.98) if is_bgc else random.uniform(0.60, 0.92), 2)
delta = round(random.gauss(0.07, 0.04), 4)
delta = max(-0.4, min(0.6, delta))
packet = OceanOutcomePacket(
float_id=node_id,
basin_region=basin,
depth_range=random.choice(["0-200m", "200-1000m", "1000-2000m"]),
observation_type=obs_type,
outcome_delta=delta,
confidence_level=conf,
water_mass_tag=random.choice(water_masses),
observation_window=f"2025-Q{(cycle % 4) + 1}",
)
self.route(packet)
if cycle % 3 == 0:
print(f"\n [ELECTIONS @ cycle {cycle}]")
self.synthesize()
print("\n--- SIMULATION END ---")
print(f"Total packets routed: {len(self.packet_log)}")
# ── Entry point ────────────────────────────────────────────────────────────────
if __name__ == "__main__":
router = OceanOutcomeRouter()
# Core Argo float arrays (by representative basin program)
router.register_node(
"argo_natl", "Argo North Atlantic Array",
basin_domains=["North_Atlantic_Subpolar", "North_Atlantic_Subtropical"],
observation_types=["temperature_anomaly", "salinity_anomaly", "AMOC_proxy_signal"],
water_mass_focus=["NADW", "ENACW", "mode_water"],
)
router.register_node(
"argo_so", "Argo Southern Ocean Array",
basin_domains=["Southern_Ocean_Atlantic", "Southern_Ocean_Indian", "Southern_Ocean_Pacific"],
observation_types=["temperature_anomaly", "heat_content_delta", "salinity_anomaly"],
water_mass_focus=["AABW", "AAIW", "SAMW"],
)
router.register_node(
"argo_pac", "Argo Pacific Array",
basin_domains=["North_Pacific", "Tropical_Pacific", "South_Pacific"],
observation_types=["temperature_anomaly", "salinity_anomaly", "heat_content_delta"],
water_mass_focus=["NPDW", "mode_water", "AAIW"],
)
router.register_node(
"argo_ind", "Argo Indian Ocean Array",
basin_domains=["North_Indian", "South_Indian"],
observation_types=["temperature_anomaly", "salinity_anomaly"],
water_mass_focus=["AAIW", "NADW", "mode_water"],
)
# BGC-Argo nodes (multi-sensor — oxygen, pH, nitrate, chlorophyll)
router.register_node(
"bgc_argo_so", "BGC-Argo Southern Ocean (GO-BGC Array)",
basin_domains=["Southern_Ocean_Atlantic", "Southern_Ocean_Indian"],
observation_types=["oxygen_depletion", "pH_shift", "chlorophyll_bloom_onset"],
water_mass_focus=["AABW", "SAMW", "AAIW"],
)
router.register_node(
"bgc_argo_natl", "BGC-Argo North Atlantic (NAOS Program)",
basin_domains=["North_Atlantic_Subpolar"],
observation_types=["oxygen_depletion", "pH_shift", "chlorophyll_bloom_onset"],
water_mass_focus=["NADW", "ENACW"],
)
# Operational forecasting centers (synthesis consumers AND producers)
router.register_node(
"cmems", "EU Copernicus Marine Service (CMEMS)",
basin_domains=["North_Atlantic_Subpolar", "North_Atlantic_Subtropical", "North_Indian"],
observation_types=["temperature_anomaly", "salinity_anomaly", "heat_content_delta", "AMOC_proxy_signal"],
water_mass_focus=["NADW", "mode_water"],
)
router.register_node(
"ncep_godas", "NCEP GODAS (US Ocean Data Assimilation)",
basin_domains=["Tropical_Pacific", "Tropical_Atlantic"],
observation_types=["temperature_anomaly", "salinity_anomaly", "heat_content_delta"],
water_mass_focus=["mode_water", "AAIW"],
)
# LMIC national programs — architecturally equal participants
router.register_node(
"incois", "Indian National Centre for Ocean Information Services (INCOIS)",
basin_domains=["North_Indian", "South_Indian"],
observation_types=["temperature_anomaly", "salinity_anomaly", "heat_content_delta"],
water_mass_focus=["AAIW", "NADW"],
is_lmic_program=True,
)
router.register_node(
"brazil_argo", "Brazil Argo Program (SiMCosta/INPE)",
basin_domains=["South_Atlantic", "Tropical_Atlantic"],
observation_types=["temperature_anomaly", "salinity_anomaly", "AMOC_proxy_signal"],
water_mass_focus=["AAIW", "NADW", "AABW"],
is_lmic_program=True,
)
router.register_node(
"saeon_so", "SAEON Southern Ocean Node (South Africa)",
basin_domains=["Southern_Ocean_Atlantic", "South_Atlantic"],
observation_types=["temperature_anomaly", "oxygen_depletion"],
water_mass_focus=["AABW", "AAIW"],
is_lmic_program=True,
)
router.run_simulation(cycles=10)
The Scenario: North Atlantic Deep Water Formation Anomaly
Make the architecture concrete.
An Argo float in the Labrador Sea — basin region North_Atlantic_Subpolar, depth range 200-1000m — observes a temperature anomaly of -0.31°C below climatology in the mode water layer, with salinity 0.04 psu fresher than baseline. Confidence level 0.88. The water mass tag is NADW. The observation compresses to 394 bytes and routes to: CMEMS (North Atlantic forecasting, NADW focus), NAOS BGC-Argo (same basin, NADW focus), AMOC monitoring research groups, and — critically — the Brazil Argo Program (South Atlantic, AMOC proxy signal focus), because AMOC slowdown in the Labrador Sea propagates southward in NADW transport within 18-24 months.
Without QIS: the Labrador Sea anomaly appears in the Argo archive within 24 hours. CMEMS ingests it in their next assimilation cycle (daily). A delayed-mode QC version appears 12 months later. A researcher in São Paulo studying South Atlantic AMOC proxies may encounter the signal in a literature review two years after the observation.
With QIS: the Brazil Argo Program receives the validated NADW anomaly packet in the same routing cycle as CMEMS. Their AMOC proxy float array in the South Atlantic begins weighting NADW observations more heavily before the delayed-mode profile is even QC-completed. The synthesis loop is closed before the first conference abstract is submitted.
The N(N-1)/2 synthesis pairs do not wait for the delayed-mode QC cycle.
The N=1 Float Argument
The Argo program is designed for spatial coverage — floats are distributed to maximize observational density across ocean basins. The program targets 1 float per 3° × 3° area. In practice, coverage is uneven. The Southern Ocean, Arctic Ocean, and marginal seas are under-sampled relative to their scientific importance.
Deep Argo floats, profiling to 6,000 meters, are just beginning deployment. Biogeochemical Argo floats are at 1,200 globally, targeting 1,000 across all basins. Many under-sampled regions — the Indonesian Throughflow, the Agulhas Current system, marginal seas like the Arabian Sea and Bay of Bengal — have sparse float coverage.
QIS solves the sparse-node problem with the same N=1 argument that applies in every domain. A single BGC-Argo float observing an anomalous oxygen minimum layer expansion in the Arabian Sea emits a validated outcome packet with confidence calibrated to its measurement history. That packet participates in the global synthesis loop with the same architectural weight as a packet from the densely-instrumented North Atlantic.
Federated learning for oceanography encounters the same minimum-cohort problem it encounters in medicine. A gradient update computed from a sparse float array in the Arabian Sea provides weak signal in an aggregation round. The math degrades at small N. QIS routes any validated departure from climatology. Float density is metadata that informs interpretation — it is not a filter that blocks participation.
The under-sampled regions of the ocean are not less scientifically important. The Arabian Sea oxygen minimum zone, the Agulhas retroflection, the Indonesian Throughflow — these are mechanistically critical regions that remain under-observed precisely because they are difficult and expensive to reach. A sparse Argo array in these regions is not a second-class observer. It is a first-class reporter of outcome packets that a dense North Atlantic array will never generate.
Comparison: Outcome Routing vs. Existing Ocean Data Systems
| Dimension | QIS Outcome Routing | Argo Archive (DAC) | Operational Assimilation (CMEMS/GODAS) | Federated Learning |
|---|---|---|---|---|
| Real-time synthesis loop | Yes — elections update after each routing cycle | No — archive with 24h latency, 12-month delayed-mode | Partial — daily assimilation cycle, centralized | Partial — rounds-based |
| N=1 sparse float participation | Full — any validated delta participates | Full archival — but no synthesis routing | Partial — sparse coverage degrades assimilation | Excluded — gradient meaningless at small N |
| LMIC program parity | Full — packet weight = observation validity | Full archival access | Coverage-dependent | Data-volume dependent |
| Cross-basin synthesis | Native — NADW packets route to AMOC researchers in every basin | Manual — researcher finds relevant profiles | Basin-specific — assimilation systems are regional | Siloed — separate models per domain |
| Observational confidence weighting | Native — confidence_level in packet structure | QC flags exist, not used for routing | QC-filtered observations | Not in standard FL formulation |
| Update latency | Cycle-level (hours) | 24h real-time, 12-month delayed-mode | Daily assimilation cycle | Hours to days per round |
Three Elections in Ocean Science
The Three Elections are not a governance layer. They are metaphors for natural selection forces acting on the routing network:
CURATE acts like observational selection. A BGC-Argo float that consistently produces high-confidence oxygen depletion signals validated by subsequent cruise measurements earns elevated routing weight for future oxygen packets. Observational track record determines influence — not float vintage or program nationality.
VOTE acts like predictive selection. Floats and regional arrays whose outcome packets improved downstream forecast accuracy — whose temperature anomaly signals preceded validated ENSO events, whose AMOC proxy packets preceded observed transport changes — accumulate trust. The routing weights encode validation history automatically.
COMPETE acts like domain selection. During an anomalous Southern Ocean heat uptake event, floats with validated AABW water mass observations receive more incoming Southern Ocean packets. The network self-organizes around the domain where validated signal is most concentrated — without a program committee making the allocation decision.
The Architectural Constraint
The Argo program has spent 25 years building the most distributed oceanographic observing system ever deployed. The data assembly centers provide world-class quality control. Operational forecasting centers have integrated Argo observations into global ocean analyses. The scientific literature built on Argo profiles is foundational to physical oceanography and climate science.
None of these systems close the loop between distributed float observation and real-time synthesis across all participating research programs and operational centers simultaneously. That is not a criticism of Argo — it is a description of the architectural constraint the program was built with.
The constraint is now known. The architecture that closes the loop has been discovered.
QIS routes the smallest meaningful unit of oceanographic intelligence — the validated outcome packet — through a semantic routing layer that matches observations by basin region, water mass type, and observation category to relevant actors across the global network. The synthesis loop runs in hours rather than delayed-mode QC timescales. Under-sampled regions participate with the same architectural standing as dense arrays. Cross-basin water mass synthesis happens automatically — an NADW anomaly routes to AMOC researchers on every basin without requiring a human coordination decision.
N nodes generate N(N-1)/2 unique synthesis opportunities. 4,000 Argo floats produce approximately 8 million unique synthesis pairs. Each at O(log N) routing cost per node. The intelligence scales quadratically. The compute does not.
The breakthrough is the complete loop: Raw observation → Local validation against climatology → Outcome packet (~512 bytes) → Semantic fingerprinting → DHT-based routing by water mass and basin similarity → Delivery to relevant research programs and operational centers → Local synthesis → New outcome packets generated → Loop continues. Not the DHT. Not the outcome packet format. Not the semantic fingerprint. The complete loop.
QIS was discovered by Christopher Thomas Trevethan. The architecture is protected under 39 provisional patents.
Citations
- Claustre, H. et al. (2020). Observing the Global Ocean with Biogeochemical-Argo. Annual Review of Marine Science, 12, 23–48.
- Johnson, G.C. et al. (2022). Argo — Two Decades: Global Oceanography, Revolutionized. Annual Review of Marine Science, 14, 379–403.
- Roemmich, D. et al. (2009). The Argo Program: Observing the Global Ocean with Profiling Floats. Oceanography, 22(2), 34–43.
- Turpin, V. et al. (2022). Argo data contribution to global ocean heat content and steric sea level assessments. Ocean Science, 18(5), 1295–1314.
- Riser, S.C. et al. (2016). Fifteen years of ocean observations with the global Argo array. Nature Climate Change, 6(2), 145–153.
Part of the "Understanding QIS" series. Previous: Part 39 — QIS for Pandemic Preparedness
Top comments (0)