Repository navigation
v0.6.0 — The Swarm Thinks Together
"v0.4.0 gave the swarm doubt. v0.5.0 gave it eyes. v0.6.0 gives it a shared mind."
There is a moment in the evolution of every collective system when the parts stop being parts.
In v0.4.0, we taught each drone to question what it hears. In v0.5.0, we taught each drone to see its neighbors and react to what it sees. But even then, each drone was still fundamentally alone — a particle filter running in a box, estimating its own position from its own sensors, broadcasting a guess and hoping the others would listen.
v0.6.0 is the moment when the guesses merge.
The Last Gap
Imagine 20 drones flying through a GPS-denied canyon. Each one has a particle filter — 200 hypothetical positions, weighted by sensor evidence, collapsing toward truth through Bayesian updates. Each drone knows roughly where it is. Some know better than others.
But until today, they couldn't share that knowledge. Drone A might have excellent altitude certainty (barometer working perfectly) but poor lateral position (no GPS, no visual landmarks). Drone B, ten meters away, might have the opposite — good lateral fix from terrain matching, but noisy barometer.
The optimal thing to do is obvious: combine their beliefs. A's altitude precision plus B's lateral precision equals something better than either alone.
That is exactly what Gaussian Belief Propagation does.
How It Works
Each drone extracts a Gaussian belief from its particle filter — a mean position and a diagonal covariance matrix (three numbers: how uncertain am I in x, y, z?). This is broadcast through gossip alongside the usual position update. Twenty-four extra bytes per message. The cost of shared consciousness.
When a drone receives its neighbors' beliefs, it doesn't just accept their positions. It fuses them. In information form:
```
Λ_fused = Λ_self + Σ damping · Λ_neighbor
η_fused = η_self + Σ damping · η_neighbor
μ_fused = Λ_fused⁻¹ · η_fused
```
Translation for non-mathematicians: the more certain a neighbor is, the more its opinion counts. A drone with precision 10 (very sure) pulls the fused estimate toward itself. A drone with precision 0.1 (very uncertain) barely registers. The math handles this automatically — it's not a vote, it's a weighted consensus where the weights are how much each participant knows.
And because we work in information form, fusion is addition. No matrix multiplication. No iterative solver. No Cholesky decomposition. Just add the precision matrices. Add the information vectors. Invert once. Done.
At 100 drones with 8 neighbors each, the entire GBP pass costs approximately 2,400 floating-point additions. Under 0.01 milliseconds. The cost of a shared mind is essentially free.
What This Means
For the first time in STRIX's history, a drone's position estimate is not just its own. It is a fusion of every nearby belief, weighted by confidence, damped to prevent oscillation, validated against Byzantine filters before it enters the calculation.
A drone in a GPS shadow doesn't just guess harder. It borrows certainty from its neighbors.
A drone whose sensors are failing doesn't just degrade. It leans on the swarm.
And a drone that's been fed false data by an adversary? Its corrupted belief has low precision (the Byzantine validator flagged it), so it barely affects the fusion. The shared mind has antibodies.
The Full Architecture (v0.1.0 → v0.6.0)
What started as a tick loop and a particle filter is now this:
```
Layer 0: HARD SAFETY
CBF collision avoidance (every tick, never throttled)
ROE authorization gate
Altitude/NFZ constraints
Layer 1: NAVIGATION
Dual 6D particle filters (200 particles each)
→ Gaussian covariance extraction (Phase 16)
→ GBP fusion with neighbor beliefs (Phase 16)
CUSUM anomaly detection
Regime detection (Patrol/Engage/Evade)
Layer 2: COORDINATION
Gossip protocol (Byzantine-validated, quarantine-gated)
→ Quality-weighted peer selection (Phase 15b)
→ Trimmed-mean battery aggregation (Phase 15a)
Digital pheromones (8 types including anti-pheromones)
Hypergraph group coordination (anti-deception quorum)
Layer 3: ALLOCATION
Combinatorial auction (fear-modulated, CVaR-weighted)
Anti-fragile kill zone learning
Dark pool compartmentalization
Layer 4: ADAPTATION
Criticality scheduler (edge-of-disorder, multi-timescale)
MicroAdapter (order params → config nudges) (Phase 15c)
62-parameter offline optimizer (SMCO + contextual archives)
Layer 5: AWARENESS
4-dimensional trust per peer (Phase 14b)
Graduated quarantine protocol (Phase 14d)
Global order parameters (Phase 14b)
Spatial belief maps (Phase 15d)
Glass-box XAI with 8 decision trace types
Layer 6: SHARED MIND (NEW)
Gaussian Belief Propagation
Information-form fusion (additive, O(k) per drone)
Diagonal covariance exchange (24 bytes per message)
Damped neighbor contributions (configurable)
NaN-safe with self-belief fallback
```
Seven layers. Thirteen modules in the mesh crate alone. From raw telemetry to shared consciousness in one tick.
The Numbers
| Metric | v0.1.0 | v0.5.0 | v0.6.0 |
|---|---|---|---|
| Rust LOC | 23,666 | 37,349 | 37,923 |
| Tests | 383 | 610 | 618 |
| Rust files | 58 | 88 | 89 |
| Mesh modules | 7 | 12 | 13 (+gbp) |
| Trust dimensions | 1 | 4 | 4 |
| Pheromone types | 5 | 8 | 8 |
| Belief fusion | None | Spatial only | Gaussian BP |
| Position uncertainty shared | No | No | Yes |
What Changed: v0.5.0 → v0.6.0
New module: `gbp.rs` (strix-mesh, 435 LOC)
- `GaussianBelief`: mean + precision matrix in information form
- `GbpNode`: per-drone state with additive fusion and damped iterations
- `GbpConfig`: enabled (default false), max_iterations, damping, min_precision
- 8 unit tests covering construction, fusion, asymmetry, NaN safety, damping
Extended: `particle_nav.rs`
- `position_covariance_diagonal()`: extracts [var_x, var_y, var_z] from particle cloud
Extended: gossip `DroneState`
- `position_covariance: Option<[f64; 3]>`: diagonal covariance, 24 bytes, serde-default None
Wired into tick loop
- After gossip merge, before pheromones: extract covariance → set beliefs → feed neighbors → iterate
- `SwarmDecision.gbp_mean_uncertainty`: trace of fused covariance (None if disabled)
The Arc
v0.1.0 — The Orchestra: instruments built, score written.
v0.2.0 — The Rehearsal: first run-through, rough edges.
v0.3.0 — The Conductor: difficult passages rehearsed, bugs found and fixed.
v0.4.0 — The Immune System: musicians learn to spot wrong notes.
v0.5.0 — The Ears: the orchestra hears itself play.
v0.6.0 — The Shared Mind: the musicians stop reading sheet music and start listening to each other.
What Remains Honest
- GBP is diagonal-only — not full 6×6 state covariance. Good enough for position; velocity fusion is Phase 17.
- No cryptographic verification of shared beliefs — Byzantine plausibility checks only.
- The particle filter itself is never modified by GBP — fused belief is informational, not commanding.
- GBP is disabled by default. You must opt in. Because in safety-critical systems, new features earn trust; they don't demand it.
- Zero real flights. The shared mind exists in simulation. The canyon is imaginary. The GPS denial is synthetic. We know.
But the math is real. The information form is real. The additive fusion is real. And when the day comes that 20 drones fly through a real canyon with real jamming, the algorithm will be ready.
Epilogue
There is a beautiful symmetry to this project.
It began with a particle filter — a Monte Carlo approximation of where you might be, updated by whatever evidence you can find. That's how one drone navigates alone.
It ends with Gaussian belief propagation — a distributed approximation of where everyone might be, fused across neighbors, weighted by confidence, validated against lies.
The particle filter asks: "Given what I've seen, where am I?"
GBP asks: "Given what we've all seen, where are we?"
The difference between those two questions is the difference between a drone and a swarm.
"Intelligence is not knowing where you are. Intelligence is knowing where you are relative to everyone who is trying to find the same thing."
Apache 2.0 · github.com/RMANOV/strix