MiMo-V2.6-Flash

MiMo-V2.6-Flash

Released 21 September 2026. Omnimodal, a million tokens of context, and a single reinforcement learning run across four domains.

⚠️ Read the Numbers With Their Source

The most important fact about this model's published results, and it is about timing rather than quality.

MiMo-V2.6-Flash and its larger sibling were published eighteen seconds apart on 21 September 2026.

At the time of writing, the only independently measured figure anywhere in this series belongs to the larger model. Every benchmark result for Flash comes from Xiaomi's own harness, Xiaomi's own grader, and Xiaomi's own offline run.

That is not a criticism. Independent evaluation takes time, and a day-old model has not had it. It may also be structural: the volume tier in a family attracts less benchmarking attention than the flagship.

What it means practically. Comparing this model against anything outside its own family means comparing a vendor figure against someone else's measurement — and those are not the same kind of number.

The remedy is cheap. Run twenty of your real prompts through it. That evaluation is independent by construction, and it measures the thing you actually care about.

One RL Run, Four Domains

The training decision that distinguishes this generation.

A single mixed reinforcement learning run that folded coding, general-agent, visual, and cybersecurity tasks into one training pass — rather than separate runs per domain.

Method: GRPO plus groupwise agentic grading.

Why a single run is the interesting choice. Separate domain runs produce a model that is good at each domain in isolation and can regress on one while improving another. A mixed run forces the model to hold all four at once — which is closer to how an agent actually works, switching between reading a screenshot, writing code, and reasoning about a system inside one task.

And cybersecurity is on the list. That is uncommon in a general model's RL curriculum, and it means security analysis is a trained capability rather than an emergent one.

It also means you should know it is there. A model trained on cybersecurity tasks is useful for defensive work — code review, vulnerability analysis, log triage — and it is a capability to account for when deciding who can reach it and with what moderation.

Xiaomi are open-sourcing the technical report, the training environments, and the RL code, so the training can be reproduced and verified rather than accepted.

Architecture

Two descriptions of the same 48 layers, and they do not conflict — one counts attention types, the other counts feed-forward types.

The first block is global attention with a dense feed-forward network. Everything after it interleaves.

No shared expert

Worth noticing, because most MoE designs in this catalogue include one. A shared expert runs on every token and handles common patterns so the routed experts can specialise.

This model has none. All capacity is routed, which means every token's computation is fully specialist — a different bet about where generalisation should live, and one that places more weight on the router learning a sensible division of labour.

A 128-token window

Aggressively narrow. Thirty-nine layers each see only 128 neighbouring tokens, at constant cost regardless of input length. Nine global layers see everything.

That ratio is what makes a million tokens affordable on fifteen billion active parameters — and it means exact long-range retrieval rests entirely on those nine layers.

Three Encoders

Native omnimodal input through dedicated components rather than one generic encoder.

Text, image, video, and audio all enter the same model rather than three pipelines assembled together.

The vision encoder uses the same idea as the backbone — mostly sliding-window, with a few full attention layers — applied to image patches rather than tokens.

And audio gets two components, a tokenizer and a patch encoder. That split handles sound as both a sequence and a signal, which is part of why audio understanding here is reasoning over sound rather than transcription followed by reasoning over text.

Seven Tokens Per Pass

A five-layer multi-token-prediction drafter, DFlash-style, predicting seven subsequent tokens per forward pass for parallel verification.

Most speculative decoding drafts two to four tokens. Seven is ambitious — the drafter has to be right about a longer sequence for the saving to materialise, and a wrong prediction at token three discards the four after it.

The payoff when it works is proportionally larger. On predictable output — code with a clear structure, formatted data, boilerplate — seven accepted tokens per pass is a substantial throughput gain.

It is built in, not a separate model to deploy alongside.

⚠️ Two Naming Traps

Both documented, and both cost time if you meet them unprepared.

The -RL suffix is the model, not an adapter

The upstream repository is named MiMo-V2.6-Flash-RL, which invites the reading that it is a reinforcement-learning adapter sitting on some other base.

It is the model. The suffix marks post-training lineage — this checkpoint is the output of the mixed RL run. The weight index confirms it: tens of thousands of tensors covering the backbone, the vision encoder, the audio stack, and the drafter.

The repository page reports 159B

The Safetensors block on the upstream repository page reports 159 billion parameters — neither the 309 billion total nor the 15 billion active on the model card.

Size your hardware from the card, not the page. A display figure that matches neither documented number is an artefact of how the weight format is counted, not a third specification.

Specifications

MIT on a 309-billion-parameter omnimodal model. Commercial use, modification, and redistribution with no conditions, no attribution requirement, and no user threshold.

The output ceiling is unusually generous. 131,072 tokens of generation — an eighth of the window, and enough for a complete long document, a full codebase refactor, or an extended reasoning trace in a single response.

Capabilities

Using MiMo-V2.6-Flash on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: XiaomiMiMo/MiMo-V2.6-Flash

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.6-Flash",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "XiaomiMiMo/MiMo-V2.6-Flash",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

  console.log(response.choices[0].message.content);
}

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "XiaomiMiMo/MiMo-V2.6-Flash",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

An Agent Loop

The workload the mixed RL run targeted — long-horizon tasks across a range of agent harnesses.

import json
import time

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file relative to the repository root.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": "Replace an exact string in a file. The old string must appear exactly once.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "old_str": {"type": "string"},
                    "new_str": {"type": "string"},
                },
                "required": ["path", "old_str", "new_str"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def edit_file(path: str, old_str: str, new_str: str) -> dict:
    """Replace with your real, sandboxed editor."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "edit_file": edit_file, "run_tests": run_tests}

session = [
    {
        "role": "system",
        "content": (
            "You are working inside a git repository. Make the smallest change that resolves the "
            "issue and run the tests after every edit. When a change spans several files, re-read "
            "each file before editing it rather than relying on an earlier read."
        ),
    },
    {"role": "user", "content": "The DZD invoice test fails on totals ending in .005. Find the cause and fix it."},
]

CEILING = 100
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="XiaomiMiMo/MiMo-V2.6-Flash",
        messages=session,
        tools=TOOLS,
        max_tokens=32768,
    )

    message = response.choices[0].message
    session.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        session.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})

    if step % 25 == 0:
        used = response.usage.prompt_tokens
        print(f"step {step:>3} · {(time.monotonic() - start) / 60:>5.1f} min · {used:>9,} tokens ({used / 1_048_576:.1%})")
else:
    print(f"Reached the {CEILING}-step ceiling.")

"Re-read each file before editing it" is the instruction worth copying for multi-file work. It is cheap, and it replaces reliance on an earlier read that may have drifted out of focus across a long session with a fresh look at the current state.

Track consumption as a percentage of the window. A million tokens is generous, and a long agent session with large file reads still reaches a meaningful fraction of it.

Multimodal Input

Four input types through dedicated encoders.

import base64
from pathlib import Path

encoded = base64.b64encode(Path("dashboard.png").read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.6-Flash",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded}"}},
                {
                    "type": "text",
                    "text": (
                        "Read every figure with its label and unit. Separate values printed in the "
                        "image from values you read off an axis, and mark anything illegible as "
                        "unreadable rather than estimating it."
                    ),
                },
            ],
        }
    ],
    max_tokens=16384,
)

⚠️ How video and audio are supplied on the chat endpoint varies by platform. Confirm the field shape with a test request before building a pipeline around either.

Ask questions that need more than one modality. "What is in this video" produces a description. "At which point does the speaker contradict the slide behind them" needs picture and sound together — and that is the question a model with native audio and vision answers that a pipeline of specialists cannot.

Video and audio consume input tokens rapidly. Measure one short clip before processing an archive; even a million-token window fills faster than a minute count suggests.

Using the Output Ceiling

131,072 tokens of generation is unusual, and it enables single-request work that elsewhere needs chunking.

response = client.chat.completions.create(
    model="XiaomiMiMo/MiMo-V2.6-Flash",
    messages=[
        {
            "role": "system",
            "content": (
                "Produce the complete document requested. Use headings. Do not stop early, do not "
                "summarise sections you have not written, and do not add meta-commentary."
            ),
        },
        {"role": "user", "content": f"{source_material}\n\nWrite the full technical specification."},
    ],
    max_tokens=65536,
)

choice = response.choices[0]

if choice.finish_reason == "length":
    raise ValueError(f"reached {response.usage.completion_tokens:,} tokens without finishing")

print(f"{response.usage.completion_tokens:,} tokens generated")

A complete long document in one response keeps structure, terminology, and cross-references consistent in a way that section-by-section generation struggles to.

"Do not stop early" earns its place. Models frequently wind down before their budget is exhausted, and an explicit instruction to complete the whole task counters it.

Check finish_reason regardless. A generous ceiling is still a ceiling.

Flash Against Its Larger Sibling

Both were released together, and the comparison is worth making carefully.

On routine execution, the reported gap is small. Third-party comparison puts the two within about a point of each other on multi-step web navigation and on single-function code generation — a difference that does not justify roughly three times the active compute on work of that shape.

On sustained multi-file work, the reported gap is larger. The same comparison describes Flash as drifting on changes spanning many interconnected files, where the larger model holds its symbol tables and architectural contracts across the whole context.

Read both of those as reported characterisations rather than measured results — they come from third-party analysis within a day of release.

The practical split they suggest: Flash for high-volume execution and routine agent steps; the larger model for large refactors where consistency across many files is the whole task. And test the split on your own work, because a day-old characterisation is a starting hypothesis rather than a finding.

Self-Hosting

172.9 GB of FP8 weights across 65 shards, with a dynamic activation scheme — the full model, not a reduced quantisation.

vLLM publishes a serving recipe covering H200 and GB300 configurations.

The drafter ships with the model. Enabling speculative decoding uses the built-in seven-token drafter rather than a separate model.

Size from the card. The repository page's parameter display matches neither documented figure.

The training environments and RL code are being open-sourced alongside the weights — relevant if you intend to continue training rather than only serve.

Where It Fits

Long-horizon agentic work across coding, general tasks, and visual inputs — what the single mixed RL run was built for.

Omnimodal applications, with text, image, video, and audio through dedicated encoders.

Very long outputs, where 131,072 tokens of generation removes the need to chunk.

Security analysis — code review, vulnerability triage, log analysis — which is a trained domain here rather than an incidental one.

High-volume execution, where fifteen billion active parameters decides the economics.

Self-hosted deployment under MIT, with the training stack being published alongside.

Less certain on sustained multi-file consistency, where reported characterisations favour the larger sibling.

Not yet independently benchmarked. Evaluate on your own workload before relying on a published figure.

Practical Notes

Treat published benchmarks as vendor figures until independent measurement exists.

Evaluate on twenty of your own prompts — that is independent by construction.

Instruct agents to re-read files before editing on multi-file changes.

Track context consumption as a percentage on long sessions.

Confirm how video and audio are supplied on your path.

Use the output ceiling for complete documents, and instruct the model not to stop early.

Check finish_reason on every long generation.

Size hardware from the model card, not the repository page.

Account for the cybersecurity training when deciding access and moderation.

Limitations

No independent benchmarks yet. Every Flash figure currently comes from Xiaomi's own harness and grader.

Released 21 September 2026. New enough that behaviour in production, framework support, and community tooling are all still being established.

Exact long-range retrieval rests on nine global layers of forty-eight, with a 128-token window on the rest. Verify recall at your working length.

No shared expert. All capacity is routed, which places unusual weight on routing quality.

Fifteen billion active parameters is the compute ceiling per token.

309 billion parameters must be loaded — 172.9 GB at FP8.

Text output only. Four input modalities, one output modality.

Reported to drift on large multi-file changes relative to its larger sibling — a characterisation rather than a measurement, and worth testing.

Cybersecurity is a trained capability. Useful defensively, and a factor in who you let reach the model.

The repository naming and parameter display both mislead — -RL is the model, and 159B matches neither documented figure.