MiMo-V2.6-Flash-MOPD, EXL3

Model size: 309B parameters (15B active). The "52B params" figure in the Hugging Face sidebar is not a parameter count: the site counts the packed 16-bit words of the EXL3 format.

Hardware: sized to fit one 128 GB machine. The pack is in the standard EXL3 format, so it is not tied to one GPU; it has been tested only on AMD Strix Halo (Ryzen AI Max+ 395) with the Kyojin engine, and other hardware is untested.

An EXL3 quantisation of XiaomiMiMo/MiMo-V2.6-Flash-MOPD (MoE, 309B total, 15B active, per the upstream card) for one 128 GB unified-memory machine (AMD Ryzen AI Max+ 395, gfx1151). The three MTP heads are kept at 4 bits or more in the pack; the engine does not use them; speculative decoding runs on the separate 4 bpw drafter in drafter/ (see Speed). This pack holds the text model only (no vision or audio encoders). It runs on the Kyojin engine, built on ExLlamaV3. Quantised by Yamz. Not affiliated with Xiaomi.

Highlights

• Quality. Against the official FP8 model on 125 held-out rows: KLD 0.0713, top-1 agreement 91.99 %. The tuning overlay (see below) lowers KLD by 1.86 % on the same rows compared with the pack without it.
• Size. 105.04 GB for a 309B-total MoE: one 128 GB machine holds it.
• Speed. Speculative decoding is on by default with the bundled 4 bpw drafter: decode 28.9 tok/s on prose, 31.2 on chat, 37.0 on code, prefill 760 tok/s at 8K, on one Ryzen AI Max+ 395 (see Speed).
• Engine. Kyojin, the Yamz engine built on ExLlamaV3, runs it on gfx1151 with ROCm.
• Image input. The Kyojin server reads images (OpenAI image_url parts) with the vision tower in vision/ (engine main from 2026-10-08). First version, improvements coming.
• Feedback wanted. Run it on your Strix Halo / Ryzen AI Max machine and tell us your tok/s and hardware: open an issue at https://github.com/Yamz-Labs/kyojin/issues or start a discussion on this page.

What is in the folder

• 14 EXL3 shards (model-0000X-of-00014.safetensors, 145,504 tensors): the quantised model. Mixed precision per layer (see Limits).

• zz-e2e-step120.safetensors (2.3 MB, 240 tensors): a small overlay from one end-to-end tuning stage. It replaces the scale vectors (su, sv) and norm weights of layers 24 to 47; the quantised tensors and the expert weights are untouched. Our engine loads every *.safetensors file in the folder and lets the later file win (the loader prints one "Overriding ..." line per tensor). It was tested on our engine only; other loaders were not tried. If you delete this file you get the pack without the tuning stage: on the same rows it has a KLD 1.9 % higher (see Quality); the numbers below are for the pack with the file.

• drafter/ (702 MB): the DFlash draft model, 4 bits per weight in EXL3, with config.json, mask_embedding.safetensors and draft_conf_prior.json (an offline table that sets the confidence cut-off of the drafts). The engine finds it by itself next to the shards. Delete the folder, or set MIMO_SPEC=0, for plain decode.

• vision/vision.safetensors (1.46 GB): the vision tower, unquantised bf16 weights taken from the upstream checkpoint. The server loads it at start (1.4 GiB of GPU memory); --no-vision skips it.

Size: 105.04 GB for the folder (14 shards 104.99 GB, overlay 2.3 MB), plus the 0.70 GB drafter/ folder and the 1.46 GB vision/ folder, measured.

Run

git clone https://github.com/Yamz-Labs/kyojin && cd kyojin
./build.sh && source tools/strix_halo/env.sh
python tools/mimo/serve.py --model /path/to/this-pack --port 8000 -c 32768

See tools/mimo/SERVE.md in the engine repo. The speed table below was measured from a clean install with this pack.

Context: the upstream config declares 1,048,576 positions. We ran 32K. Memory arithmetic from config.json (not a measurement): 9 of the 48 layers use global attention and keep a KV cache of 4 heads x (192 + 128) x 2 bytes = 23,040 bytes per token in fp16; the other 39 layers use a 128-token sliding window. At -c 131072 that is about 2.8 GiB for the global layers. The weights take about 97.8 GiB.

Hardware

Quality (reference = the official FP8 MiMo-V2.6-Flash-MOPD weights; held-out rows, top-64 KLD)

Measured with a development build of our engine (the MiMo branch); the published tree differs from it in a few kernel and quantiser source files and was not itself benchmarked for quality. 125 held-out rows of up to 4,096 tokens (251,986 tokens); the 4 longer rows were not run (memory risk).

KLD measures how far the output distribution is from FP8 (lower is closer); top-1 agreement is how often the most likely next token is the same. Top-1 by stratum: chat 95.05, math 95.33, agent 94.48, code 92.27, bridge 91.44, prose 90.37, wiki 89.34, French 87.37.

The tuning overlay was trained on 313 clean rows of 531 candidates (agent and chat rows were dropped because their teacher reference was unreliable) and has no tool-call or chat rows. None of the 531 candidate rows shares a source document, a token window or a text 12-gram with the held-out rows. Without the overlay file, KLD on the same 125 rows is 0.0727 (0.0713 with it, -1.86 %, 95 % CI -2.27 to -1.46); top-1 is unchanged within noise.

Comparison with a GGUF: none in this card. An earlier GGUF number was measured under a different protocol and is not comparable.

Speed

This is the Kyojin 1.5 release of MiMo-V2.6-Flash. Speculative decoding is on by default. The engine reads the 4 bpw drafter in drafter/, drafts up to 7 tokens and keeps only the confident prefix of each draft (--ndt 7 --dynamic-draft --draft-confidence 0.6). Plain decode: --no-dflash on serve.py. If the drafter folder is missing, the server logs one line and decodes plain.

Method: the public engine code, an empty home directory, this published pack downloaded from the hub, the default environment, greedy decoding, thinking off, 256 tokens, median of 3. Prefill is the speed the server reports; decode uses the server's own counters (/metrics). Cold prompts of 8K to 128K tokens; two requests per depth, the second one reported. Full method: doc/benchmarks.md in the engine repository. One Ryzen AI Max+ 395, 128 GB. Tokens per second.

By kind of text (card prompts, speculative decode): prose 28.9, chat 31.2, code 37.0 tok/s.

A loaded drafter costs 2 to 4 % of prefill speed. The output of speculative decoding is token-identical to plain greedy decoding by default (exact verify arithmetic); EXL3_MIMO_LOSSLESS=0 selects a slightly faster verify that is not token-identical, because near-tied logits can flip when several drafted tokens are checked in one pass. Speed depends on the prompt: the gain is largest where the text is predictable.

Earlier run, kept as published

Decode tok/s, medians of 6 runs over two server loads, 128 new tokens, client temperature 0, -c 32768, this pack with the bundled drafter, published engine tree: plain 28.9; speculative 32.1 prose, 34.8 chat, 40.8 code. Prefill about 650 tok/s at 4K tokens. That run used a different protocol from the table above, so the two are not comparable row by row.

Optional steering presets

Optional steering presets for the optional runtime steering hook of the engine are published separately in the Yamz presets repository (https://github.com/yamz-labs/yamz-presets); they are not part of these weights. For MiMo a partly validated preset exists (mimo-v2.6-flash/): on this pack it gives 4/100 refusals on 100 held-out harmful prompts (94/100 without it) and +5.5 % KLD against FP8 (hook off 0.0713, on 0.0752). Task-score deltas and over-refusal were not measured. A ready-made variant of this pack, with the preset bundled as a file the engine applies at load, is yamz-labs/MiMo-V2.6-Flash-MOPD-EXL3-Yamz-Uncensored.

Sampling

Use the upstream card values: temperature=1.0, top_p=0.95 (read on the upstream model card). Greedy decoding is not recommended.

Limits

• Only gfx1151 with ROCm is tested.
• Conversion tooling is not published.
• Per-layer check: 11 of 48 layers have rfn (a per-layer reconstruction-error score) above 0.05 (layers 8-15, 44, 46, 47; mean 0.032, max 0.068 in layer 46, most of them at 2.05 bits per weight). Overall top-1 passes our 90 % bar and no stratum collapses, but French (87.3 %) and wiki-style text (89.1 %) agree less with the reference. A per-layer-group KLD was not run.
• Use the card sampling above; greedy decoding is not recommended, especially for long outputs.
• The three MTP heads are not used by the engine; the speed-up comes from the separate drafter.

Licence and credits

MIT, as declared by the upstream model card (license: mit). The upstream repository has no LICENSE file and no copyright line for the weights (checked at release time), so this repository carries no copy of one. modeling_mimo_v2.py and configuration_mimo_v2.py are upstream files, unchanged, under their own Apache-2.0 header (Copyright 2026 Xiaomi Corporation); the Apache-2.0 text is in LICENSE-APACHE-2.0. Base model: Xiaomi MiMo team. Our additions: Copyright (c) 2026 Yamz Labs, MIT (LICENSE). Provided as is, without warranty. Engine: built on ExLlamaV3 by turboderp (MIT).

@misc{mimo2026v26flashmopd, title={MiMo-V2.6-Flash-MOPD}, author={{Xiaomi MiMo Team}}, year={2026}, howpublished={https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-MOPD}}