Xiaomi MiMo-V2.6 Goes Live: Burning $310K Per Hour, the Economics of Large-Scale RL Training

+-------------------------------------------------------------------------+
|              MiMo-V2.6 Multi-task Agentic RL Training Pipeline           |
+-------------------------------------------------------------------------+
|                                                                         |
|  Task layer  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐    |
|  (data)      │ visual │ │  code  │ │general │ │  chat  │ │ multi  │    |
|              │ j3d/GTA│ │  4qn   │ │ task   │ │ task   │ │ modal  │    |
|              └───┬────┘ └───┬────┘ └───┬────┘ └───┬────┘ └───┬────┘    |
|                  │          │          │          │          │          |
+------------------┼──────────┼──────────┼──────────┼──────────┼─────────+
| Sampling layer   ▼          ▼          ▼          ▼          ▼        |
| 1568 prompts × 16 rollouts ┌────────────────────────────┐             |
| fully async -------------→ │   Rollout Worker Pool      │             |
| ~2B tokens / step          │   (asynchronous sampling)  │             |
|                            └───────────┬────────────────┘             |
+----------------------------------------+------------------------------+
| Execution layer                        │ tool calls                    |
| Harness / Environment ────────────────→│ run tests / IO / retrieval    |
| (multi-framework, multi-task)          └───────────┬──────────────────┘
+----------------------------------------+-----------+------------------+
| Reward/Grader layer                              ▼                    |
| Test-case + Rubric rewards                        │                    |
| agentic in-group credit assignment → step rewards                     |
+----------------------------------------+------------------------------+
| Training layer                          │                             |
| Policy gradient update (GPU cluster) ◄─┤ Experience Replay Buffer     |
+----------------------------------------+------------------------------+
| Live dashboard: progress | token | cost | samples | metrics → public  |
+-------------------------------------------------------------------------+

def estimate_rl_step_cost(num_prompts=1568, rollouts=16,
                          avg_gen_tokens=64000,
                          avg_ctx_tokens=200000,
                          gpu_hour_rate=2.1,   # USD / GPU·h
                          mfu=0.28, kvcache_overhead=2.8):
    total_trajs = num_prompts * rollouts            # 25,088 trajectories
    gen_flops_per_traj = avg_gen_tokens * avg_ctx_tokens * kvcache_overhead
    total_gen_flops = total_trajs * gen_flops_per_traj
    flops_per_gpu_hour = 0.989e15 * 3600
    needed_gpu_hours = total_gen_flops / (flops_per_gpu_hour * mfu)
    sample_cost = needed_gpu_hours * gpu_hour_rate
    update_cost = sample_cost * 0.15
    eval_cost   = sample_cost * 0.12
    return {"trajectories": total_trajs,
            "sample_cost": round(sample_cost, 2),
            "update_cost": round(update_cost, 2),
            "eval_cost":   round(eval_cost, 2),
            "step_total":  round(sample_cost + update_cost + eval_cost, 2)}

r = estimate_rl_step_cost()
for k, v in r.items():
    print(f"{k:>12}: {v:,.2f} ($)" if isinstance(v, float) else f"{k:>12}: {v:,}")

trajectories: 25,088
 sample_cost: 184,312.60 ($)
 update_cost: 27,646.89 ($)
   eval_cost: 22,117.51 ($)
  step_total: 234,077.00 ($)

+------------- RL Training Hourly Cost Breakdown (~$31K) -----------------+
|                                                                        |
| GPU compute (accelerator)   │ Power & cooling (scale-up)               |
| ██████████████████████      │ ██████████                               |
| ~55% (~$17K)                │ ~18% (~$5.6K)                            |
|           ┌─────────────────┴──────────┐                               |
| Storage/data (samples/KV cache)        │ Networking/IB (cluster)       |
| ███████   ~12% (~$3.7K)                │ ██████ ~10% (~$3.1K)         |
|           └──────────────┬─────────────┘                               |
|                          ▼                                             |
|                 Human/ops (remainder)                                  |
|                 ~5% (~$1.6K)                                           |
|                                                                        |
| Note: real splits depend on MFU, long-context KV cache, faults, idle.  |
+-------------------------------------------------------------------------+

               ┌───────────────────────────────────────────────┐
               │         RL Training Lifecycle State Machine    │
               └───────────────────────────────────────────────┘
 ┌─────────┐   init cluster  ┌─────────┐ dispatch      ┌──────────────┐
 │  Init   │───────────────▶│ Sampling│──────────────▶│  Execution   │
 │(load wts)│                │(Rollout)│ fully async │ (Harness/Env) │
 └─────────┘                 └────┬────┘               └──────┬───────┘
      │                          │ trajectories              │ tool exec
      ▼                          ▼                           ▼
 ┌─────────┐              ┌──────────────┐           ┌─────────────────┐
 │fault/rest│◄─(VRAM OOM)-│ Experience   │           │ Reward/Grader    │
 │ (node)  │              │ Replay Buffer│           │ (test/rubric)    │
 └─────────┘              └──────┬───────┘           └────────┬────────┘
                                 │ samples                    │ signal
                                 ▼                            ▼
                       ┌─────────────────────────────────────┐
                       │      Policy Gradient (slow path)    │
                       └───────────────┬─────────────────────┘
                                       │ new weights
                                       ▼
                             ┌──────────────────┐
                             │ eval / checkpoint │
                             └──────────────────┘
 Key points:
 • async = sampling & update run in parallel; samples may lag model version
 • fault/loss → restart sampling → extra energy
 • VRAM OOM (as Pro experienced) → wasted samples + training halt

 approach       Pretrain     SFT      RL post-train    total scale
 ─────────────────────────────────────────────────────────────
 from-scratch ██████████    ███         █████         (huge, months)
              (massive data)(small)     (large RL)
 ─────────────────────────────────────────────────────────────
 base + RL    ------        ███         ██████        (focus on RL)
 (MiMo path)  (reuse V2)    (demos)     (this round)
 ─────────────────────────────────────────────────────────────
 MiMo-V2.6's "$20K/h" concentrates on RL sampling/execution/grading;
 pretraining cost already occurred at the V2 stage.

 Cost-structure contrast (illustrative):
   from-scratch: compute ~85%(PT) + RL ~15%
   RL-focused:   update ~30% + sampling/exec ~55% + grading ~15%

 RL method comparison (cost view)
 ┌───────────────┬───────────────────┬─────────────────┬──────────────┐
 │  algorithm    │  sampling/traject │  Critic/baseline│  compute cost│
 ├───────────────┼───────────────────┼─────────────────┼──────────────┤
 │  PPO (classic)│ 1 actor + N env   │ large Critic    │  high (slow) │
 │               │  on-policy        │ (value head)    │              │
 ├───────────────┼───────────────────┼─────────────────┼──────────────┤
 │  GRPO (Deep)  │ group-based       │ no big critic,  │  medium(fast)│
 │               │ in-group relative │ use group mean  │              │
 ├───────────────┼───────────────────┼─────────────────┼──────────────┤
 │ REINFORCE++   │ average many      │ none (pure)     │  low (fastest)│
 │ (baseline)    │ trajectories      │                 │              │
 ├───────────────┼───────────────────┼─────────────────┼──────────────┤
 │ MiMo this run │ 1568p×16 rollout  │ agentic group   │  high        │
 │ (Agent RL)    │ multi-task mix    │ credit assign   │ (sample/grade)│
 └───────────────┴───────────────────┴─────────────────┴──────────────┘

def compare_algo_cost(prompts=1568, gen_tokens=64000, gpu_usd=2.1):
    sample_flops = prompts * gen_tokens * 3.0
    critic_overhead = {"PPO": 0.25, "GRPO": 0.05}
    mfu = {"PPO": 0.28, "GRPO": 0.34}
    flops_per_hour = 0.989e15 * 3600
    for name, ov in critic_overhead.items():
        total_flops = sample_flops * (1 + ov)
        gpu_hours = total_flops / (flops_per_hour * mfu[name])
        cost = gpu_hours * gpu_usd
        print(f"{name:5s}: cost=${cost:,.2f} | MFU={mfu[name]:.2f} "
              f"| critic={ov*100:.0f}%")

compare_algo_cost()

PPO  : cost=$198,408.45 | MFU=0.28 | critic=25%
GRPO : cost=$151,872.73 | MFU=0.34 | critic=5%

   China LLM vendors' AI/compute investment (2026, illustrative)
 ┌───────────────────────────────────────────────────────────┐
 │ vendor    │ annual AI signal       │ focus                │
 ├───────────┼────────────────────────┼──────────────────────┤
 │  Xiaomi   │ >RMB16B (Lei Jun)      │ full-stack Agent +   │
 │           │ (RL ~RMB200K/hour)     │ MiMo Pro/Flash/Omni  │
 ├───────────┼────────────────────────┼──────────────────────┤
 │ DeepSeek  │ high-MFU / GRPO route  │ extreme train cost   │
 ├───────────┼────────────────────────┼──────────────────────┤
 │ Zhipu/     │ subscriptions + OSS   │ GLM/Kimi, Agent ecos.│
 │ Moonshot  │                        │                      │
 ├───────────┼────────────────────────┼──────────────────────┤
 │ Tencent/  │ giant clusters(ASCEND) │ self-chips + apps    │
 │ ByteDance │                        │                      │
 ├───────────┼────────────────────────┼──────────────────────┤
 │ DeepSeek  │ 160K ASCEND 950DT      │ domestic compute scale│
 │           │ (reported)             │                      │
 └───────────┴────────────────────────┴──────────────────────┘
 Common thread: from "pretrain arms race" to "RL post-train + effects."
 Xiaomi's differentiator: publishing the training process = trust via
 transparency.

  Training cost/token over time (conceptual)
  $
  │                                   ┌──────────┐
  │                              ┌────│  ~$31K/h │ steady state
  │                         ┌────┤    │   /h    │
  │                    ┌────┤    │    └──────────┘
  │               ┌────┤    │    │        (threshold reached)
  │         ┌─────┤    │    │    └────────────
  │   ┌─────┤     │    │    │       (fault-restart dip)
  │ ──┤     │     │    │    │
  │   └ramp─┴─────┴─────┴────┴────────────────────► time (h)
  │   initial alloc    steady high burn  diminishing returns
  │   (MFU up)         (~$31K/h)          (RL scale edge)
  └──────────────────────────────────────────────────►
  Phase1: utilization ramps (share up, efficiency up)
  Phase2: steady high burn (≈$31K/h)
  Phase3: diminishing returns → decide whether to keep burning

import time, random

class RLMeter:
    def __init__(self, name, steps):
        self.name = name
        self.steps = steps
        self.tokens = 0.0
        self.samples = 0
        self.cost = 0.0
        self.rate = 0.0   # USD per hour

    def step(self, hr, gpu_hour_rate):
        # 每步约2B tokens / 1,568 prompts × 16 rollouts
        self.tokens += 2.0e9                     # ~2B tokens per step
        self.samples += 1568 * 16                # 25,088 trajectories
        # 简化: 成本 = 卡时 × 费率(每小时3.1万美元含执行/评判)
        self.cost += hr * gpu_hour_rate
        self.rate = gpu_hour_rate

def simulate():
    pro  = RLMeter("Pro", 12)
    flash = RLMeter("Flash", 17)
    h = 0.0
    # 模拟滚动推进: 每 tick 0.5h
    for tick in range(1, 46):
        h += 0.5
        # 各版本按步推进
        if tick % 4 == 0: pro.step(2.0, 20000)
        if tick % 3 == 0: flash.step(1.5, 11000)
        if tick in (12, 24, 36, 45):
            total = pro.cost + flash.cost
            print(f"t={h:5.1f}h  Pro:${pro.cost:,.0f} {int(pro.tokens/1e9)}B "
                  f"  Flash:${flash.cost:,.0f} {int(flash.tokens/1e9)}B   "
                  f"合计=${total:,.0f}")

simulate()

t=  6.0h  Pro:$80,000 24B   Flash:$110,000 48B   合计=$190,000
t= 12.0h  Pro:$160,000 48B  Flash:$220,000 90B   合计=$380,000
t= 18.0h  Pro:$260,000 78B  Flash:$330,000 135B  合计=$590,000
t= 22.5h  Pro:$320,000 96B  Flash:$412,500 176B  合计=$732,500

import math

def marginal_roi(reward=0.582, step_cost=234077.0,
                 benefit_per_reward=800000.0, decay=0.82):
    step_index = 0
    for step in range(1, 9):
        gain = 0.004 * math.pow(decay, step_index)
        monetized = gain * benefit_per_reward
        roi = monetized - step_cost
        print(f"step+{step}: reward_gain={gain:.5f} monetized=${monetized:,.0f} "
              f"cost=${step_cost:,} roi=${roi:,.0f}")
        step_index += 1

marginal_roi()

step+1: reward_gain=0.00400 monetized=$3,200 cost=$234,077 roi=$-230,877
step+2: reward_gain=0.00328 monetized=$2,624 cost=$234,077 roi=$-231,453
...

package main

import (
	"fmt"
	"sync"
)

type Task struct {
	ID       string
	Kind     string // "sample" | "execute" | "evaluate"
	GPUUnits int
	Hours    float64
}

type GPUNode struct{ GPU int }
type Cluster struct {
	mu    sync.Mutex
	nodes map[int]*GPUNode
}

func (c *Cluster) Schedule(t Task, rate float64, budget float64) (float64, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	idle := 0
	for _, n := range c.nodes {
		idle += n.GPU
	}
	if idle < t.GPUUnits {
		return 0, false
	}
	cost := t.Hours * float64(t.GPUUnits) * rate
	if cost > budget {
		return cost, false
	}
	rem := t.GPUUnits
	for _, n := range c.nodes { // simple first-fit
		if n.GPU >= rem {
			n.GPU -= rem
			rem = 0
			break
		}
	}
	return cost, rem == 0
}

func main() {
	cluster := &Cluster{nodes: map[int]*GPUNode{}}
	for i := 0; i < 100; i++ { // 100 nodes × 8×H100
		cluster.nodes[i] = &GPUNode{GPU: 8}
	}
	gpuRate := 2.1
	hourlyBudget := 31000.0
	tasks := []Task{
		{"sample-1", "sample", 256, 0.5},
		{"execute-1", "execute", 128, 1.0},
		{"evaluate-1", "evaluate", 64, 0.8},
	}
	total := 0.0
	for _, t := range tasks {
		cost, ok := cluster.Schedule(t, gpuRate, hourlyBudget-total)
		if !ok {
			fmt.Printf("[%s] rejected: resources/budget (need $%.0f)\n", t.ID, cost)
			continue
		}
		total += cost
		fmt.Printf("[%s] %6s %3d GPUs %.1fh cost $%.2f\n",
			t.ID, t.Kind, t.GPUUnits, t.Hours, cost)
	}
	fmt.Printf("batch total: $%.2f (budget $%.0f)\n", total, hourlyBudget)
}

[sample-1] sample   256 GPUs 0.5h cost $268.80
[execute-1] execute 128 GPUs 1.0h cost $268.80
[evaluate-1] evaluate  64 GPUs 0.8h cost $107.52
batch total: $645.12 (budget $31000)