> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# Run MiMo V2.6 locally — Xiaomi's multimodal agent model

> Run MiMo V2.6 locally — Xiaomi's 1.02T MoE with 42B active, native multimodal (text/image/video/audio), 1M context, MIT license. The 9B distill fits a single GPU.

> [!NOTE]
>
> 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.

> [!TIP]
>
> Already running a MiMo variant? [Register it with Tokios](/setup/register-model.md) to reach it as `https://api.tokios.com` from any client.

## The MiMo V2.6 lineup

| Variant | Total params | Active params | Context | Best for | Hardware |
| - | - | - | - | - | - |
| **Pro** | 1.02T | 42B | 1M | Difficult coding, long-horizon planning, cybersecurity, multi-tool orchestration | Multi-GPU server (\~520 GB+) |
| **Flash** | 309B | 15B | 1M | High-volume automation, cost-sensitive agent loops | High-memory system (\~160 GB+) |
| **Distill** | 9B | 9B (dense) | 1M | Local experiments, education, single-GPU work | Single 24 GB GPU |

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](/concepts/how-inference-works.md)):

* 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](/concepts/kv-cache-and-context.md) for your context length and concurrency on top of the weights.

## Run it locally

**vLLM — Pro (multi-GPU server)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
vllm serve XiaomiMiMo/MiMo-V2.6-Pro-RL \
  --tensor-parallel-size 8 \
  --trust-remote-code
```

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](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL) before you standardize. See [vLLM remote access](/guides/vllm-remote-access.md).

**vLLM — Flash (high-memory server)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
vllm serve XiaomiMiMo/MiMo-V2.6-Flash-MOPD \
  --tensor-parallel-size 4 \
  --trust-remote-code
```

Budget \~160 GB+ of combined VRAM. A community NVFP4 build ([`ProCreations/MiMo-V2.6-Flash-RL-NVFP4`](https://huggingface.co/ProCreations/MiMo-V2.6-Flash-RL-NVFP4)) is available for Blackwell GPUs and may reduce the memory footprint further. Confirm against the model card before serving. See [vLLM remote access](/guides/vllm-remote-access.md).

**SGLang — Pro or Flash**

```bash Pro theme={"theme":{"light":"github-light","dark":"css-variables"}}
sglang serve XiaomiMiMo/MiMo-V2.6-Pro-RL \
  --tp 8 \
  --trust-remote-code
```

```bash Flash theme={"theme":{"light":"github-light","dark":"css-variables"}}
sglang serve XiaomiMiMo/MiMo-V2.6-Flash-MOPD \
  --tp 4 \
  --trust-remote-code
```

SGLang is an alternative to vLLM with comparable performance characteristics. Adjust `--tp` to match your GPU count. See [SGLang remote access](/guides/sglang-remote-access.md).

**llama.cpp — Distill (single GPU)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
llama serve -hf XiaomiMiMo/MiMo-V2.6-Distill-9B
```

The 9B Distill fits a single 24 GB GPU at 4-bit. Confirm the exact HuggingFace repo name on [XiaomiMiMo's HuggingFace page](https://huggingface.co/XiaomiMiMo) — community GGUF builds may also appear once the model is released. See [llama.cpp remote access](/guides/llama-cpp-remote-access.md).

> [!WARNING]
>
> 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](https://huggingface.co/XiaomiMiMo) 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.

| Property | Pro | Flash | Distill |
| - | - | - | - |
| Hugging Face | [`XiaomiMiMo/MiMo-V2.6-Pro-RL`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL) | [`XiaomiMiMo/MiMo-V2.6-Flash-MOPD`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-MOPD) | Check [XiaomiMiMo](https://huggingface.co/XiaomiMiMo) |
| Parameters | 1.02T total / **42B active** | 309B total / **15B active** | 9B (dense) |
| Architecture | Sparse MoE | Sparse MoE | Dense (Qwen-based distill) |
| Context window | 1M (1,048,576) | 1M (1,048,576) | 1M (1,048,576) |
| Max output tokens | 128K | 128K | 128K |
| Input modalities | Text, image, video, audio | Text, image, video, audio | Text, image, video, audio |
| Output | Text | Text | Text |
| License | MIT | MIT | MIT |
| Community quants | — | [`ProCreations/MiMo-V2.6-Flash-RL-NVFP4`](https://huggingface.com/ProCreations/MiMo-V2.6-Flash-RL-NVFP4) | — |
| Best for | Difficult coding, long-horizon planning, cybersecurity, multi-tool orchestration | High-volume automation, cost-sensitive agent loops | Local experiments, education, single-GPU work |

Sources: [`XiaomiMiMo/MiMo-V2.6-Pro-RL`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL), [`XiaomiMiMo/MiMo-V2.6-Flash-MOPD`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-MOPD).

> [!NOTE]
>
> 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](/concepts/kv-cache-and-context.md) 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.

| Benchmark | Pro | Flash |
| - | - | - |
| Coding (HumanEval-style) | Vendor-reported | Vendor-reported |
| Agentic tasks | Vendor-reported | Vendor-reported |
| Multimodal understanding | Vendor-reported | Vendor-reported |

Specific scores will be added once independent evaluations are published. For now, compare Pro and Flash against [Kimi K2.6](/models/kimi.md) and [Qwen3.8-27B](/models/qwen3.8.md) on your own workload.

## Hardware fit

Verdicts assume 4-bit quantization at a modest context length.

| Target | Pro (\~520 GB+) | Flash (\~160 GB+) | Distill (\~6 GB) |
| - | - | - | - |
| RTX 4070 Ti Super / 4080 (16 GB) | Won't fit | Won't fit | Comfortable |
| RTX 3090 / 4090 (24 GB) | Won't fit | Won't fit | Comfortable |
| RTX 5090 (32 GB, Blackwell) | Won't fit | Won't fit | Comfortable, long context |
| 2× RTX 4090 (48 GB pooled) | Won't fit | Tight, short context | Comfortable |
| 4× RTX 4090 (96 GB pooled) | Won't fit | Workable | Comfortable |
| Apple Silicon (64 GB unified) | Won't fit | Won't fit | Comfortable |
| Apple Silicon (192 GB+ unified) | Won't fit | Workable | Comfortable |
| DGX Spark (128 GB unified) | Won't fit | Tight | Comfortable |
| 2× DGX Spark (256 GB pooled) | Won't fit | Comfortable | Comfortable |
| Multi-GPU server (8× H100, 640 GB) | Comfortable | Comfortable | Comfortable |

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?](/guides/model-fit.md).

> **[Picked a model? Connect it](/quickstart.md)**
>
> 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](https://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:

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'
```

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX
```

```bash Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX
```

Then **approve** the device on the **Setup** or **Connectors** tab.

**3. Register a deployment**

In the [Models](https://tokios.com/console/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](https://tokios.com/console/keys) tab, click **Create key**. Copy the `sk-tok-…` key now — it is shown only once.

### Call it from anywhere

```bash curl (OpenAI-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mimo-flash",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Analyze this codebase and propose a refactoring plan."}
    ]
  }'
```

```bash Claude Code (Anthropic-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model mimo-flash
```

## 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](/concepts/how-inference-works.md).
* **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](/setup/supported-backends.md).

## FAQ

> **How much VRAM does MiMo V2.6 Pro need?**
>
> \~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.

> **Can I run MiMo V2.6 on a single GPU?**
>
> 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.

> **Is MiMo V2.6 open source?**
>
> 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.

> **What is the difference between Pro, Flash, and Distill?**
>
> **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.

> **How does MiMo V2.6 compare to Kimi or Qwen?**
>
> MiMo V2.6 Pro and Flash are MoE models in the same scale class as [Kimi K2.6](/models/kimi.md) (1T total, 32B active) but with native audio input and a larger context window. The Distill at 9B competes with [Qwen3.8-27B](/models/qwen3.8.md) and [Muse Glimmer](/models/muse-glimmer.md) for single-GPU work, though it is smaller. Compare them on your own workload — the MIT license makes all of them easy to test.

> **Can I use MiMo V2.6 with a coding agent?**
>
> 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](/guides/coding-agent-compatibility.md) for the matrix and [coding agents with local models](/guides/coding-agents-local-models.md) for setup.

> **What audio formats does MiMo V2.6 accept?**
>
> 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?](/guides/model-fit.md)**
>
> Size the model and context to your VRAM or unified memory.

> **[Coding agents with local models](/guides/coding-agents-local-models.md)**
>
> Point Claude Code, Cline, or Aider at a model you host.

> **[Kimi](/models/kimi.md)**
>
> Moonshot AI's 1T MoE family — comparable scale, different license.

> **[Qwen3.8](/models/qwen3.8.md)**
>
> Alibaba's dense 27B vision-language model, also Apache-2.0.

> **[Reach it from your phone](/use-cases/local-model-on-your-phone.md)**
>
> Use an always-on local model when you are away from the machine.

> **[Quickstart](/quickstart.md)**
>
> Pair a connector and register your first model end to end.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.