# mimo-v2.6 on Ollama: Xiaomi's 9B agent-coding model, first look

Xiaomi MiMo's MiMo-V2.6-Distill-Qwen-9B has landed on the Ollama library as mimo-v2.6 — a 9B fine-tune of Qwen3.5-9B for code and agent workflows. Here's what it needs and how to run it.

Published 2026-11-03 · https://inpherio.co.uk/blog/mimo-v2-6-on-ollama-xiaomi-s-9b-agent-coding-model-first-look

Key points:
- mimo-v2.6 is Xiaomi MiMo's MiMo-V2.6-Distill-Qwen-9B — a 9B model fine-tuned from Qwen3.5-9B for code and agent workflows, on Ollama from 3 November 2026 under MIT.

A new 9B model appeared on the [Ollama library](https://ollama.com/library/mimo-v2.6) today: **mimo-v2.6**, the tag for Xiaomi MiMo's MiMo-V2.6-Distill-Qwen-9B. It's a fine-tune of Qwen3.5-9B, and the pitch is code and agent workflows, with vision, tools and thinking all listed as capabilities. Here's what it is, what hardware it wants, and whether it earns a spot on your disk.

## What is mimo-v2.6?

mimo-v2.6 is the Ollama tag for **MiMo-V2.6-Distill-Qwen-9B**, Xiaomi MiMo's 9B model for code and agent workflows. It's fine-tuned from Qwen3.5-9B on MiMo-generated data — so a Qwen base distilled into Xiaomi's agent-focused training pipeline.

Ollama lists three capabilities: **vision, tools and thinking**. That means it takes text and image input, supports tool calling, and can produce reasoning traces before answering.

It's released under the **MIT licence**, so it's free to run, modify and build on, including commercially.

There's a single size on the library: **9b**, with both `:latest` and `:9b` tags pointing to the same model. Ollama lists the download as **6.6–8.7GB** — a range that typically reflects quantisation, though the page doesn't spell out which quants the tags cover. No smaller variants are listed.

## What it's for (and what it's not for)

The readme names four use cases:

- **Software development** — understand unfamiliar code, investigate failures, and draft fixes.
- **Agent workflows** — work through multi-step tasks when connected to tools.
- **Visual coding** — use screenshots or interface references to guide an implementation.
- **Security analysis** — examine code and explain potential vulnerabilities.

The 256K context window matters for all four: it means the model can work across long files, documentation and extended agent task histories without you having to chunk everything first. Agent loops in particular burn context fast — every tool call and result lands in the history — so a big window is genuinely useful, not just a spec-sheet number.

Be clear about what this isn't. The pitch is squarely **agentic coding**. This is not positioned as a general chat model, and the readme doesn't claim creative writing or summarisation among its uses. If you want a local assistant for everyday questions, this isn't the model you're shopping for.

One more caveat: all quality numbers so far are Xiaomi's own. We've seen no independent benchmarks as of release day. Treat the evaluation table below as vendor-reported until third parties weigh in.

## Xiaomi's numbers: where it beats its Qwen3.5-9B base

Xiaomi reports MiMo-V2.6-Distill-Qwen-9B against its own base, Qwen3.5-9B, on five agentic benchmarks:

| Benchmark | Metric | Qwen3.5-9B | MiMo-V2.6-Distill-Qwen-9B |
| --- | --- | ---: | ---: |
| SWE Verified | avg@3 | 60.0 | 61.1 |
| SWE Pro | avg@3 | 32.0 | 44.6 |
| AutomationBench v1.0.6 | avg@1 | 5.0 | 30.3 |
| Terminal Bench 2.1 | avg@1 | 27.0 | 37.1 |
| Toolathlon-Verified | avg@1 | 25.9 | 35.2 |

Source: [Ollama library page](https://ollama.com/library/mimo-v2.6), citing Xiaomi's [model card](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B) and the [MiMo-V2.6 technical report](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL/blob/main/MiMo_V2_6_technical_report.pdf).

How to read this:

- **SWE Verified: 61.1 vs 60.0** — a small gain on the standard software-engineering benchmark. Raw coding ability is roughly unchanged.
- **SWE Pro: 44.6 vs 32.0** — the biggest jump on a coding benchmark, on the harder professional subset.
- **AutomationBench: 30.3 vs 5.0** — a dramatic gain, though a base score of 5.0 suggests Qwen3.5-9B was barely functional on this benchmark to begin with. Impressive, but read the denominator.
- **Terminal Bench 2.1: 37.1 vs 27.0** and **Toolathlon-Verified: 35.2 vs 25.9** — solid, consistent gains on tool-use and terminal-agent tasks.

The pattern is clear: **the distillation mainly buys agent and tool-use competence, not raw coding ability**. If you're only doing single-file code completion, the base Qwen3.5-9B may serve you just as well at a similar memory cost. If you're running an agent that loops tools over a repo, that's where Xiaomi claims the difference.

(Live on Inpherio: https://inpherio.co.uk/models/qwen3.5:9b)

## Memory and hardware: what you need to run it

Both tags are the same download: **6.6–8.7GB**, with a 256K context window and text+image inputs.

The rule of thumb we use across these posts (see [LM Studio vs Ollama](/blog/lm-studio-vs-ollama-which-one-should-you-actually-install)): budget roughly the download size in RAM or VRAM, plus headroom for context. The KV cache grows with context length, and a 256K window can add several gigabytes if you actually fill it — the model weights are only part of the bill at long context.

Applying that rule of thumb, the realistic hardware classes look like this:

- **12GB gaming GPU** (RTX 3060/4070 class) — should run it comfortably at modest context. The sensible floor.
- **16GB Mac** — comfortable at everyday context lengths; the unified memory handles the weights fine.
- **8GB card** — tight. It'll load, but expect spilling to system RAM and slower token rates.
- **16GB laptop** — workable but slow; 32GB machines are comfortable.
- **Long-context work near 256K** — you want 24GB VRAM or a 32GB+ Mac. At that point the weights are the cheap part.

Vision support adds its own cost: image inputs consume memory too. A screenshot is cheap; batched or high-resolution images aren't free. If you're feeding it interface references for visual coding, keep the images reasonable.

## How to run it locally

One command:

```sh
ollama run mimo-v2.6
```

The `:latest` and `:9b` tags are identical, so `ollama run mimo-v2.6:9b` gets you the same model.

Because it supports **tools and thinking**, it works with Ollama's tool-calling API out of the box — relevant if you're wiring it into an agent loop rather than chatting. Image input works the same way as other vision models on Ollama: drop an image into the chat or send it via the API.

As of release day, the Ollama page is the only documented route we've seen — no LM Studio, llama.cpp or vLLM instructions on it. Check the [model card](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B) for GGUFs and other engine support. If you're weighing engines generally, our [LM Studio vs Ollama](/blog/lm-studio-vs-ollama-which-one-should-you-actually-install) and [vLLM vs Ollama](/blog/vllm-vs-ollama-which-inference-engine-should-you-actually-run) posts cover the trade-offs.

## How it sits among the other 9B models you can run locally

At 9B with vision, tools and thinking, it lands in a busy size class. Two alternatives we've covered recently are worth a mention — with the caveat that we're drawing on each model's published page and our earlier coverage, not re-testing anything head-to-head today.

**Bonsai 2** ([our hands-on](/blog/bonsai-2-on-ollama-a-27b-model-that-fits-in-8-3gb)) is Prism ML's family of vision models with tools and thinking, and its 9b variant is a 3.2GB download with a 262K context window under Apache 2.0. If your job is general vision work rather than agentic coding, it's the lighter pick — less than half the download of mimo-v2.6.

**Clef Flash** ([our hands-on](/blog/clef-flash-on-ollama-cloudflare-s-9b-decision-model-hands-on)) is Cloudflare's 9B decision model — it doesn't chat or write code at all, it scores options and returns a call. Different job entirely, but it shows how much the 9B class has specialised: same rough size, completely different outputs.

(Live on Inpherio: https://inpherio.co.uk/models/bonsai-2:9b)

The honest read on mimo-v2.6: if **agentic tool use** is the job, the AutomationBench and Terminal Bench gains over its base are the whole pitch. If you want a general-purpose model at this size, the alternatives above are equally reasonable — and we haven't run any of these against each other ourselves, so treat this as orientation, not a verdict.

## Worth a spot on your disk?

If you run local coding agents — anything that loops tools over a repo — this is exactly the kind of small model that makes agents affordable to iterate with. The agent-benchmark gains over Qwen3.5-9B are the reason to pick it over the base; a 9B that's actually competent with tools is more useful than a marginally better coder that isn't.

If you just want a local chat or coding model, the base Qwen3.5-9B or a general-purpose option like Bonsai 2 are equally reasonable choices.

Caveats for now: vendor-reported numbers only, one size, and Ollama as the only documented engine on release day. Worth revisiting when independent benchmarks appear.

And if you've got a 12GB GPU or a 16GB+ Mac sitting idle, this is also the kind of model hosts can serve — a 9B with tool support fits that hardware class well. See [providers](/providers) if that's you.

## FAQ

**What is mimo-v2.6 on Ollama?** It's the Ollama tag for MiMo-V2.6-Distill-Qwen-9B, Xiaomi MiMo's 9B model for code and agent workflows, fine-tuned from Qwen3.5-9B and released under MIT.
