The transparency stunt that actually meant something

For the past three to four years, the public story of a frontier model has been packaged around a familiar set of disclosures: parameter count, benchmark scores, an API, sometimes weights, occasionally a decent model report. But the actual process, the training environments, the reward signals, the infrastructure failures, the invoice, stayed firmly inside the lab.

Xiaomi’s MiMo team broke that pattern. On 15 September 2026, they started two RL post-training jobs in parallel. Within two days, the trainer logs were on the open web at mimo.xiaomi.com/rl. Team lead Fuli Luo framed it as a single research question made operational: how far agentic RL can scale.

The two cards you can hold

Both checkpoints are native omnimodal with a claimed 1M-token context, and both carry the MIT licence, commercially usable, fine-tunable, redistributable, no revenue gate, no research clause. The card calls Flash the “efficiency-balanced checkpoint” of the series and Pro the flagship. The interesting part is how the two differ once you look at the configs rather than the marketing sentence.

Flash runs a 48-layer backbone with 39 sliding-window attention layers and 9 global attention layers, a hidden size of 4096, 256 routed experts with 8 activated per token, and a 128-token sliding window. The first Transformer block uses global attention with a dense FFN, everything after it interleaves SWA and GA, both using sparse MoE FFNs without shared experts.

The vision encoder is a 681M-parameter MiMo ViT, 28 layers split 24/4 between sliding-window and global attention, with a patch size of 2×16×16 and 2×2 spatial merging. The audio stack is a 308M AudioTokenizer (24 layers, 20 RVQ codebooks) plus a 127M audio patch encoder that downsamples from 25 Hz to 6.25 Hz. For speed, there’s a 5-layer multi-token-prediction drafter that predicts seven subsequent tokens per forward pass for parallel verification.

This isn’t three bolted-together pipelines. Text, image, video, and audio all enter the same model, trained together, reinforced together.

Three numbers that don’t agree

This is worth stating plainly, because all three numbers affect a deployment decision rather than a benchmark argument, and none of them is necessarily sinister, they look like documentation drift between the write-up, the repository page, and the shipped files.

What’s actually in the RL recipe

The training run is where this release gets genuinely interesting, because the details were public in real time. Each model ran 30 steps. Each step’s batch shape was 1,568 prompts × 16 rollouts per prompt, 25,088 nominal sequences before a model update.

That group of 16 is the credit-assignment unit. Graders score traces with test cases and rubrics, and advantages are computed inside the group. Xiaomi calls this Groupwise Agentic Grading, and it’s a significant departure from binary pass/fail rewards.

Groupwise Reward Synthesis (GRS) builds task-specific rubrics offline from contrasting rollouts within each group, then fuses rubric quality with test outcomes. Groupwise Advantage Redistribution (GAR) ranks passing trajectories online and moves advantage toward higher-quality solutions.

The result is a self-improvement loop that steers toward shorter paths and fewer tokens per task, judged against the policy’s own samples.

The dynamic sampler makes the pipeline work. The trainer draws ~3,300 prompts × 16 traces per step (oversampling), judges them, drops groups that are all zeros or all ones (which carry no training signal), and packs the accepted pool back down to the 1,568 × 16 target. The log shows accepted counts of 2,200, 2,700 against a target of 1,568. Dispatch more than you judge, judge more than you accept, accept more than you train.

The async architecture separated rollout, grading, and training into independent clusters. Rollout owned the long multi-turn generations by scaling inference and sandboxes, at peak, 38,694 environments were live for the Flash run and 11,180 for Pro. The grader cluster owned the oversample. The training cluster owned a fixed backward pass. When the training cluster lost connectivity to the graders mid-run, generation, judging, and training ops didn’t stop.

The cost of public learning

Here’s where the dashboard busts a persistent myth: enterprise-scale RL doesn’t have to cost hundreds of millions of dollars.

The Flash run processed 81.4B tokens at a cost of $854k. Pro processed 75.0B at $2.62M. Same loop, same batch shape, same 1,568 × 16 grid, the bill is the size difference.

For enterprises eyeing agentic post-training on proprietary data, these numbers are not prohibitive. They’re planning inputs. Xiaomi just made the unit economics visible.

The batch composition offers a product strategy read. Code dominated every step at 65.8% of prompts, with visual at 19.5%, general at 11.3%, and chat at 3.4%. Cyber was included in the Pro run until the team removed it mid-training after observing “bad patterns in the rollout logs.” Capability priorities aren’t abstract, they’re visible in the sampler.

Benchmark reality check

Every benchmark figure here comes from Xiaomi’s own evaluation tables in the model card. None of it has been independently reproduced, none of it appears on a public leaderboard, and the comparison columns are the vendor’s own runs of the same harnesses against other companies’ models. Treat the shape of the results as informative and the decimal places as decoration.

On DeepSWE v1.1, Flash lands at 67.9 against Claude Opus 5’s 74.0. On Terminal Bench 2.1, it’s 87.6 versus 89.1, a gap small enough that the harness, not the model, may be deciding it. AutomationBench puts Flash above both GPT-5.6 Sol and Claude Opus 5 on Xiaomi’s run.

The most lopsided column is cybersecurity. CyberGym: Flash 95.1, above its own bigger sibling Pro at 94.0, against MiMo-V2.5-Pro’s 40.0, a 55-point jump in one generation. Then the floor drops out: ExploitGym 6.0 for Flash against 22.1 for Opus 5, ExploitBench 25.3 against 70.0, SEC Bench Pro 47.5 against 79.1 for GPT-5.6 Sol. CyberGym measures something specific, and Xiaomi’s RL pipeline optimized for it aggressively.

One number is worth pulling out because it’s the kind of thing a launch post usually hides. The RL dashboard published Flash at 65.68 on DeepSWE v1.1 during training, and the model card now prints 67.9 for the same benchmark on the finished checkpoint. Those are not the same measurement. The dashboard figure was labeled mini-swe-agent, avg@3, on a training snapshot, the card’s table is the vendor’s offline evaluation of the released weights. The two-point difference is the gain from the last part of the run plus whatever changed in the evaluation setup.

This builds directly on Xiaomi’s earlier work, the MiMo V2.5 breakthrough that reportedly hit 3000 tokens per second and the DFlash speed optimization that made a 300B model practical. The MiMo-V2-Flash architecture was the efficiency-focused predecessor, and Xiaomi’s AI Cube hardware with 1.22TB/s memory bandwidth points squarely at on-device execution.

What “open source” actually means here

Open weights are a license, not a bill. The card’s own deployment section recommends SGLang at tensor parallel 16 with data parallel 2, or a vLLM recipe at tensor parallel 8. That’s a multi-node serving job for a 309B model whose weights occupy about 173 GB before you add KV cache for a 1M-token context.

The honest framing: Xiaomi removed the license barrier and left the hardware barrier exactly where it was. Fine-tuning Flash on your own traces is now legal and possible, doing it on anything smaller than a serious GPU node is not.

The SGLang serving command shows the practical deployment profile:

sglang serve \
  --trust-remote-code \
  --model-path XiaomiMiMo/MiMo-V2.6-Flash-RL \
  --tp 8 \
  --dp 2 \
  --enable-dp-attention \
  --enable-dp-lm-head \
  --mm-enable-dp-encoder \
  --mem-fraction-static 0.65 \
  --chunked-prefill-size 16384 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --enable-multi-layer-eagle \
  --reasoning-parser mimo \
  --tool-call-parser mimo \
  --host 0.0.0.0 \
  --port 30000
    

Notable: data parallel attention heads, data parallel LM head, and data parallel encoders, the architecture was designed for multi-node serving from the start, not retrofitted.

For vLLM, the MiMo-V2.5 recipe applies, with a pre-built image at docker pull vllm/vllm-openai:mimov25-cu129. Recommended sampling: temperature 1.0, top_p 0.95.

The -RL suffix model is available through Transformers with trust_remote_code=True, and quantizations exist for llama.cpp, Ollama, and LM Studio, three community quantizations are listed on the model tree, which suggests the edge deployment story isn’t purely theoretical.

The pricing vacuum

Xiaomi has not published a per-token rate for MiMo-V2.6-Flash. Reporting says the series will retain MiMo-V2.5’s API pricing, around $0.10, 0.14 per million input tokens with cached input an order of magnitude cheaper, but nothing on Xiaomi’s site confirms the new checkpoints inherit those rates. Until a price list appears, any figure you see for a MiMo-V2.6 endpoint is someone’s inference.

Two other things are missing, and both are on Xiaomi’s own to-do list:

1. The training stack. Luo Fuli’s statement during the RL livestream was that the training environments and RL code would be open-sourced. The repositories currently ship weights, a technical report, and deployment instructions, not the training stack.

2. Independent evaluation. No leaderboard submission, no third-party rerun of the DeepSWE or CyberGym columns. That’s the gap that matters most for anyone deciding whether a 309B model with a 15B active budget is worth a node.

What this means for edge AI

The “Flash” designation matters beyond marketing. With 15B active parameters, Flash is designed for workloads where latency and throughput matter more than raw capability, the real-time agent tier. The 5-layer speculative decoder predicting seven tokens ahead, the sliding-window attention optimized for streaming, and the data-parallel serving architecture all point to low-latency inference as a design goal.

The trillion-parameter MiMo-V2.5-Pro-UltraSpeed hitting 1000+ tokens per second showed Xiaomi’s ceiling. Flash is the floor they’re trying to raise for practical deployments.

What we’re actually seeing is a coordinated play across the stack: models that excel at complex reasoning, a 1.22TB/s AI Cube for local execution, and now open-weight checkpoints with the training run exposed. The strategic direction isn’t subtle, Xiaomi wants to be the default AI platform for devices, and they’re using radical transparency as the wedge.

The RL training dashboard published the cost. The checkpoint is MIT-licensed. The technical report is attached. The last remaining question is whether anyone can independently verify the benchmark claims, and whether the training loop itself, when open-sourced, will let enterprises build their own self-improving agents on proprietary data.

Until then, the practical reading of this release is narrow and clear: MiMo-V2.6-Flash-RL is a legitimate open-weight, MIT-licensed, omnimodal agent model at a scale that assumes a cluster, and it’s the first checkpoint in the MiMo-V2.6 generation you can hold in your hands. That’s more than could be said for it last week.