The Plasma Problem

How to hold a star together with mathematics, micropayments and a ledger.

A tokamak is a magnetic bottle for a star. Inside the torus, hydrogen plasma is heated past 150 million degrees — ten times hotter than the core of the Sun — and held away from the walls by magnetic fields, because no material on Earth can touch it and survive. The physics of that held plasma is called magnetohydrodynamics: the fluid dynamics of a gas so hot it has become electrically charged, so that every swirl in the fluid bends the magnetic field, and every bend in the field pushes back on the fluid. It is one of the most beautiful and least forgiving feedback systems in nature. And it does not want to stay in the bottle.

Plasma instabilities have names that sound like weather — kink modes, tearing modes, edge-localised modes — and timescales that sound like electronics. A disruption can go from a wobble to a wall-strike in milliseconds. The control loops that keep a modern tokamak alive read the sensors and retune the magnetic coils thousands of times per second. This is the plasma problem: sustained fusion is not only a heating problem or a materials problem. It is a control problem, and the controller has microseconds to be right.

No network can close a microsecond loop

Start with the thing that kills the naive version of this idea, because everything interesting follows from it. You cannot put a blockchain — or any distributed network — inside a tokamak's control loop. Light in fibre crosses a continent slower than a tearing mode grows. Consensus takes longer still. Any design that says "the network reacts to the plasma" has already failed; that is a physics limit, not an engineering one.

So don't react. Arrive with the answer already computed.

The trick is not computing fast. It is being finished before the question is asked.

Precompute the star

A control policy is, in the end, a map: for every plasma state the sensors can report, the coil adjustments — which magnets to drive harder, which to ease, effectively which to turn up and which to turn off — that steer the plasma back toward stability. If that map already exists, the machine at the reactor doesn't compute anything in the hot loop. It looks the answer up and acts, in microseconds, because the thinking was done days ago, elsewhere, by something enormous.

This is not speculation about whether learned control can fly a plasma — that part has been demonstrated: in 2022, DeepMind and EPFL trained a reinforcement-learning policy on massive offline simulation and had it shape and hold real plasma in the TCV tokamak, executing locally at ten kilohertz. The offline brain, the fast local reflex. The shape works.

What limits it is the size of the offline brain. The space of plasma flows is astronomical, and every regime, every reactor geometry, every fault scenario multiplies it. One lab's cluster explores a sliver. The question worth asking is: what if the offline computation weren't one lab's cluster, but everyone's — an open market where anyone with compute can explore a region of plasma-state space, and get paid exactly for the stability their policy buys?

Distributed paid computation

"Distributed computation" is an old dream that keeps dying of the same two diseases: nobody gets paid, and nobody can be trusted. SETI@home ran on goodwill; goodwill doesn't scale to industrial workloads. And the moment you pay strangers for computation, you invite strangers who fake it. Both diseases have the same cure, and it is the unglamorous machinery this platform runs on every day.

Payment channels solve the payroll. A contributor exploring plasma states doesn't invoice monthly; the channel meters value continuously, the way our media channels already meter video by the five-second segment on mainnet. Compute a batch of trajectories, submit the result, the channel state advances a few more satoshis your way. Thousands of contributors, thousands of micropayment streams, no trust extended in either direction beyond the current channel state.

Covenants solve the trust. A covenant is a transaction whose script constrains the transaction that spends it — the ledger itself enforcing what happens next, with no referee. We have proven this on mainnet: a counter covenant whose state can only advance according to its own rules, enforced by consensus, not by a server. The same construction runs a compute tournament nobody can cheat: the bounty sits in a covenant that will only release to a submission whose policy verifiably outperforms the incumbent against published simulation checkpoints. Verification is the crucial asymmetry — checking a policy against a benchmark costs a fraction of discovering it, the same asymmetry that makes proof-of-work possible at all.

And chained covenants solve the computation itself. A single Bitcoin script is deliberately bounded. But a covenant that forces its successor's shape turns the ledger into a tape: each transaction executes one step and constrains the next, and the loop unrolls across transactions without limit. That is Turing completeness in the way that actually matters — unbounded computation whose every step is public, ordered, and enforced. The interesting workload isn't running the fluid solver in script; it's running the referee in script: the state machine that tracks which regions of plasma-state space are claimed, explored, verified and paid, across millions of contributions, with no coordinator to bribe or subpoena.

Three layers, one honest split

Layer one is the swarm: open, paid precomputation. Contributors pull regions of plasma-state space, run flows forward, optimise the coil response — the ahead-of-time calculation of every path the plasma can take and the actuation that answers each one. Channels pay in proportion to verified quality.

Layer two is the registry: versioned, signed, content-addressed policies, each declaring the reactor, the operating regime and the exact input domain it is valid for. The covenant tournament decides what gets in.

Layer three is the reflex: a local executor beside the machine, running the current policy at loop speed. Sensor state in, coil setpoints out, microseconds flat. If the plasma wanders somewhere no policy has mapped, the executor does the only safe thing: falls back to a conservative hold. It never extrapolates, because layer one's whole job is to make sure it never has to.

Prediction as a market

Seen from a distance, the design does something odd to the phrase "real time." The system predicts the plasma in real time precisely because none of the prediction happens in real time — it happened in advance, everywhere, paid for by the microsecond of stability it delivers. The scarce resource in fusion control stops being any single lab's supercomputer and becomes the total compute the market is willing to sell — which is to say, effectively unbounded.

Fusion is the flagship case because its numbers are brutal, but the pattern is general: any system too fast for a network to steer, but slow enough for a market to pre-think — grid inrush, hypersonic aerodynamics, protein dynamics. The ledger's role is the same in each: coordination without a coordinator, payroll without an employer, and a referee nobody appointed and nobody can fire.

The concept page for the build lives at Project Fusion.