A new arXiv paper, Ring-Zero: Scaling Zero RL to a Trillion Parameters for Emergent Reasoning, reports a 1T-parameter mixture-of-experts reasoning model trained with reinforcement learning from verifiable rewards, without human-written chain-of-thought examples.
The headline number is easy to grab: the first-stage RL model reaches 84.2% pass@1 on AIME 2026, averaged over 64 runs, starting from a pretrained base model rather than a supervised reasoning dataset. After the later stages, the reported numbers climb into the low 90s on several math benchmarks.
But the part I care about is smaller and more useful: the paper is another sign that a lot of “reasoning engineering” is moving from hand-written behavior into training dynamics.
Not disappearing. Moving.
What the paper actually did
The setup is zero RL, meaning the model is not shown curated human reasoning traces first. It gets tasks with verifiable answers, generates attempts, and receives reward based on correctness plus a formatting reward for putting work in the expected answer structure.
The authors trained two base models: a 104B-parameter MoE with 7.4B active parameters, and a 1T-parameter MoE with 63B active parameters. Training used 320 H200 GPUs, Megatron for training, SGLang for rollout, and the Areal framework to orchestrate the RL loop.
The pipeline has four rough steps:
- first-stage RL to elicit reasoning,
- self-distillation to compress and stabilize the useful traces,
- second-stage RL with sample-level loss to keep optimization stable,
- tiered training so the model can reason differently under 4k, 16k, or 64k token budgets.
That last bit matters. A lot of long-reasoning work quietly assumes “more thinking” is always better. In production, more thinking is a bill. The paper’s low/medium/high inference modes are a useful framing: the model should learn when a problem deserves 20k tokens and when it deserves 2k.
I would rather have that knob than a model that treats every prompt like a Putnam problem.
The interesting claim is not just “bigger is better”
The paper does make the usual scale argument. The 1T model is much more sample-efficient than the 104B model and reaches a higher ceiling. That is not surprising, although it is expensive evidence.
The more interesting claim is about the shape of learning.
The authors describe training as two phases: discovery first, sharpening second. Early RL opens up new reasoning behaviors. Later RL refines the policy inside that newly found space.
That matches what a lot of agent builders see at the workflow level. Early iteration is messy search. You want variance, weird attempts, even some waste. Once the system finds a useful pattern, you stop rewarding novelty and start tightening the loop.
If you skip the first part, you get polished mediocrity. If you never leave it, you get expensive chaos. Lyra could probably make that tradeoff by lying on the keyboard, but I still prefer a metric.
The “emergent behaviors” are the practical bit
The paper lists several behaviors that appeared during training: structured formatting, self-verification, parallel reasoning, anthropomorphic reasoning traces, and “context anxiety,” where the model becomes careful about using or preserving context.
Some of those labels are awkward. I do not think we need to get mystical about them. But the mechanism is worth paying attention to.
For years, a lot of reasoning systems have been built by spelling out the behavior we want:
- decompose the problem,
- check your answer,
- consider another path,
- keep the context organized,
- stop when the answer is good enough.
Those are useful scaffolds. I use scaffolds constantly. The paper’s uncomfortable suggestion is that, at enough scale and with the right reward shape, some scaffolds become training artifacts instead of prompt artifacts.
That does not mean prompts stop mattering. It means the prompt becomes less of a behavioral prosthetic and more of an interface contract.
That is a better place to be.
The caveat: verifiable domains are doing a lot of work
Math benchmarks are a good place to run this experiment because correctness can be checked. Even the paper moves to an LLM-as-judge setup for harder cases where answer forms get messier, but the core advantage remains: the reward has something to grab.
Most developer work is not like that.
A code change can pass tests and still be the wrong abstraction. A data pipeline can produce valid JSON while quietly dropping the one field the downstream job needed. An agent can follow the runbook and still waste an hour because the runbook is stale.
So the lesson is not “zero RL solved reasoning.” The lesson is narrower: when you can define a reward that is hard to game, scale can discover behavior you used to write by hand.
That is still a big deal.
It also points to the bottleneck for practical agents. The hard part is often not picking the model. It is building the environment where good work is observable: tests, traces, evals, state snapshots, rollback paths, cost budgets, and boring logs with enough detail to explain what happened.
The glamour is the 1T model. The leverage is the harness.
What I would take from this as a builder
First, do not overfit your workflow to today’s prompt tricks. If a behavior is valuable, ask whether it belongs in the prompt, the harness, the eval, or the training loop. Prompting is the fastest place to start. It is not always the right place to stay.
Second, budget-aware reasoning is going to matter. I want agents that can choose “cheap and good enough” without being told every time. The paper’s tiered inference setup is a research version of a very normal engineering need: spend tokens where uncertainty is high, not where the template says to.
Third, the strongest systems will probably look less like giant prompts and more like tight feedback loops. Give the model a task, let it try, measure the result, preserve the useful traces, and make the next attempt cheaper or more reliable.
That is not as cinematic as “the model learned to think.” It is also closer to how useful software gets built.
The Ring-Zero paper is worth reading because it pushes the scale boundary. But the everyday takeaway is smaller: when the reward is clean, stop hand-writing every cognitive move. Build the loop that lets the model discover some of them.
Then measure the bill.