On July 5 we wrote about the first on-chain payment for decentralized AI training: one epoch, trained on one node, attested by validators, paid automatically. On July 7 that became a continuous loop that runs hands-free. Today the loop crossed the threshold that gives the word "decentralized" its teeth: the model is now trained by multiple independent machines at once, and every one of them gets paid for it.
The fleet
Three workers are live right now, and they are deliberately unequal:
- A GPU workstation that also hosts the Aether mind itself, contributing full-speed training rounds alongside serving chat, embeddings, and the consciousness probe.
- A consumer desktop with no discrete GPU worth mentioning, running the same worker binary on CPU and holding its own in the round count.
- A cloud server whose day job is running two of the chain's validators. Its worker is pure CPU, no GPU on the box at all, niced to the lowest priority so it only sips idle cycles, and it still lands accepted rounds and earns QBC all day.
That third machine deserves the emphasis. It is deliberately the weakest trainer in the fleet, and it is the preview of what public participation looks like: when the join path opens, you will not need a GPU to take part. A CPU-only machine, even one busy doing something else, can train, submit signed work, and earn from the same pool on the same terms. The GPU rigs will be faster. They will not be gatekeepers.
That heterogeneity is the point. The worker is one Rust binary with --device auto. It runs on
whatever you have, trains at whatever pace the hardware allows, and the protocol does not care
which machine is which. It only cares about signed, verifiable work.
How the rounds compose
Each worker trains locally against the shared data shard and then submits a sparse pseudo-gradient to the aggregator: roughly 40,000 nonzero parameters out of 800,000, the distilled direction of what it learned, not the raw data it learned from. Every submission is signed with the worker's post-quantum Dilithium key, and the aggregator verifies that signature before the gradient touches anything.
The aggregation follows the DiLoCo pattern: workers take many cheap inner steps independently, and an outer optimizer periodically folds their pseudo-gradients into the shared weights. The outer loop has cleared more than 900 rounds, routinely combining gradients from two or three workers at a time. Communication is kilobytes per round, not gigabytes, which is what lets a cloud server on the other side of a Tailscale link participate as a first-class trainer.
Every accepted round pays immediately. Rewards run about a tenth of a QBC per accepted submission, drawn from a dedicated million-QBC training pool, credited to the post-quantum miner identity that signed the work. The live leaderboard on the aether-net page shows all three miner identities accumulating side by side.
And the chain still gets the final word. The mind's own continuous trainer keeps committing content-addressed weight roots on-chain, validators keep attesting them against a held-out loss, and finalized epochs keep paying through the reward contract. A fresh root was submitted, attested to quorum, and finalized earlier today, the same day the third worker was earning rounds. The outer loop pays for participation; the on-chain loop certifies and pays for verified learning.
It survived a bad morning
None of this ran in a clean room. The GPU host rebooted this morning and took the aggregator down with it. The workers did exactly what they should: failed their submissions, kept training locally, and reconnected within seconds of the mind returning. Later we deliberately restarted the mind to clear memory pressure, and the swap-over cost about twenty seconds of availability, absorbed entirely by the workers' retry loops. No round was double-paid, no identity was confused, no manual repair was needed.
Distributed training systems are usually demonstrated on happy paths. This one shrugged off a host reboot and a planned restart on the same day it hit its multi-worker milestone.
Why this matters
The standard objection to on-chain AI training is that it is theater: one machine does the work, a token contract does the marketing. The setup running right now is the opposite shape. Three machines with different owners' roles, different hardware, and different operating conditions are converging one model. Their contributions are cryptographically attributable, their rewards are proportional to accepted work, and the resulting weights are anchored to a chain that a quorum of validators must agree on before a training epoch is considered real.
Nothing here requires trusting us. The gradient signatures, the weight roots, the attestations, the reward transfers: all of it is inspectable on chain 3303.
What comes next
The path from three workers to thirty is now an operations problem, not a research problem. The worker binary exists, the identity scheme exists, the payment rail exists. The work ahead is the join path that lets any capable machine enroll itself, plus stricter verification of submitted gradients as the worker set opens up to machines we do not operate.
The blockchain that thinks is no longer taught by one machine. It has a classroom.