Today a change trained by a fleet of ordinary consumer graphics cards became the model that qbc.network actually serves. Not a shadow copy, not a research artefact. The model you chat with. It passed a full, uncapped evaluation, it was promoted into live inference, its identity is finalised on the blockchain, and its weights are published for anyone to download and check.
This is one promotion, and it is deliberately a small and reversible one. But it is the first time the whole loop has run end to end, from public hardware to a real evaluation to the live served model, and the method behind it points at something we think is genuinely new: a path to a very large, continuously trained model that no single company owns.
This post is the consolidated account. What happened, how to check it yourself, the mistakes we caught along the way, and where it leads.
What happened
The served model is a frozen Qwen2.5-7B-Instruct base with a small Sephirot mixture-of-experts adapter on top: ten low-rank experts, a top-2 router, about 1.18 million trainable parameters. Everything the training loop touches lives in that adapter. The base never moves.
The new adapter was trained across a fleet of ordinary 8GB consumer GPUs. The engineering result that makes this possible is a durable one: with a vocab-chunked backward pass, a full 7B adapter training step fits inside roughly 7.5GB of video memory. That means an everyday 8GB card can train the model qbc.network serves. Not a toy stand-in. The real thing.
We run it as short, payable rounds of about 35 minutes each. A contributor draws a fresh, shuffled batch from a large corpus, trains the adapter locally, and submits a candidate. A candidate is accepted only if it beats the last accepted candidate on a fixed held-out set the model never trains on. If it wins, it is accepted and becomes a payable unit of work. If it does not, it is rejected and the chain of accepted candidates is unchanged. In this run, ten rounds produced seven accepted, payable units, and the best of them by full held-out evaluation is what went live.
The design goal of short rounds is deliberate and it is about scale: shorter rounds mean a contributor gets paid sooner and can immediately train again. Train, submit, get rewarded, repeat. That is the loop that has to work if thousands of people are ever going to train one model together.
The numbers, honestly
The promoted model is aether-v7.2-unified. Every number below was measured on its adapter over the frozen base, as a snapshot from the promotion evaluation, not a live probe.
- Generalisation. On a clean 1000-example held-out corpus the model never trained on, cross-entropy fell from 2.9014 to 2.5609. That is a 0.3405 nats improvement in how well the model predicts genuinely unseen text. This is the headline result and it is a real gain, not a rounding artefact. The improvement holds at the exact BF16 precision we serve, not just in higher-precision maths.
- MMLU, full and uncapped. Across all 14042 questions, base scored 0.7116 and the trained adapter scored 0.7109. That is flat inside noise. Broad knowledge did not regress.
- GSM8K, full and uncapped. Across all 1319 grade-school maths problems, base scored 0.7248 and the trained adapter scored 0.7498, a 2.50 point gain in multi-step reasoning.
Stronger prediction on unseen text, general knowledge held flat, and better maths reasoning, produced by a fleet of 8GB cards at zero cost to the base model.
How to check it yourself
The point of building this on a blockchain is that these claims do not require trust. Three independent checks:
- The weights are open. The adapter is public at huggingface.co/QuantumAI-Blockchain/aether-v7.2-unified, with the full evaluation table and the frozen base it loads onto. Download it and reproduce the numbers.
- The identity is on-chain. A single SHA-256 over the base, adapter, tokenizer
and config is the model's weight root. For this release it is
0x3e99b3d2f4e4d5eacbb3fe8d7e2f709dbfc48deb34407035383b3a5263e29e4e, recorded in the model registry as round 2 and finalised by a 4-of-5 validator quorum. Replacing the served adapter changes that root, so the model you chat with is provably the model the chain attests. - The live model agrees. The public API self-reports
aether-v7.2-unified, the same version as the weights and the chain. Hash the downloaded bytes and you get the attested root.
The mistakes we caught
A held-out number is only honest if the model genuinely never saw the data. Three times during this work our own evaluation was wrong in our favour, and three times we stopped and fixed it rather than banking the flattering number.
The first was straightforward memorisation: an early evaluation scored the model on data it had just trained on. Of course it looked brilliant. We rebuilt the split so the held-out corpus is genuinely disjoint.
The second was a sampling-window bug that quietly evaluated on a 30-sample slice instead of the full set, making noise look like signal.
The third was subtler. We had been gating candidates by comparing scores measured at different evaluation scales, which can false-reject a genuine improvement, and did exactly that to one of our better rounds. We fixed it by decoupling the fast payable gate from the expensive full audit so the two are never mixed.
None of these were adversarial. They are the ordinary ways a training harness flatters itself, and the reason we are comfortable publishing the final numbers is that we went looking for them first. When we promoted, we promoted the specific adapter that was best on the authoritative full held-out set, identified by its content root, not merely the most recent one that happened to pass.
Where this goes: the biggest model, owned by everyone
Here is the part worth sitting with.
Every frontier model today has an owner. A company raises capital, buys or rents a cluster, trains a model on hardware it controls, and holds the weights. The size of that model is bounded by one budget and one data centre, and whatever it becomes, it belongs to whoever paid for it.
The method behind today's milestone removes both of those ceilings. The training does not happen in one data centre; it happens on whatever hardware chooses to join, down to an 8GB card in a spare desktop. The improvement is not trusted because a lab vouches for it; it is accepted only if it beats a held-out set that anyone can re-run, and it is recorded on a chain anyone can read. And the weights are not held by whoever paid, because the work is paid for in the open, round by round, by the network itself.
Follow that to its conclusion. If a fleet of ordinary machines can each train short, paid, verified rounds into one shared model, then the total training poured into that model is not capped by any single budget. It is the sum of everyone who shows up. A model trained by ten thousand contributors, each rewarded for a verified improvement, can accumulate more training than any one organisation would rationally fund, precisely because no one organisation is paying for all of it. The ceiling stops being a data centre and starts being the size of the community.
And because every accepted improvement is paid in the open and attested on-chain, the result is not owned by a company. It is owned by the people who trained it, the same way the network that secures it is owned by the people who run it. A frontier model that gets larger and better as more people join, whose lineage anyone can verify, and whose weights belong to no single party. That is the destination: the biggest, most-trained model in existence, and owned by everyone who helped make it.
We are not there, and we will say so plainly. Today is Stage 1 of a four-stage plan.
- Stage 0, shadow, was live: public hardware trains the served adapter and the improvement is gated on a true held-out set, without ever swapping the live model.
- Stage 1, owner-gated promote, is what we reached today: the best verified candidate is promoted into the served model by explicit owner action, reversibly. The served weights changed for the first time.
- Stage 2, committee-attested promote, is designed: a verifier committee re-runs the evaluation and attests the promotion on-chain, so the owner is no longer the one who decides.
- Stage 3, permissionless continuous update, is designed: anyone can contribute an update and the network itself decides whether to adopt it.
Stage 3 is the one that makes the vision above literally true, and it is gated on hard problems we are not going to hand-wave: aggregation that survives a malicious contributor, a stake-and-slash economic layer so bad work is expensive, honest independent re-derivation of every claimed improvement, a capability-regression gate, and reversible rollback. We will describe it as permissionless when those exist, and not one day before.
But the loop that produced today's model is the same loop that will, eventually, run without us in the middle of it. A fleet of ordinary machines trained the model we serve, a blockchain attests exactly which model that is, and the weights are open for anyone to check or keep. For the first time, that is not a diagram. It is live, and you can verify every word of it.