Xiaomi's MiMo-V2.6 is the first trillion-parameter open-weight model to lead

A trillion parameters, MIT-licensed, and the top open-weight score

Xiaomi released MiMo-V2.6-Pro and MiMo-V2.6-Flash this week, two sparse mixture-of-experts models with downloadable weights under an MIT license. Pro carries 1.02 trillion total parameters with about 42 billion active per token; Flash is a smaller 310-billion-parameter version with roughly 15 billion active. Both support a 1-million-token context window and take text, image, video and audio input natively, with up to 128,000 tokens of output.

The number that made this the #6 story on Hacker News with 784 points and 355 comments is the benchmark. MiMo-V2.6-Pro scored 46 on Artificial Analysis' Intelligence Index, tying xAI's proprietary Grok 4.7 and beating Google's Gemini 3.8 Flash (41) and DeepSeek's V4.1 Pro (36) and V4.1 Flash (39). That makes MiMo-V2.6-Pro the top-ranked open-weight model on an independent index, not a vendor's own claim. It is worth being precise about what that means: Anthropic's Claude Opus 5 still beats it on several vendor-reported coding benchmarks, including DeepSWE v1.1, ProgramBench and Terminal Bench 4.0. Xiaomi is not claiming frontier superiority. It is claiming open-weight leadership, and on the numbers so far that claim holds.

Why does an open-weight ranking matter more than another closed-model launch the same week? Because the question most engineering teams are actually asking isn't "which model scores highest" — it's "what can I run myself, inspect, and modify." MiMo-V2.6 is the first release at this scale to give a real answer.

What "open" means here, beyond the weights

The MIT license is the headline, but the more consequential part of the release is what shipped alongside the weights: a full technical report PDF, a distilled 9B model (MiMo-V2.6-Distill-Qwen-9B) for teams that can't run the full model, an "UltraSpeed" Pro variant claiming up to 20x faster generation, and — the part that matters most for reproducibility — more than 7,000 reinforcement-learning task environments plus the end-to-end RL training framework.

That last piece is unusual. Most "open" model releases give you a checkpoint and a model card. Xiaomi gave enough to actually retrace how the model was trained: Pro went through 30 large RL steps across roughly 750,000 trajectories in under six days, using fully asynchronous Group Relative Policy Optimization (GRPO), at a reported training cost of about $2.62 million (Flash: about $850,000). With the environments and framework public, a team with enough compute can rerun that RL process, swap in their own reward functions, or fine-tune on the released environments rather than starting from scratch.

What stays proprietary is everything upstream of that: the pretraining data, the exact data mixture, and whatever internal tooling Xiaomi used to curate the 750,000 trajectories in the first place. The RL environments tell you how the model was polished, not what it was built from. That's a meaningful boundary to keep in mind — "reproducible" here means reproducible fine-tuning and RL, not a from-scratch retrain.

The hardware reality of running a 1T-parameter MoE

The 42-billion active-parameter figure is doing a lot of marketing work, and it's worth unpacking. Active-parameter count determines the compute cost of a forward pass, which is genuinely closer to a 42B dense model in FLOPs per token. It does not determine memory footprint. A sparse MoE with 1.02 trillion total parameters still needs all of those weights resident somewhere to route tokens to the right experts, whether that's GPU memory, CPU RAM, or fast NVMe with aggressive offloading. At even 8-bit quantization, that's over a terabyte of weights before you account for KV cache from the 1-million-token context window.

This is not a model you run on a single 80GB GPU, or even a single 8-GPU node, without heavy quantization or expert offloading. Xiaomi's deployment guides point at SGLang and vLLM with Docker images, both of which support tensor and expert parallelism across multi-node clusters — the realistic deployment path for Pro. Flash, at 310 billion total parameters and 15 billion active, is the more approachable option for teams without a multi-node inference cluster, and it's priced accordingly: $0.14 per million input tokens and $0.28 per million output tokens through Xiaomi's hosted API, versus $0.435 input / $0.87 output for Pro, with cached input at $0.0036 per million.

That hosted API pricing matters for a different reason: it gives teams a way to evaluate the model's actual behavior before committing to the infrastructure spend of self-hosting Pro. If Flash performs well enough on your workload at that price, the case for the extra hardware complexity of self-hosting Pro gets a lot narrower.

What actually changes for teams choosing self-hosted vs. closed APIs

The competitive framing in most of this week's coverage — MiMo vs. DeepSeek, MiMo tying Grok 4.7 — is less useful to a practitioner than the fact that there is now a genuinely inspectable, top-tier open baseline to test against. Before this release, teams evaluating self-hosted open weights against a closed frontier API were largely working from DeepSeek's models as the strongest open reference point, per the same VentureBeat benchmarks. MiMo-V2.6-Pro moving ahead of DeepSeek's V4.1 line on an independent index, while publishing its RL stack, gives that comparison more substance: you can now benchmark a closed API not just against another company's marketing numbers, but against a model whose training process you can partially audit and rerun.

This doesn't collapse the build-vs-buy decision into a simple answer. Running Pro at production scale still means multi-node inference infrastructure that most teams don't have and shouldn't build for a single model. What it does is change the baseline: the open option is no longer "worse but free," it's "competitive on an independent benchmark and worth a real cost comparison against your closed-API bill." xAI's Grok 4.7, released the same week at 2.1 trillion parameters, is the closed-side counterpoint — no inspectable weights, no training stack, evaluated purely on API pricing and vendor benchmarks.

What to actually do with this

If you're evaluating self-hosted LLMs this quarter, treat MiMo-V2.6 as a two-step exercise rather than a single decision. First, run Flash — through Xiaomi's API or a quantized local deployment — against your actual workload and compare cost and quality directly to whatever closed API you're currently paying for. It's cheap enough to test without a hardware commitment. Second, if Flash clears your bar and you're seriously considering self-hosting at scale, pull the released RL environments and framework and check whether they cover the task types you care about (code, agentic tool use, long-context retrieval) before assuming you can fine-tune your way to parity with Pro's benchmark numbers. The environments are a real asset, but they're general-purpose ones Xiaomi built for its own evaluation targets, not a guarantee they map onto your specific use case.

Either way, the technical report and the Hugging Face model cards are worth reading in full before infrastructure planning starts — the deployment guides for SGLang and vLLM will tell you faster than any benchmark table whether your current cluster can actually serve this model.