Skip to main content
Last verified: 2026-10-14
MiMo V2.6 is Xiaomi’s multimodal agent model family, released September 22, 2026 under the MIT license. The lineup spans 3 variants — a 1.02-trillion-parameter flagship (Pro), a 309B production workhorse (Flash), and a 9B distill that fits a single consumer GPU — all sharing native multimodal input (text, images, video, and audio), up to 128K output tokens, and a 1M-token context window. The headline is the combination of scale, modality coverage, and license. Pro and Flash are sparse mixture-of-experts architectures that need serious multi-GPU hardware, but the 9B Distill brings the family down to a single 24 GB GPU — the first time a model in this lineage runs on consumer hardware you probably already own.
Already running a MiMo variant? Register it with Tokios to reach it as https://api.tokios.com from any client.

​
The MiMo V2.6 lineup

All 3 variants are MIT licensed, accept text, image, video, and audio input, produce text output, and support up to 128K output tokens.

​
Which MiMo should you run?

Your hardware decides:
  • Single 24 GB GPU (RTX 3090, 4090, or similar) — run the Distill. It is a 9B dense model distilled from the Qwen architecture, and it is the only MiMo variant that fits consumer hardware without offloading. Start here for experiments, learning, and light agent work.
  • High-memory system (192 GB+ unified memory, or 2+ datacenter GPUs) — run Flash. At 309B total with 15B active per token, it is the cost-effective choice for production agent loops where you need multimodal input and long context without Pro’s hardware floor.
  • Multi-GPU server (4× H100-class or equivalent) — run Pro. The 1.02T flagship is built for the hardest tasks: difficult coding, cybersecurity analysis, and multi-tool orchestration across long horizons.
The transparent sizing math for MoE models — memory scales with total parameters, not active ones, because every expert weight stays resident even though routing activates only a fraction per token (see how inference works):
  • Pro: 1.02T × ~0.5 bytes at 4-bit ≈ ~510 GB of weights, ~520 GB+ with overhead
  • Flash: 309B × ~0.5 bytes at 4-bit ≈ ~155 GB of weights, ~160 GB+ with overhead
  • Distill: 9B × ~0.5 bytes at 4-bit ≈ ~4.5 GB of weights, ~6 GB as shipped
Add KV cache for your context length and concurrency on top of the weights.

​
Run it locally

Tensor-parallel across every GPU in the box. Budget ~520 GB+ of combined VRAM for the 4-bit weights plus KV cache. vLLM serves an OpenAI-compatible API on http://127.0.0.1:8000/v1 — that is what the Tokios connector points at. Confirm the flags for your vLLM version against the model card before you standardize. See vLLM remote access.
Do not invent repo names or CLI flags for MiMo variants. The Pro and Flash repos above are confirmed. The Distill repo name is a best guess based on Xiaomi’s naming pattern — verify it on XiaomiMiMo’s HuggingFace page before you run it.

​
Variants & specs

Every value below is from Xiaomi’s model cards on Hugging Face. Verify against the model card before you standardize on one. Sources: XiaomiMiMo/MiMo-V2.6-Pro-RL, XiaomiMiMo/MiMo-V2.6-Flash-MOPD.
MiMo V2.6 is released under the MIT license, which is permissive and carries no acceptable-use policy or user-count threshold. Read the LICENSE file on the model card before you build a commercial product on it.

​
Capabilities

  • Native multimodal input. Text, image, video, and audio go in; text comes out. This is not a bolt-on vision module — it is part of the base architecture across all 3 variants.
  • 128K output tokens. Long enough for extended reasoning, repository-scale code generation, and detailed analysis without truncation.
  • 1M context window. Large enough for repository-scale coding sessions, long documents, or hours of audio. Budget KV-cache memory on top of the weights when you size a long-context deployment.
  • Tool calling and agentic workflows. All variants support tool use and multi-step agent loops. When you serve with vLLM or SGLang, enable the tool-call parser the model card recommends so tools requests work through your endpoint.
  • MIT license. Permissive across all 3 variants — no acceptable-use policy, no user-count threshold.

​
Benchmarks

Xiaomi-reported, on a model released recently. No independent reproduction exists yet — treat these as the vendor’s claims until third-party evaluations appear. Specific scores will be added once independent evaluations are published. For now, compare Pro and Flash against Kimi K2.6 and Qwen3.8-27B on your own workload.

​
Hardware fit

Verdicts assume 4-bit quantization at a modest context length. The Pro model needs ~520 GB+ of combined VRAM — that is a 4× H100 or 8× A100 system, or a large pool of consumer GPUs with aggressive quantization. Flash at ~160 GB fits a high-memory Mac Studio, 2 DGX Sparks, or a 4-GPU server. The Distill at ~6 GB fits any modern GPU with 24 GB of VRAM and still leaves headroom for context. On shared hardware, the Flash and Distill variants compete for the same memory pool as the KV cache at long context lengths. Start at a modest context, measure, then raise it. For the sizing method, see what size model fits your GPU?.

Picked a model? Connect it

One authenticated endpoint at https://api.tokios.com — no inbound ports, about 5 minutes.

​
Connect it with Tokios

An always-on local model is one you want to reach when you are not at the machine running it. Tokios sits after your runtime: it does not download the model or replace vLLM.
1

Keep your local runtime running

Start MiMo V2.6 in vLLM, SGLang, or llama.cpp and leave it bound to loopback.
2

Pair the Tokios connector

Sign in at tokios.com/console, open the Setup tab, and click Start pairing to get a one-time claim code (TKS-XXXX-XXXX). Run the installer on the machine that runs the model:
Windows
macOS
Linux
Then approve the device on the Setup or Connectors tab.
3

Register a deployment

In the Models tab, register the upstream model id (for example XiaomiMiMo/MiMo-V2.6-Flash-MOPD) under a public deployment name like mimo-flash. Clients send the deployment name in the model field, never the local id — so re-quantizing later changes nothing on the client side.
4

Create an API key

In the Keys tab, click Create key. Copy the sk-tok-… key now — it is shown only once.

​
Call it from anywhere

​
Caveats

  • Pro and Flash are MoE models. All 1.02T (Pro) or 309B (Flash) parameters must fit in memory even though only 42B or 15B are active per token — see how inference works.
  • 1M context is a ceiling, not a target. Long contexts add KV-cache memory on top of the model weights. On shared hardware, that headroom is what the model also uses for inference.
  • Benchmarks are vendor-reported. Xiaomi published them on release day. Wait for independent evaluations before treating the scores as settled.
  • Flash is the practical choice for most production setups. Pro needs ~520 GB+ of combined VRAM — a serious multi-GPU server. Flash at ~160 GB fits a high-memory workstation or a smaller server, and covers most agent-loop workloads.
  • The Distill is a distillation, not the full architecture. It trades MoE scale for single-GPU fit. Expect it to be weaker than Pro and Flash on the hardest tasks, but it is the only variant that runs on consumer hardware.
  • Multimodal input depends on your runtime. Tokios passes image, video, and audio content through to the upstream endpoint — it does not add capabilities your runtime or quantization lacks. Check supported backends.

​
FAQ

~520 GB+ of combined VRAM at 4-bit. The transparent calculation: 1.02T parameters × ~0.5 bytes at 4-bit ≈ ~510 GB of weights, plus overhead for embeddings and metadata. That means a multi-GPU server — 4× H100 (320 GB) is not enough; plan for 8× A100 (640 GB) or equivalent.
Yes — the Distill variant is a 9B dense model that fits a single 24 GB GPU at 4-bit (~6 GB). It is distilled from the Qwen architecture and is the only MiMo variant that runs on consumer hardware. Pro and Flash need multi-GPU systems.
All 3 variants are published under the MIT license, which is permissive and carries no acceptable-use policy or user-count threshold. Note that open weights and open source are not the same thing — the training data and pipeline are not released.
Pro (1.02T total, 42B active) is the flagship for difficult coding, cybersecurity, and long-horizon planning. Flash (309B total, 15B active) is the production workhorse for high-volume agent loops. Distill (9B, dense) fits a single GPU for experiments and education. All 3 share the same multimodal input capabilities and MIT license.
MiMo V2.6 Pro and Flash are MoE models in the same scale class as Kimi K2.6 (1T total, 32B active) but with native audio input and a larger context window. The Distill at 9B competes with Qwen3.8-27B and Muse Glimmer for single-GPU work, though it is smaller. Compare them on your own workload — the MIT license makes all of them easy to test.
Yes — all variants support tool calling and agentic workflows. Whether a specific agent works depends on how your runtime exposes tool calls. See coding agent compatibility for the matrix and coding agents with local models for setup.
Check the model card for the specific audio formats and sampling rates supported. Tokios passes audio content through to the upstream endpoint unchanged — it does not transcode or resample.

What fits your GPU?

Size the model and context to your VRAM or unified memory.

Coding agents with local models

Point Claude Code, Cline, or Aider at a model you host.

Kimi

Moonshot AI’s 1T MoE family — comparable scale, different license.

Qwen3.8

Alibaba’s dense 27B vision-language model, also Apache-2.0.

Reach it from your phone

Use an always-on local model when you are away from the machine.

Quickstart

Pair a connector and register your first model end to end.