Field SOP
Field SOP

MiMo-V2.6 Integration SOP: Desktop, API and Local Weights

A hands-on SOP for wiring MiMo-V2.6 into your workflow along three routes of rising effort: (1) the MiMo Desktop client (install, sign in or plug in your own API key, switch MiMo-V2.6-Pro/Flash in the model list, UltraSpeed mode, screenshot-feedback iteration); (2) the MiMo open-platform API (create an app for a key, pass model name, messages, tools and multimodal inputs; for agent tasks, wire environment logs, test pass rates, screenshots and verifier feedback into an execute-check-correct loop; validate price, latency and success rate on a small traffic slice before production); (3) local weights (download from the HF collection collections/XiaomiMiMo/mimo-v26; parameter counts are unpublished, so hardware floors defer to the model cards; for RL reproduction, go through the five environment scripts in XiaomiMiMo/verl). Includes a pitfall table and a pre-launch checklist; API pricing defers to the platform documentation.

Published September 27, 202610 min read
<!-- mimo-v2-6-integration-sop | sop | MiMo-V2.6 Integration SOP: Desktop, API and Local Weights -->

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

RouteBest forBarrierCost structureControl
MiMo Desktop clientIndividuals, light daily tasksLowest, install and goSubscription or your own API keyLow, configured in UI
Open platform APIDevelopers, teams embedding into productsMedium, requires codePay per token, see open platform docsMedium, you pick tools and params
Local weightsTeams with GPUs, researchers reproducing RLHighestHardware and ops costHighest, 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:

  1. Download and install. Grab the client for your OS from the official channel and install it the normal way. No special dependencies.
  2. 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.
  3. 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.
  4. 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.
  5. 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:

json
{
  "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 signalTask typeHow to feed it
Environment logsCommand execution, deploymentReturn the raw failure log, not just an error summary
Test pass rateSoftware engineeringAfter the test run, return both passing and failing cases
ScreenshotsFrontend, UI, designReturn render screenshots so the model self-checks against the requirement
Verifier outputTasks with clear acceptance criteriaStructure 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:

DomainTask familyVerifierLaunch script
CodeSoftware engineeringExecutable testsscripts/code/train.sh
CyberVulnerability reproductionRule checksscripts/arvo/arvo.sh
GeneralKnowledge workRubric-based judgingscripts/general/general.sh
VisualWeb developmentVisual gradingscripts/design/webdev.sh
MusicSymbolic music compositionRule checksscripts/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

PitfallSymptomFix
Product confusionTreating MiMo-Code as the MiMo-V2.6 entry pointOne is a terminal coding assistant, the other an omnimodal model family; check the release line
Wrong model pickUsing Pro for trivial tasks, budget blownRoute light traffic to Flash, reserve Pro for hard tasks
Key leakageKeys hardcoded in repos or logsEnvironment variables plus a secrets manager; revoke and rotate on leak
No canaryStraight to full production, latency and cost both spikeSmall-traffic validation of price, latency and success rate first
Agent infinite loopUncapped correction rounds, runaway token spendSet a max-round and budget circuit breaker
License neglectAssuming open source means unrestricted commercial useModel 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.

This article is AI-assisted and human-edited. Last updated: 2026-09-27

FAQ

What is the parameter count of MiMo-V2.6, and can my GPU run it?
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.
How do I choose between Pro and Flash, and is running Pro for everything okay?
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.
How is the API priced, and is it expensive compared with overseas models?
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.
What do I need to reproduce the RL training?
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.
What is the relationship between MiMo-V2.6 and MiMo-Code?
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.

Related

Field SOP

8GB VRAM, 4K Output: FLUX 3 Klein's Three Pitfalls

A practical path to running FLUX 3 Image Klein on consumer Nvidia cards, with three pitfalls found in the field; every command and filename comes from the official repositories or from third-party recipes that were actually run. The main line is ComfyUI. The repository black-forest-labs/flux-3-image-klein-comfy is gated, marked gated auto in the Hugging Face API, so an anonymous request returns 401 with x-error-code GatedRepo; sign in, accept the terms, then run hf auth login. Next, hf download pulls four files: the distilled int8 transformer at 5,827,874,779 bytes, the Qwen3-VL-4B int8 text encoder at 4,858,559,240 bytes, the w4a8 prompt upsampler at 6,724,090,780 bytes and the FLUX.2 VAE at 336,211,292 bytes. Start with python main.py, open Workflow and then Browse Templates, search FLUX 3 and pick distilled Text to Image with template id image_flux3_klein_distilled_t2i; the template defaults to 1024 by 1024, euler with the simple scheduler, 16 steps and CFG 1, both text-encoder loaders set to type flux3, and the upsampler switch left on. Then the three pitfalls. First, following the card's example and downloading the int8 upsampler at 9,748,113,996 bytes, about 9.08GiB, brings the four files to 19.343GiB, which will not fit a 16GB card, while the ComfyUI v0.41.2 distilled template actually loads the w4a8 file, 2.816GiB smaller. Second, the model card says the editing templates have no upsampler branch and that you should run your own LLM and paste the caption, yet the v0.41.2 editing template does contain an upsampler branch behind a switch that is off by default, a TextGenerate node with the W4A8 loader and an image-editing system prompt, so either route works. Third, running the model without an upsampler gives unstable results in editing and Ref2Image; the card states plainly not to use the model without a prompt upsampler. Memory budget: 11.2GB in BF16, 5.6GB in FP8, INT8 running on 8GB RTX cards, and NVFP4 aimed at data centres. All speed figures are vendor-reported: about 4 seconds per 1MP image on an RTX 5090 and under 9 seconds on an RTX 4070 with the distilled INT8 build, under 0.6 seconds in NVFP4 on a GB300, with a served LoRA adding about 5 percent. Resolution reaches 4K with width and height in multiples of 16, up to 10 reference images are accepted, and official defaults are 16 steps with no guidance for the distilled checkpoint and 50 steps at CFG 3.5 for the base. The Diffusers route is described only as far as is verifiable - it works, and BFL ships reference inference code including a Gradio demo with bounding-box control, with the repository README as the authority; no class names or parameters are invented here. Before commercial use, check the FLUX Kommunity License: free commercial use for individuals and companies under 5 million dollars in annualized revenue, free research and non-commercial use, and self-hosted licensing or the API beyond that, with the LICENSE text governing the details.

Oct 17, 202610 min read
Field SOP

Can One GPU Run Matrix-Game 4.0? A Local Deploy SOP

A nine-step SOP for running Matrix-Game 4.0 locally on a single GPU, with every command and flag taken verbatim from the v4 subdirectory README (repository: github.com/SkyworkAI/Matrix-Game, file Matrix-Game-4/README.md). Step 1, align on requirements: model inference needs Linux, an NVIDIA GPU and Python 3.12 together, the reference A100 80 GB deployment uses PyTorch 2.12.0 / CUDA 13.2, and the repo ships a dedicated RTX 5090 runtime that does not auto-detect hardware, so the matching preset must be selected explicitly; the browser demo needs a Linux server that also builds the game and GStreamer pipeline while the Safari/Chrome client needs no GPU; standalone play and recording need macOS or Linux plus CMake, C++20, SDL2 and FFmpeg, with the legacy Windows entry retained but not validated for feature parity; and weights and assets are not shipped in the repo, so budget extra space for the Hugging Face Hub cache. Step 2, install inside the Matrix-Game-4/ subdirectory or everything after is wrong: git clone, cd Matrix-Game/Matrix-Game-4, python3.12 -m venv .venv and source .venv/bin/activate, then pip install torch==2.12.0 torchvision==0.27.0 --index-url https://download.pytorch.org/whl/cu132 as a matched pair, then pip install -e '.[inference,server,download,test]' with all four extras; FlashAttention is optional and only rtx5090-sage needs SageAttention while plain rtx5090 uses PyTorch SDPA. Step 3, downloads come as two manifests, game assets and model weights, pinned to revision 4419accdb7bb7881234c5914de8cd915266e0325 with --scene switchable across castle, racing and all, and one server process supporting only one scene model; the downloader verifies size and SHA256 against the manifests so interrupted runs can simply restart, shared T5/tokenizer and Wan VAE pull automatically from the official base, and matrix-game verify rechecks an installed scene. Step 4, offline rendering proves the model produces output: matrix-game render --scene ancient-egypt --input lowpoly.mp4 --resources resources --preset realtime --prompt-mode fixed --output outputs/egypt, where the input is a low-poly proxy stream rather than real footage and the output is rendered.mp4 plus a configuration report with FPS and frame count preserved; the three presets matter - realtime is for A100, RTX 5090 switches to rtx5090, and quality is slower yet is exactly the default when --preset is omitted. Step 5, play and record locally without loading a model: bash scripts/build_game.sh then bash scripts/play.sh --scene ancient-egypt, giving the two shooter scenes a 48 FPS, 2x simulation-time demo mode with F9 recording and Escape menu, and MATRIX_GAME_DATA_DIR overriding the default data directory; racing uses build_racing.sh with 1x simulation time, and the browser demo does not enable the shooters' 2x mode either, advancing 1/--fps seconds per captured frame. Step 6, the browser demo splits server and client: mediamtx configs/mediamtx.yml in one terminal and CUDA_VISIBLE_DEVICES=0 bash scripts/serve.sh --scene ancient-egypt --resources resources --preset realtime --fps 40 in another, then open http://127.0.0.1:8025/, with --reference-only testing controls, HUD, audio and transport without loading a model; --fps 40 is a capture cadence target, not a throughput or latency guarantee. Step 7, the two RTX 5090 presets: rtx5090 needs no extra installation while rtx5090-sage requires building SageAttention 2.2.0 with the supplied CUDA-graph patch and CUDA 13.2 at git checkout eb615cf6cf4d221338033340ee2de1c37fbdba4a; both reuse the same scene checkpoints and shared resources, converting DiT block linear weights to FP8 at load with activations quantized during inference while embeddings and the output head stay BF16, and startup warms kernels and captures CUDA graphs so the first launch is slower than steady state. Step 8, acceptance in two forms: a keypress producing a picture in the browser demo (officially about under 150 ms, not independently reproduced) or an offline render turning a low-poly video into a finer output, with the three performance accounts written side by side (official 480p 60 FPS, 83 FPS and 18.5 GiB; the project page panel still at 0; and the README's about 38-39 FPS on an A100 at 864 x 480), remembering that model throughput, pipeline throughput, presentation frame rate and end-to-end latency are four different things. Step 9, six pitfalls: one process supports one session and one scene model; it binds to loopback by default and must not be exposed to the internet, since the official statement calls it a trusted single-user demo rather than a public cloud-gaming service; --fps 40 is not a throughput guarantee; Windows is unvalidated; disk must accommodate the Hub cache; and VRAM splits into an A100 80 GB reference tier and an RTX 5090 consumer tier with the 5080 and 5070 still pending.

Oct 16, 202610 min read
Field SOP

Run MiniCPM-V 4.7 on Your Phone: Three Paths

A hands-on SOP for running MiniCPM-V 4.7 from phone to desktop in three routes (all figures as of October 15, 2026, official pages prevail). First understand two official numbers: the 3 GB is the model's runtime memory footprint (the MoE-SSD mechanism keeps 35B expert weights on flash and streams them in on demand), not a device-RAM floor - the official app hardware table recommends 12 GB+ RAM for 35B-A3B (validated on the iPhone 17 Pro Max) and 4 GB+ for 1B, with smaller devices falling back to a smaller expert cache that runs noticeably slower; 13+ tokens/s is the official documentation figure for the iPhone 17 Pro Max, and other circulating figures (iPad 15+ and the like) are not adopted. Route 1, the official app on phone/tablet (OpenBMB/MiniCPM-V-Apps covers iOS, Android and HarmonyOS: TestFlight public link on iOS, APK from Releases on Android, signed HAP via DevEco on HarmonyOS; the 35B-A3B phone build is about 16.6 GB - main file plus 40 expert shards plus the vision module; 1B about 1.8 GB; the only fully offline route; pitfalls: slow storage throttles decoding, shards must match or the consistency check refuses to load, and the phone NPU stays unused short-term - the app runs the stock llama.cpp path). Route 2, desktop self-build with llama.cpp-omni for LES acceleration (the official LES link points to OpenBMB/llama.cpp-omni, a fresh repo created October 13 with 16 stars; the community tc-mb same-named repo has 291 stars, full docs and prebuilt packages - both share the same code lineage; verified commands: cmake -B build and cmake --build --target llama-omni-server/llama-omni-cli; GGUF weights in the official quantization repos on HF/ModelScope; honest limits: the README quick start targets the MiniCPM-o 4.5 full-duplex voice pipeline, 4.7 loading details are untested by this site and follow the official README). Route 3, the Ollama shortcut (the official library still lists only 4.6 as of October 15; the OpenBMB publisher page openbmb/minicpm-v4.7 runs today via ollama run - 1b about 1.8 GB, 35b-a3b Q4_K_M about 22 GB and the default latest tag, so small-memory machines must specify :1b explicitly; this route runs whole-model quants with no MoE-SSD, so "3 GB runs 35B" does not apply). One acceptance test for all three: ask about a local image and get a relevant answer. Division of labor with the same-batch open-source piece: that one covers capability and ecosystem, this one only covers getting it running. Repos: github.com/OpenBMB/MiniCPM-V and github.com/OpenBMB/MiniCPM-V-Apps.

Oct 15, 202610 min read