SUBNET 81 · FINNEY
The RL layer of Bittensor.
Reliquary runs reinforcement-learning training on a decentralized network. Rollout generation — the inference that consumes most of the compute in a GRPO run — is distributed across independent operators instead of a fleet the protocol owns or rents. Nobody vets those machines. Nothing they submit counts until the protocol recomputes it and confirms it came from the current model. The objective is to lower the cost of an RL run.
How the subnet works.
Operators generate rollout groups on hardware they own and submit them inside a collection window. The sealing validator ranks submitted groups and recomputes them top-down until it has enough winners; what reproduces becomes training input.
scroll the figure →
| stage | value | meaning |
|---|---|---|
| rollouts | 8 rollouts per group | Operators run a group of rollouts on hardware they own, on prompts they predict the model can still learn from, then submit the group to the sealing validator. |
| GRAIL recompute | one collection window, up to 30 minutes | The sealing validator ranks submitted groups, then recomputes them top-down against the GRAIL sketch the operator committed to, until it has enough winners. Groups that do not reproduce, or are never reached, are discarded and count for nothing. |
| selected | gated on a healthy balanced batch | A group must already rank highly enough to be proved; reproducing the GRAIL sketch is what confirms it as selected, eligible to be used as training input in a later batch. |
| GRPO step | one optimizer step on the retained groups | A healthy balanced batch assembled from selected groups runs one GRPO optimizer step. |
| checkpoint published | every 4 successful balanced optimizer steps · Qwen3.5-2B | A Qwen3.5-2B checkpoint is published on a fixed cadence of successful balanced optimizer steps, earlier on behavior-policy drift, with the provenance of the steps behind it. |
Cost of an RL run.
Most prompts teach a model nothing
A prompt carries gradient signal only when the model's success rate on it is neither 0 nor 1. Rollouts that all fail and rollouts that all succeed leave nothing to learn from. Subnet 81 admits a group only when 2 to 6 of its 8 rollouts succeed, and the fraction of prompts inside that band shrinks as the policy improves.
A centralized trainer generates the group, measures the variance, and discards what has none. It has paid for those rollouts before learning they were useless. Reliquary moves the decision ahead of generation: operators commit their own compute to prompts they predict are inside the band, and the rollouts behind the groups that miss are paid for by the operator rather than by the run.
pass@1 · held-out math
| run | pass@1 |
|---|---|
| vanilla GRPO | 0.47 |
| Reliquary | 0.61 |
Measured. One controlled comparison: Qwen3-4B-Instruct, 300 steps, held-out math. Vanilla GRPO 0.47 pass@1, Reliquary selection 0.61. Single run, not replicated.
The protocol pays for the outcome, not the method
An operator is paid when a group it submitted is verified and selected. It is not told how to get there. Which prompts to bet on is one decision; how fast to generate the rollouts, what hardware to run, how to batch the work are others. All of it is the operator's problem, and all of it is where one operator wins a slot another loses. The protocol scores the outcome and breaks ties on throughput; how an operator gets there is not specified.
The dominant cost of a GRPO run is the number of rollouts you generate multiplied by what you pay to generate each one. Everything an operator can optimize lands on one of those two terms.
The second term is what an operator pays per rollout. Generation runs on operator-owned hardware, not on capacity the protocol rents. Operators choose their own cards, power, and location, and compete on cost.
GRAIL sketch digests are bit-exact across four hosts spanning two GPU generations (3× RTX PRO 6000 Blackwell, 1× H100), 90 samples, zero drift. Determinism is verified empirically, not proven analytically: each new hardware class needs its own 90-sample audit, and the audit harness is public.
Competition on those axes is the mechanism. Lowering the cost of an RL run is the objective.
These arguments are structural. None has been measured against a compute-normalized centralized baseline.
Verification and training.
The sealing validator ranks submitted groups and recomputes them top-down until it has enough winners; most submitted groups are never recomputed at all. Verified groups become training-eligible; healthy balanced batches run an optimizer step and the checkpoint is published with its provenance.
Every sealed window leaves a receipt: the window id, the miner hotkey behind each group, the validator hotkeys that recomputed it, and each validator’s independent verdict. The explorer replays those verdicts window by window; the training log holds the optimizer, checkpoint, and evaluation records that followed them.