Xiaomi released and open-sourced the MiMo-V2.6 omnimodal model family on September 22, 2026, with two natively omnimodal models: Pro and Flash. The parameter count has not been published. According to the official numbers as relayed by AI tool coverage, Pro scores 46 on the AA Composite Intelligence Index, overtaking Kimi K3 and Qwen3.8 Max to become the strongest open-source model available. It still trails the closed models Claude Fable 5.1 and GPT-6 Astra, but the gap has narrowed into workable territory. The capability map spans software engineering (clearly improved out-of-sample on DeepSWE v1.1), 3D game scene generation, Blender modeling, closed-loop robotic arm control, Computer Use, research work (material screening for dry-lab experiments and Lean 4 formal proofs), plus content creation across frontend pages, presentations, SVG, video and music.
Behind that scoreboard sits large-scale Agentic RL: roughly six days of live RL, about 750,000 trajectories, a 1M training context, single-step updates pushing 2.7 to 3.7B tokens, large batches on a fully asynchronous architecture. Stability got equal attention: the MoE router is frozen to suppress expert-load drift, within-group relative comparison provides fine-grained rewards for long-horizon tasks, and a four-layer stack of reward design, adversarial evaluation, anomaly detection and verifier cross-checking keeps Reward Hacking down.
For most readers, that is background. The real question is how to wire this thing into your own workflow. This SOP splits integration into three routes with rising barriers to entry, so you can pick by matching your situation. One boundary note before we start: MiMo-Code, covered in our earlier dedicated piece, is Xiaomi's terminal coding assistant from a previous release cycle. It is a separate product line, not the entry point for MiMo-V2.6. For the full release recap and training deep-dive, see our launch coverage; this article is strictly hands-on.
Route Selection: Match Yourself to a Lane
| Route | Best for | Barrier | Cost structure | Control |
|---|---|---|---|---|
| MiMo Desktop client | Individuals, light daily tasks | Lowest, install and go | Subscription or your own API key | Low, configured in UI |
| Open platform API | Developers, teams embedding into products | Medium, requires code | Pay per token, see open platform docs | Medium, you pick tools and params |
| Local weights | Teams with GPUs, researchers reproducing RL | Highest | Hardware and ops cost | Highest, weights in hand |
The decision rule is simple: if you just want a capable assistant, take Route 1; if you need to embed model capability into your own product or agent system, take Route 2; if you need data to stay in-house, plan to fine-tune, or want to reproduce the training recipe, take Route 3. The routes are not mutually exclusive. Many teams run one and two in parallel and keep three as a fallback.
Route 1: MiMo Desktop, the Ten-Minute Path
This is the official shortest path. The client covers both macOS and Windows, and the whole setup breaks down into five steps:
- Download and install. Grab the client for your OS from the official channel and install it the normal way. No special dependencies.
- Connect an account. Two options: sign in and subscribe, which is the easiest for individuals, or, if you already hold an open platform API key, configure it yourself in settings, which suits teams with enterprise accounts.
- Switch models. In the model list, toggle between MiMo-V2.6-Pro and MiMo-V2.6-Flash. The rule of thumb: hand complex reasoning, software engineering and long-horizon agent tasks to Pro; route high-frequency lightweight work, drafts and polish to Flash. Keep both in the list and switch as needed to balance cost and quality.
- Turn on UltraSpeed mode. This fits scenarios where response latency matters more than polish: brainstorming while iterating, quick frontend page drafts. It trades some generation refinement for shorter waits, which is exactly what you want when moving fast.
- Dispatch tasks in plain language and iterate with screenshots. Describe the task in everyday words; for anything visual, paste a screenshot and let the model fix what it sees. This is where an omnimodal model feels most different from a text-only one: you never have to translate an interface into words, because one screenshot is the most precise requirement statement you can give.
A typical iteration round looks like this: you say the login page should go dark-theme, the model produces version one; you screenshot and circle the wrong button spacing, the model studies the image and ships version two; one more screenshot confirms the result, done in three rounds. No code, no prompt templates, just typing and screenshots.
Scenarios where Route 1 is enough: everyday Q&A and writing polish, frontend page generation and iteration, presentation and SVG asset production, image-based revision, Blender modeling help. If your needs live entirely on that list, you can stop reading here. Two kinds of demand push you further down: embedding the model into your own product or system, and batch-automating tasks at scale. Both are API territory.
Route 2: The Open Platform API, Wiring It into Production
This is the developer's main battlefield, and the core moves are create-app, get-key, call-interface, canary-rollout.
Step one, create the app and get the key. Register on the MiMo open platform and create an application to obtain an API key. Follow the usual key hygiene: never commit keys to repositories, never print them to logs, isolate per environment, rotate regularly, revoke immediately on suspicion of leakage.
Step two, assemble requests per the documentation. The request body minimally contains the model name and a messages array; add tool definitions when you need tool calling, and pass image content in the multimodal format the docs specify. Field names and format details follow the open platform documentation. A purely illustrative skeleton:
{
"model": "mimo-v2.6-pro or flash, per docs",
"messages": [
{ "role": "user", "content": "text or multimodal content with images" }
],
"tools": "tool definitions per docs when needed"
}Step three, and this matters more than model choice if you are wiring in agent tasks: design the feedback loop. The way MiMo-V2.6 was trained makes it a natural fit for an execute-check-correct cycle, and your job is to feed the check-phase signals back in:
| Feedback signal | Task type | How to feed it |
|---|---|---|
| Environment logs | Command execution, deployment | Return the raw failure log, not just an error summary |
| Test pass rate | Software engineering | After the test run, return both passing and failing cases |
| Screenshots | Frontend, UI, design | Return render screenshots so the model self-checks against the requirement |
| Verifier output | Tasks with clear acceptance criteria | Structure the verifier output and return it |
Three design points for the loop. First, the check signal must be objective: if a test or verifier can judge it, do not rely on human eyes. Second, cap the correction rounds; unbounded loops burn money. Third, persist the full trajectory of every round to storage, because it is both your debugging evidence and the raw material for a future evaluation set. For how to build the evaluation layer, our agent evaluation SOP covers the methodology end to end.
There is a deeper reason this loop works with this model: MiMo-V2.6 was literally reinforced across roughly 750,000 trajectories of this exact shape. Feeding back the same kind of signals puts the model back on its home turf, and output tends to be more stable. Conversely, if your task has no objective check signal at all, only subjective impressions, the loop pays off far less; run it as plain conversation first and see.
Step four, canary before production. Do not ship to full traffic directly. On a small slice, verify three things: whether pricing matches expectations (API pricing follows the open platform documentation), whether latency stays inside your business tolerance, and whether success rate meets the bar. Scale up only after all three hold steady. On price-performance, article-level reporting puts the cost at roughly one twentieth to one sixtieth of overseas models at comparable capability, with API prices held unchanged; your actual bill is the number that matters.
Route 3: Local Weights and RL Reproduction
The weights are open for download on Hugging Face under the XiaomiMiMo collection at collections/XiaomiMiMo/mimo-v26. Discipline check here: the parameter count is officially unpublished, so hardware requirements and VRAM follow the model cards, and this piece will not invent numbers. Before touching anything, read the model card for VRAM needs, quantized variants and license terms, then assess your compute. For a broader comparison of deployment options, see our local deployment comparison.
The advanced path: if you want to reproduce the training recipe, Xiaomi open-sourced XiaomiMiMo/verl on GitHub. Be precise about what it is: a fork, built on verl 0.9.0.dev from the ByteDance-lineage open-source project (HybridFlow, 23,650 stars upstream), with reproduction code for five Agentic RL environments added on top. It is not a framework Xiaomi wrote from scratch:
| Domain | Task family | Verifier | Launch script |
|---|---|---|---|
| Code | Software engineering | Executable tests | scripts/code/train.sh |
| Cyber | Vulnerability reproduction | Rule checks | scripts/arvo/arvo.sh |
| General | Knowledge work | Rubric-based judging | scripts/general/general.sh |
| Visual | Web development | Visual grading | scripts/design/webdev.sh |
| Music | Symbolic music composition | Rule checks | scripts/design/music.sh |
Supporting resources: the training dataset is open on Hugging Face as MiMo-V2.6-RL-oss; the training model is MiMo-V2.6-Distill-Qwen-9B; official Docker images are provided; and the technical report PDF lives in the MiMo-V2.6-Pro-RL repository on Hugging Face, with the training recipe in Section 7.
On repo mechanics: each launch script reads the variables listed in the env.example file next to it, so configure those before launching. Four of the five environments (Code, Cyber, General, Visual) are driven through two submodules under third_party: mimoagent supplies harnesses, tools, execution environments and graders (a fork of mini-swe-agent, MIT licensed), while uni-agent handles the model gateway and trajectory capture (Apache-2.0). The two submodules do not import each other; the glue lives in the recipes directory, and Music uses neither. Initialize submodules with the git submodule command. The repository is Apache-2.0 licensed, with the LICENSE file as the final word. For a fuller teardown of this repo, see our verl resource piece.
A threshold warning on RL reproduction: this stack is for teams with distributed training experience. Multi-node GPU orchestration, environment images and verifier infrastructure are all mandatory pieces; missing one stalls everything. If you have no GPU cluster but want to learn RL engineering, read the dataset and Section 7 of the report first rather than forcing a training run. For a systematic comparison of RL frameworks, see our framework review; if you want general fine-tuning without RL, the general fine-tuning SOP is the better fit.
One boundary note on going local: if the motivation is only "data stays in-house", run the numbers first. GPU procurement, power, operations and staffing for self-hosting often exceed the cost of calling the API behind a private-data agreement. Local wins when data sensitivity is too high for any agreement to cover, or when you plan to train on top of the open weights yourself.
Pitfall Quick Reference
| Pitfall | Symptom | Fix |
|---|---|---|
| Product confusion | Treating MiMo-Code as the MiMo-V2.6 entry point | One is a terminal coding assistant, the other an omnimodal model family; check the release line |
| Wrong model pick | Using Pro for trivial tasks, budget blown | Route light traffic to Flash, reserve Pro for hard tasks |
| Key leakage | Keys hardcoded in repos or logs | Environment variables plus a secrets manager; revoke and rotate on leak |
| No canary | Straight to full production, latency and cost both spike | Small-traffic validation of price, latency and success rate first |
| Agent infinite loop | Uncapped correction rounds, runaway token spend | Set a max-round and budget circuit breaker |
| License neglect | Assuming open source means unrestricted commercial use | Model cards and the repository LICENSE file are the final word |
Pre-Launch Checklist
- Model version decided: Pro or Flash, with the switching strategy written down
- Key hygiene in place: not committed, isolated per environment, rotatable
- Request parameters follow the open platform docs, nothing coded from memory
- Agent loop has objective check signals and a cap on correction rounds
- Canary complete: price, latency and success rate verified on small traffic
- Multimodal input format validated against docs, screenshot feedback path tested
- For local deploys, VRAM per the model card with headroom to spare
- License compliance confirmed against model cards and LICENSE files
- Trajectories and logs persisted, reproducible and evaluable
FAQ
Q1: What is the parameter count of MiMo-V2.6, and can my GPU run it?
A1: The parameter count is officially unpublished, so any specific number is fabrication. Hardware requirements and VRAM follow the Hugging Face model cards; check them before you start and pick a quantized variant if needed.
Q2: How do I choose between Pro and Flash, and is running Pro for everything okay?
A2: It works, but it is wasteful. Pro pays off on complex reasoning, software engineering and long-horizon agent tasks; Flash wins on speed and cost for high-frequency lightweight work. Keep both in the model list and switch as needed.
Q3: How is the API priced, and is it expensive compared with overseas models?
A3: Pricing follows the open platform documentation. Article-level reporting puts it at roughly one twentieth to one sixtieth of overseas models at comparable capability, with API prices held unchanged; your actual bill depends on your usage.
Q4: What do I need to reproduce the RL training?
A4: A GPU cluster and distributed training experience. Xiaomi's XiaomiMiMo/verl provides reproduction scripts for five environments, plus the training dataset, Docker images and the recipe in Section 7 of the technical report; missing any piece will stall you.
Q5: What is the relationship between MiMo-V2.6 and MiMo-Code?
A5: None directly. MiMo-Code is Xiaomi's terminal coding assistant from an earlier cycle, while MiMo-V2.6 is an omnimodal model family. Different product lines, different integration paths; do not conflate them when choosing.