Reliquary 2B: training done

The results, and what they taught us about the training regime.

We finished training the 2B on SN81. Here is what came out of it.

Code: more accurate, and shorter

No BFT — no forced termination of the model's reasoning.

The model got more accurate while writing less. Code runs without forced termination, so nothing in the setup was pushing it toward brevity — it got there on its own. This is the cleanest result of the run.

Math: forced termination fixed the formatting, and capped the ceiling

With BFT, a hard cap that ends the rollout when the model won't stop on its own:

We used BFT here because the base 2B couldn't close its own thinking process. Without it, rollouts don't terminate, outputs aren't gradable, and the auction has nothing to price. BFT fixed exactly that — every formatting failure mode collapsed.

But the capability number is +2.8. The model mainly learned to finish, not to reason better, and we'd rather say that plainly than let the formatting deltas stand in for progress.

Three things this run settled

The system held. No failure in the validation stack, start to finish. The σ-gate, the auction and the curriculum ran unattended and took the model to its ceiling, on data with enough signal density to converge fast. Nothing was exploited, nothing needed patching mid-run. What limited this run was the constraint below, not the machinery.

The cap that made the run possible is what limited it. We didn't pick BFT as a tuning choice — without it the 2B was untrainable in math: rollouts never terminated, outputs weren't gradable, and the auction had nothing to price. So the cap is what made the run exist, and it also decided what the run could teach. A forced ending is usually a wrong answer, so what the model gets good at is finishing. Termination was the only thing a 2B was in a position to learn there, and +2.8 is what was left over. Code is the same training without that constraint, and it moved 19 points.

A post-trained checkpoint can't answer the question. The model we trained had already been through post-training. So the code result, real as it is, can't separate reasoning the system built from reasoning that was already installed and merely surfaced. Anyone claiming capability gains from RL on an instruct model has the same problem.

What's next

A 4B, from base, running DAPO on Reliquary — with a vanilla run alongside it as a control, on the same checkpoint and the same budget.

First we match it. DAPO is the open recipe for taking a raw model to reasoning, and reaching its quality on a decentralised network would already be worth doing on its own.

Then we beat it on speed — and what we want measured is the data. Same recipe, same base, same budget, one run fed by Reliquary and one by a standard pipeline. If ours gets there in fewer steps, the difference is in what went in.

That's what a market of this shape produces. A centralised run is limited by one team's ability to pick what to train on. Reliquary has a field of miners paid to do exactly that, and looking at what they submitted during the 2B run, and how fast, we think they have already built their own techniques for finding prompts inside the model's learning zone.

Fewer steps, lower cost. The model is one output of this. The data is the other one.