InclusionAI (Ant Group) applied Zero RL to a raw 1 trillion parameter base model. No human-annotated data. No supervised fine-tuning. Pure reinforcement learning with verifiable rewards - technically called RLVR (Reinforcement Learning with Verifiable Rewards). The reward signal is binary: did the model get the right answer? That is it. The result: 5 cognitive behaviors emerged spontaneously, including a model that monitors its remaining context window and strategically panics when tokens run low. Nobody programmed any of it. #1 on HuggingFace Daily Papers, July 16, 2026.
# What Nobody Programmed
Ring-2.5-1T-Zero was trained with one objective: get the right answer. That is it. No instructions on how to reason, how to format, how to verify.
The training signal was a binary reward. Correct answer: +1. Wrong answer: 0. No partial credit. No human feedback on reasoning quality. Yet the model independently discovered 5 sophisticated cognitive strategies.
The model starts narrating its reasoning in first person. "Let me reconsider this." "I think the key insight is..."
This is not RLHF. No human told it to speak this way. It discovered that framing reasoning as internal monologue leads to better answers. First-person narration became a problem-solving strategy, not a personality trait.
Without any formatting instructions, the model starts organizing its reasoning into sections, numbered steps, and bullet points.
It learned that structured output correlates with correct answers. Readability is a side effect. The model does not care about human readability - it cares about organizing tokens in ways that minimize reasoning errors.
After reaching an answer, the model independently re-derives the solution from scratch. If the 2 paths agree, it commits. If they diverge, it investigates the discrepancy.
This is what labs spend months building into prompted CoT pipelines. Ring-Zero discovered it for free. Self-consistency checking emerged as an optimal strategy with zero prompt engineering.
The model explores 2-3 solution paths simultaneously - substitution, induction, direct computation - then selects the one that converges fastest.
This is implicit tree search without being given a tree search algorithm. The model learned that exploring multiple branches and pruning losers is more token-efficient than committing to a single path early.
When the model estimates it has consumed roughly 85% of its context window, behavior changes abruptly. Deep deduction stops. Verification is skipped. The model outputs the best available answer immediately.
This is resource-aware survival behavior. The model learned that a partial answer is worth more than no answer. The paper calls this "strategic panic" - the model essentially runs a cost-benefit analysis on its remaining tokens.
The production implications are massive. Models that self-manage their compute budgets without external orchestration could reshape how inference pipelines are built. Nobody coded a token counter. Nobody wrote a "hurry up" instruction. The model discovered resource management on its own.
# Context Anxiety Up Close
Here is what the model's reasoning chain looks like when it detects low remaining tokens. The shift is abrupt and deliberate. Watch a hard combinatorics problem trigger the transition.
Problem: In how many ways can 12 distinct books be placed on 4 identical shelves such that no shelf is empty? Let me approach this systematically. This is a surjective distribution problem. I'll explore Path A: inclusion-exclusion I'll also try Path B: Stirling numbers...
Path A: S(12,4) via inclusion-exclusion... 4^12 - C(4,1)*3^12 + C(4,2)*2^12 - C(4,3)*1 = 16777216 - 4*531441 + 6*4096 - 4 = 16777216 - 2125764 + 24576 - 4 = 14676024 Wait - let me verify by trying another approach. Path B: direct Stirling computation S(12,4) = sum of... *re-derives from scratch* Path B confirms: 14676024. But since shelves are identical, divide by 4! Final: 14676024 / 24 = 611501
Given the analysis above, the answer is 611501.
The paper describes context anxiety as the model approaching what it "perceives as its maximum" context window, at which point it "actively aborts" deep reasoning. Rather than failing silently or producing truncated output, the model deliberately restructures its response strategy.
The researchers note this is distinct from simple truncation. The model makes a deliberate decision to abandon verification steps and commit to its best current answer. It has internalized that the expected value of a complete-but-unverified answer exceeds the expected value of a verified answer that gets cut off by the context limit.
Deep deduction, multiple paths, self-verification, re-derivation from scratch. The model takes its time, explores thoroughly, and cross-checks its work against alternative methods.
Aborts verification. Skips remaining paths. Switches from "Let me verify by trying another approach" to "Given the analysis above, the answer is...". Survival mode.
If your model is running on a fixed context window in production, it may already be doing something similar. Current reasoning models likely make implicit decisions about depth vs. remaining space. The difference is that Ring-Zero makes this behavior visible, measurable, and documented. Before this paper, nobody had proven it happens.
# When Naive Scaling Fails
The paper documents that simply scaling RL training to 1 trillion parameters did not work out of the box. Naive scaling failed. 3 problems appeared that required engineering interventions.
This matters because it reveals the gap between "just scale it" and "scale it correctly." The emergent behaviors only appeared after these fixes were in place.
Raw RL training at scale produced incomprehensible reasoning traces. The model solved problems correctly but generated token sequences that no human (or downstream system) could parse.
Prevents catastrophic policy updates during training. Constrains how far the model can deviate from its previous policy in a single update step, maintaining reasoning coherence.
Structured, human-readable chains of thought that maintain logical flow across hundreds of reasoning steps.
The model repeated similar reasoning steps over and over, wasting precious context window space. Useful compute was lost to repetitive token generation.
Aligns training dynamics with inference behavior. Ensures the model's training-time exploration translates into efficient inference-time reasoning without wasteful repetition.
Each reasoning step advances the solution. No more circular loops or redundant re-statements of the same logical point.
The model could not adjust reasoning effort based on problem difficulty. Easy and hard problems consumed the same number of tokens. No compute budgeting.
Prevents numerical instability at trillion-parameter scale. Stabilizes gradient flow so the model can learn nuanced policies for effort allocation across problems of varying difficulty.
Simple problems get short reasoning chains. Hard problems get deep multi-path exploration. The model learned to budget compute.
The takeaway: the emergent behaviors from Section 1 are not free. They required the right engineering substrate. The model discovered sophisticated reasoning strategies, but only after the training infrastructure was stable enough to support them. Scale enables emergence, but engineering enables scale.
# The Bitter Lesson at Scale
The paper validates Rich Sutton's "bitter lesson" three times over. Scale wins. Engineering shortcuts lose. Here are the 3 key findings.
Scaling to 1 trillion significantly enhances sample efficiency and raises the performance ceiling. The model learns faster per training step at larger scale.
Zero human-annotated data. Pure RLVR (Reinforcement Learning with Verifiable Rewards). The reward is binary: correct or incorrect. No partial credit. No human judgment on reasoning quality.
Discovery (exploring strategies) then Sharpening (refining them). 2 distinct, measurable phases. The transition point is visible in the loss curves.
Ring-2.5-1T-Zero was evaluated across 7 challenging mathematical benchmarks covering competition math, olympiad problems, and graduate-level reasoning. Performance was measured not just on accuracy but on the quality of the reasoning chain itself.
"Zero RL" refers to RLVR - Reinforcement Learning with Verifiable Rewards. The word "zero" means zero human-annotated data. No supervised fine-tuning stage. No RLHF. No human preferences on reasoning quality.
The reward is purely "did you get the right answer?" Binary. For math, verification is straightforward - check the final number against the ground truth.
Here is the remarkable part: reasoning quality improved as a side effect. Nobody rewarded the model for clear reasoning. Nobody penalized it for messy chains. Yet the model converged on structured, verifiable, human-readable reasoning because that strategy maximizes the probability of getting the final answer correct.
# Why This Matters
Hand-crafted reasoning pipelines just got an expiration date. Scale makes them obsolete. But the implications go far beyond math.
Stop hand-crafting reasoning pipelines. Scale does it better. Every hour spent engineering CoT prompts is an hour that could go toward scaling compute. The model will discover reasoning strategies you never imagined.
Models that manage their own context are coming. Your orchestration layer - the one that chunks inputs, manages token budgets, and decides when to truncate - may become redundant. Plan for models that self-regulate.
The "discovery then sharpening" training dynamic means you can predict when emergent behaviors will appear. Watch the loss curves. The transition between phases is measurable and repeatable across model scales.
These behaviors emerged in a math model. What happens when you apply Zero RL at trillion scale to code? To science? To medicine? The paper does not answer this - it only tested on mathematical benchmarks. But the underlying dynamic (binary reward + scale = emergent strategies) has no obvious reason to be math-specific. That is a hypothesis worth watching.
Models that budget their own tokens. No external orchestration needed. The model decides when to think deeply and when to commit fast.
New evaluation framework: comprehensibility, reproducibility, efficiency. Reasoning chains are now measurable products, not black boxes.
The discovery-then-sharpening dynamic means emergent behaviors are not random. Watch the loss curves. The transition point is your signal.
Nobody taught this model to panic about running out of tokens. Nobody taught it to verify its own answers. Nobody told it to format its reasoning in bullet points. Nobody showed it how to explore multiple solution paths. These behaviors emerged as optimal strategies discovered through reinforcement learning at trillion-parameter scale.
You cannot engineer what emerges at scale. You can only create the conditions for it to appear. Ring-Zero proves that with the right training signal and enough parameters, models will discover cognitive strategies that took human AI researchers years to design by hand. The question is no longer whether to scale. The question is what else will emerge when you do.
Inkling: The Former OpenAI CTO Did What Altman Would Not
Mira Murati left OpenAI, built a 975B-parameter frontier model from scratch, and released it fully open under Apache 2.0. The largest American open-weights model.
Enjoyed this?
New episodes Mon, Wed, Sat.