Coherence Energy Labs

One Mind - deterministic autonomy

Command a swarm that can’t be herded.

A hundred drones flying as one, with no radio between them. No leader, no chatter: each drone works out the whole formation by itself, and because every drone runs the exact same integer math, they all land on the exact same plan - agreeing on who flies where, down to the last bit. That is what makes this swarm impossible to jam apart, spoof, or herd. Everything below is the real decision engine running live in your browser, not a video. Try to break it: the buttons let you fracture it, spoof half of it, shoot it down, and cut its comms.

What this is: the actual swarm.organism coordination law (exact-integer angular consensus + a fixed-point controller + zero-tolerance recompute detection), ported to BigInt so the browser reproduces the same bit-identical decisions. What it is not: a physics/aerodynamics simulator - the moat is the decision (who-goes-where, provably identical and tamper-evident), not the flight dynamics.

drone (agreeing) the target they surround spoofer, caught lying the slot it was silently assigned
Watch them fan out and lock onto the ring: every drone chose its own spot with no radio, and they never collide because they all computed the same assignment.
N 150
Byzantine 0%
Do they agree?
-
two drones, computed alone, same plan?
Different plans in the fleet
1
1 = everyone agrees
Liars caught
0 / 0
0 false alarms · even a 2 cm lie is caught
How formed up
0.00
0 = every drone exactly on its spot
Aim drift
0.0 m
how far the target has slipped from centre
Drones still flying
120
same law for 2 or 2,000

SealSign the decision - then re-run it, or try to forge it

A mission certificate binds the swarm’s exact inputs (roster seed, formation, adversary set, tick) to the SHA-256 of the final decided state, and signs that digest with Ed25519 in your browser. Verification re-executes the whole deterministic mission from the sealed inputs, recomputes the digest, and checks it matches the one that was signed - so a valid certificate is a re-runnable proof, not a stamp you trust. Change one drone by one fixed-point unit and it is caught.

No certificate yet. Fly a mission, then seal it.

ProofSelf-test - run the falsifiable bets in your browser

The same claims the engine ships with, checked live: integer consensus holds where float fractures; every spoofer up to 49% is caught with zero false positives (even a 2 cm lie); two independent bodies produce a byte-identical plan; the certificate verifies and any tamper is rejected.

Honest scope. The decision path is 0-ULP integer and bit-identical across bodies and re-runs (that is what the self-test proves). The Byzantine result is structural, not a contest: each drone’s slot is derived from the commanded centre, never from a peer’s reported position, so a position spoof has no channel to drag an honest drone - and because the honest next move is an exact integer function, any lie is caught by recompute with zero tolerance and zero false positives. Consensus survives to 49% compromised; a true ≥50% majority can define its own reality (stated plainly). This page runs the real swarm.organism / swarm_max logic ported to BigInt; the production stack (one_mind/flight) carries the same law to 200,000 drones in one bit-identical decision, to real MAVLink, and to signed mission certificates.