Xiaomi Live-Streams a Million-Dollar RL Training Run: How MiMo-V2.6 Is Publicly Stress-Testing the Limits of Reinforcement Learning

An Unprecedented Open Training Experiment

Xiaomi has done something rarely seen in the industry: live-streaming an agentic reinforcement learning (Agentic RL) training run costing over a million dollars — in real time. No paper, no blog post after the fact. Instead, they've moved a real RL training loop onto a public page where anyone can open mimo.xiaomi.com/rl and watch every training step scroll by.

MiMo project lead Fuli Luo wrote at launch: "After nearly six months of silence, we've been studying just one question: how far can RL actually scale?" That single sentence captures the essence of the whole endeavor — this isn't a marketing campaign, but a public stress test of reinforcement learning scalability.

The Real Numbers on the Dashboard

The live stream trains two models simultaneously: MiMo-V2.6 Pro and MiMo-V2.6 Flash. At the time of observation, key metrics for both were publicly displayed on a "scoreboard":

Metric	MiMo-V2.6 Pro	MiMo-V2.6 Flash
Training Step	Step 10 (progressing to 11)	Step 16 (rolling to 17)
DeepSWE v1.1 Score	62.24	60.77
Cumulative Cost	$741k	$322k
Tokens per Step	~2.2B	~2.6B
Batch	1568 prompts × 16 rollouts	Same
Samples Trained	251k	401k

Combined, the scoreboard shows a total cost of approximately $1.06 million — and still climbing. Exposing the burn rate this openly to the public has virtually no precedent in the large model training space.

The data reveals that the two models are taking different paths: Pro currently leads on the DeepSWE benchmark, while Flash has logged more steps with a steeper improvement curve. This means Flash could potentially catch up — or even surpass Pro — at a lower overall cost, making it one of the more compelling storylines to follow in the live stream.

DeepSWE is a benchmark designed for software engineering agents, evaluating a model's ability to complete tasks in real codebases — such as fixing bugs or implementing features. Its scores reflect end-to-end success rates in a full development environment, not just code completion quality. Compared to traditional code benchmarks like HumanEval or MBPP, DeepSWE requires multi-step planning, tool use, and error recovery, making it far closer to real-world software engineering scenarios. Scoring above 60 places a model in the top tier of current agent leaderboards — which is precisely why Xiaomi chose it as the primary live metric. It captures the real gains from agentic reinforcement learning far better than single-problem code generation tasks.

What They're Actually "Scaling"

Xiaomi emphasizes that what's being scaled in this run isn't raw compute alone — it's three coordinated dimensions:

Compute — approximately 2 billion tokens per step, using a fully async rollout mechanism to eliminate idle time caused by synchronization waits.

Environment — multi-task agentic RL, mixing multiple harnesses (task execution frameworks) within a single run. The model isn't grinding for scores on a single task; it's learning across a diverse set of real-world environments.

Reward compute — this is the most interesting dimension. They apply in-group credit assignment, combining test-case rewards with rubric-based rewards. This is a RLVR (Reinforcement Learning from Verifiable Rewards) approach rather than the classical RM+PPO (reward model + proximal policy optimization) pipeline.

The significance of this combination: reward signals come from verifiable outcomes — such as whether code passes a test — rather than from a reward model that can potentially be gamed. For agentic tasks, this reward design is far more aligned with measuring genuine capability.

RLVR (Reinforcement Learning from Verifiable Rewards) is a paradigm that has gained traction in code and math domains over the past two years. Its core idea is to replace neural network reward models with objectively verifiable signals. The traditional RM+PPO pipeline requires first training a reward model on human-annotated data, then using that model's scores to drive policy optimization — introducing two risks: the reward model itself may be wrong, and the model may learn to "please" the reward model rather than actually solving problems (i.e., reward hacking). RLVR bypasses this step entirely, using programmatic judgment to determine correctness: for code tasks, whether test cases pass; for math tasks, whether the answer matches the ground truth. This makes the reward signal nearly impossible to game, and is especially well-suited to programming-centric agentic tasks with clear right-or-wrong outcomes. Traces of similar mechanisms appear in the training details of both DeepSeek-R1 and OpenAI's o-series. MiMo's expansion of this approach to multi-task agentic settings is a public stress test of RLVR's viability in more complex environments.

A Dashboard Transparent Enough to Expose Failures

The metrics exposed on the live page are surprisingly granular: reward curves, entropy, KL divergence, context length (averaging ~90k–100k tokens!), gradient norms, and per-step timing are all visible in real time.

More notably, Pro hit a VRAM issue at one point and triggered a restart — and this failure was displayed directly in the notification feed, like an uptime status page. For observers accustomed to vendors showing only successful results, watching a real "crash and recovery" during training actually increases the credibility of the whole operation.

Both DeepSWE curves are trending upward, indicating the training is in a healthy state. This willingness to make both successes and failures public redefines, in some ways, what "technical transparency" can mean.

A few of the core dashboard metrics deserve specific explanation. Entropy measures the diversity of the model's output distribution: if entropy continuously drops to near-zero during training, it signals the model has "collapsed" into fixed output patterns — a warning sign of over-optimization. KL Divergence measures how far the current policy has drifted from a reference policy (typically the base model before training); excessively large KL values suggest the model may have strayed too far from its pre-trained knowledge. Gradient Norm reflects the magnitude of parameter updates — anomalous spikes often foreshadow training instability or an impending out-of-memory event. The average context length of 90k–100k tokens is not unusual for agentic tasks: agents must read tool return values, historical action logs, and task descriptions within a single inference pass, making long contexts a natural consequence of real working trajectories — and an extreme stress test for GPU VRAM and KV cache management. This also explains why Pro hit a VRAM ceiling and triggered a restart.

Why This Matters

After nearly six months of silence, suddenly launching a live stream like this sends a clear signal from Xiaomi: agentic reinforcement learning is moving from papers into the engineering-scale validation phase.

Historically, evaluating a model meant waiting for final benchmark scores and an after-the-fact write-up. A public training loop means the community can observe in real time the genuine trade-offs between cost, convergence speed, and stability. For researchers, this is more convincing than any paper — because it can't be cleaned up after the fact.

Xiaomi says training details will be open-sourced in the coming weeks. If that commitment is honored, MiMo-V2.6's "open training" run could become a valuable reference point for the agentic RL field — not just open results, but an open process.

That said, some caution is warranted. The numbers on the live dashboard are currently self-reported by Xiaomi, and third parties have no way to independently verify their accuracy or completeness. The true value of this effort can only be fully assessed once the promised open-source details land. But regardless, putting a million-dollar-plus RL training run in front of the public is itself a bold move for the industry.