MiMo-V2.6-Pro

MiMo-V2.6-Pro

The flagship of its release — and the only model in its series independently measured.

The Number With an Independent Source

MiMo-V2.6-Pro scores 46 on independent evaluation, leading open-weight models at the time of measurement.

That figure matters for a reason beyond its size. It is currently the only independently measured result anywhere in the MiMo-V2.6 series. Every figure for the smaller sibling released alongside it comes from Xiaomi's own harness, grader, and offline runs.

Which means this model can be compared to things outside its own family with a confidence the smaller one cannot. A measured figure against a measured figure is a comparison; a vendor figure against a measured one is not.

It was released on 21 September 2026, eighteen seconds before its sibling, which makes the existence of any independent measurement this early notable in itself.

What the Extra Parameters Buy

Two models from one release, trained by the same run. The difference is capacity.

Roughly 2.8 times the active compute per token.

Where the gap is small

On routine execution, reported results sit within about a point of each other — multi-step web navigation and API formatting, single-function code generation. On work shaped like that, the larger model's extra compute buys very little.

Where the gap is large

On sustained multi-file work, the reported difference widens. Third-party analysis describes this model maintaining consistent symbol tables and architectural contracts across the entire prompt context, on changes that span many interconnected files — where the smaller sibling is described as drifting.

Reported DeepSWE: 71.9 — a benchmark centred on running tests, reading compiler errors, and repairing breaking changes across multiple packages without inventing deleted interfaces.

Read the division precisely. The smaller model is not worse at coding. It is reported to be worse at holding many things in mind at once — and that is exactly the capability that more active parameters and more experts would be expected to buy.

Architecture

Eight of 384 experts per token — just over two percent of the pool, against roughly three percent on the smaller sibling. A larger pool with the same selection count means more specialised experts, each seeing a narrower slice of the data.

Sixty narrow layers, ten global ones. The same principle the whole family uses — cheap local attention carrying most of the depth, exact global attention where retrieval matters — applied at greater width.

And the ratio shifts slightly toward local attention: six to one here, against roughly four to one on the smaller model. More layers see only a neighbourhood; the ten global layers carry the long-range work across a deeper stack.

Shared With Its Sibling

Several components are identical across the two, which is worth knowing because it means capability in those areas does not differ by size.

Three encoders

Text, image, video, and audio enter one model through dedicated encoders rather than separate pipelines.

The encoders are the same size on both models. Perception does not scale with the backbone here — what scales is the reasoning over what was perceived.

A seven-token drafter

A five-layer multi-token-prediction drafter predicting seven tokens per forward pass, built in rather than deployed alongside.

On a 42-billion-parameter active path, speculative decoding matters more than on a small one. Every token costs more to verify, so every accepted draft saves more.

One RL run, four domains

A single mixed reinforcement learning run covering coding, general agents, visual tasks, and cybersecurity — one training pass rather than separate domain runs, using GRPO with groupwise agentic grading.

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

⚠️ The Repository Page Reports 524B

The Safetensors block on the upstream repository page reports 524 billion parameters — a figure that reconciles with neither the 1.02 trillion total nor the 42 billion active.

Size hardware from the model card, not the repository page. The displayed figure is an artefact of how the weight format is counted.

And the upstream repository is named MiMo-V2.6-Pro-RL. The suffix marks post-training lineage — this is the model, not an adapter on top of one.

The raw download sits in the half-terabyte range before any quantisation — roughly three times the smaller sibling's 172.9 GB.

Specifications

MIT on a trillion-parameter omnimodal model. Commercial use, modification, and redistribution with no conditions, no attribution requirement, and no user threshold — at a scale where custom licences are the norm.

Capabilities

Using MiMo-V2.6-Pro on DEVUP AI

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

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-Pro",
    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-Pro",
    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-Pro",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

A Multi-File Refactor

The workload where the reported gap over the smaller sibling is widest.

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_typecheck",
            "description": "Run the type checker across the workspace and return every error.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the full 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_typecheck() -> dict:
    """Replace with your real type checker."""
    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_typecheck": run_typecheck,
    "run_tests": run_tests,
}

session = [
    {
        "role": "system",
        "content": (
            "You are refactoring a monorepo. Before editing anything, read every file the change "
            "touches and list the interfaces that cross package boundaries. Keep that list current "
            "as you work. Run the type checker after each package you change, and the full test "
            "suite at the end. Never remove an exported symbol without first finding every caller."
        ),
    },
    {
        "role": "user",
        "content": (
            "Rename the `Invoice.total` field to `Invoice.totalDzd` across billing, reporting, and "
            "the public API package, keeping every consumer compiling."
        ),
    },
]

CEILING = 150
start = time.monotonic()

for step in range(CEILING):
    response = client.chat.completions.create(
        model="XiaomiMiMo/MiMo-V2.6-Pro",
        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")
else:
    print(f"Reached the {CEILING}-step ceiling.")

The system prompt asks for the thing this model is reported to do better: an explicit, maintained list of cross-package interfaces. That list is the symbol table the task depends on, and asking the model to keep it current turns an internal capability into visible, checkable work.

"Never remove an exported symbol without first finding every caller" is the rule that prevents the characteristic failure of multi-file work — a change that compiles locally and breaks a consumer three packages away.

A type checker as a tool gives the model a way to verify consistency rather than assert it. On a rename across packages, that is the difference between a claimed success and a demonstrated one.

Routing Between the Two

Same release, same interface, one changed identifier.

FLASH = "XiaomiMiMo/MiMo-V2.6-Flash"
PRO = "XiaomiMiMo/MiMo-V2.6-Pro"


def pick_model(files_touched: int, cross_package: bool) -> str:
    """Route by how much the task must hold in mind at once."""
    if cross_package or files_touched > 4:
        return PRO
    return FLASH

Route on breadth, not difficulty. The reported gap is not about how hard a task is — it is about how many interdependent pieces must stay consistent. A difficult single-function problem can go to the smaller model; an easy rename across seven packages should not.

And measure your own threshold. The four-file boundary here reflects one third-party characterisation. Your codebase will have its own, and twenty real tasks through both models will find it.

Where It Fits

Large refactors and cross-package changes, where consistency across many interconnected files is the whole task.

Long-horizon agentic work needing a model to hold architecture, contracts, and history together across a long session.

Workloads needing an independently measured model, where a vendor figure is not sufficient for the decision.

Omnimodal analysis across text, image, video, and audio.

Security analysis, a trained domain in the shared RL run.

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

Not for routine execution at volume, where reported results put the smaller sibling within a point at a fraction of the compute.

Practical Notes

Route by breadth of change, not difficulty of task.

Ask the model to maintain an explicit list of cross-boundary interfaces on multi-file work.

Give it a type checker as a tool, so consistency is verified rather than asserted.

Forbid removing exported symbols without finding every caller.

Size hardware from the model card — the repository page reports a figure matching neither documented number.

Evaluate against the smaller sibling on your own tasks before committing to the compute.

Account for the cybersecurity training when deciding access and moderation.

Limitations

Released 21 September 2026. Production behaviour, framework support, and community tooling are all still being established.

One independent measurement. More than its sibling has, and still a single figure rather than a broad evaluation.

The multi-file advantage is a third-party characterisation, not a vendor-published or independently benchmarked result.

Exact long-range retrieval rests on ten global layers of seventy. Verify recall at your working length.

Forty-two billion active parameters is a real cost per token, and on routine work it buys little over the smaller sibling.

1.02 trillion parameters must be loaded — a half-terabyte download before quantisation.

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

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

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