Xiaomi MiMo-V2.5-Pro: Open-Source 1T Coding Agent Guide 2026

Why MiMo-V2.5-Pro Changes the Open-Source Coding Agent Equation#

Every few months an open-source model arrives that genuinely pressures the closed frontier. MiMo-V2.5-Pro, released by Xiaomi on April 22, 2026, is the latest, and the interesting part is not the headline score. It is the token bill.

Xiaomi reports 64% Pass³ on ClawEval at roughly 70,000 tokens per trajectory, which the company puts at 40 to 60 percent fewer tokens than frontier closed models at comparable capability. That ratio is the whole argument. When a coding agent runs for eleven hours, makes 1,868 tool calls and emits 8,000 lines of code, tokens are not a rounding error. They decide whether the workflow is affordable enough to run twice.

The capability scores need more care than the marketing does. MiMo's SWE-bench Pro figure is self-reported, and the model does not appear on the independent leaderboard where its named competitors are ranked. That gap is worth understanding before you build a migration plan on a chart.

This guide covers the architecture, which numbers are independently checkable, what the API actually costs at current rates, and where self-hosting stops being realistic. For surrounding context, see our best AI coding agents comparison, the Kimi Code K26 guide, and the self-hosting versus cloud API cost breakdown.

What MiMo-V2.5-Pro Is#

MiMo-V2.5-Pro is a 1.02 trillion total parameter, 42 billion active parameter Mixture-of-Experts (MoE) model — 70 layers, 384 routed experts with 8 active per token, trained on 27 trillion tokens in FP8 (E4M3) mixed precision. It is fully open-sourced under the MIT license, meaning you can use it commercially, fine-tune it, and redistribute derivatives without additional authorization. Weights, tokenizer, and the full model card are available at XiaomiMiMo/MiMo-V2.5-Pro on HuggingFace.

The model belongs to the MiMo series, which Xiaomi has positioned as its agentic coding lineup. MiMo-V2-Pro launched earlier in 2026 and demonstrated competitive results. MiMo-V2.5-Pro is described by Xiaomi as "a major leap in general agentic capabilities, complex software engineering, and long-horizon tasks."

Do not confuse it with MiMo-V2.5 (without the "Pro" suffix). That sibling model is a 310B total / 15B active parameter omnimodal model — it handles text, image, video, and audio in a unified architecture. MiMo-V2.5-Pro is language-and-reasoning focused, the one relevant for coding agent pipelines.

Architecture Deep Dive#

Understanding the architecture explains why this model is efficient at long-context agentic tasks.

Mixture of Experts with 42B Active Parameters#

With 1.02T total parameters and only 42B activated per forward pass, the MoE routing ensures each inference call has a compute footprint comparable to a dense 42B model — not a 1T one. This is the same design principle behind DeepSeek-V4 and Mistral's Mixtral series, but scaled to a larger expert pool.

Hybrid Attention for Long Contexts#

MiMo-V2.5-Pro inherits the hybrid attention design from MiMo-V2-Flash:

• Local Sliding Window Attention (SWA) with a 128-token window
• Global Attention (GA) interleaved at a 6:1 ratio (6 SWA layers per GA layer)

The practical effect is that KV-cache memory grows far more slowly than it would under full global attention, which is what makes a 1M-token window economically servable rather than merely declarable. Xiaomi does not publish a per-length cache footprint, so size your own deployment by measurement rather than by ratio. Note also that servable is not the same as reliable at that length — see the limitation table below.

Multi-Token Prediction (MTP)#

Three lightweight MTP modules using dense FFNs allow the model to predict multiple tokens ahead simultaneously. This accelerates inference without requiring speculative decoding infrastructure on the serving side. For agentic loops where the model outputs structured tool calls, faster token generation directly reduces wall-clock time per iteration.

The Benchmark Numbers, and Who Published Them#

Every score below is tied to the page that published it. The column that matters most is the last one, because vendor-reported and independently-run numbers are not the same kind of evidence, and MiMo's headline figure is the first kind.

The comparison Xiaomi's chart implies, and what the leaderboard says#

Xiaomi's launch page positions MiMo-V2.5-Pro against Claude Opus 4.6, Gemini 3.1 Pro, GPT-5.4 and DeepSeek V4 Pro on a capability-versus-token-cost chart, but it does not publish the per-model scores behind those points. Scale's public SWE-bench Pro leaderboard does publish them, and MiMo is not on it:

Source: Scale SWE-bench Pro public leaderboard.

Two things follow. MiMo's self-reported 57.2 would sit between GPT-5.4 and Opus 4.6 if it were measured the same way, which is a genuinely strong result for an MIT-licensed model. But it was not measured the same way, and scores on this benchmark move several points depending on harness and split, so a same-chart comparison is not available yet. Treat 57.2 as a claim worth testing on your own repositories rather than a settled ranking.

The long-horizon demo numbers#

Xiaomi's site documents three sustained autonomous runs:

1. SysY compiler in Rust — 233/233 test cases passed, 672 tool calls, 4.3 hours
2. Desktop video editor — 8,192 lines of code, 1,868 tool calls, 11.5 hours
3. Analog circuit design — roughly an hour of closed-loop iteration against ngspice

These are controlled vendor demos, not independent reproductions. What they establish is narrower than "the model is better": they show the architecture holding a coherent plan across thousands of iterations, which is precisely where weaker models drift off-task mid-run.

Calling MiMo-V2.5-Pro via API Today#

The fastest path to using the model is OpenRouter, which exposes it at xiaomi/mimo-v2.5-pro on an OpenAI-compatible endpoint with the full 1M context. Listed pricing is $0.40 per million input tokens and $1.50 per million output tokens (OpenRouter model page).

Claude Opus 4.6 lists at $5 input and $25 output per million (Anthropic). Output dominates agentic workloads, so on the line item that actually moves, MiMo-V2.5-Pro is roughly 16x cheaper. Rates on both sides change; re-check before you build a budget on them.

Worked example: what one agentic run costs#

Take Xiaomi's own ClawEval trajectory figure of ~70,000 tokens and assume the usual agentic split of about 80% input (re-sent context, tool results) and 20% output. That gives 56,000 input and 14,000 output tokens per trajectory.

The Opus column is generous to Opus, because Xiaomi's claim is that competing models spend 40–60% more tokens per trajectory to reach the same result. Hold that claim aside and the gap is still about 14x. That is the number worth carrying into a budget conversation, and it is the reason a self-reported benchmark is still worth a pilot: the downside of testing is small.

To model the same comparison against a self-hosted deployment instead of an API, use our self-hosting cost calculator.

Basic Setup#

Install the OpenAI SDK (it's compatible with OpenRouter's endpoint):

pip install openai

Set your OpenRouter key as an environment variable:

export OPENROUTER_API_KEY="your-key-here"

Simple Coding Task Call#

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="your-openrouter-key",
)

response = client.chat.completions.create(
    model="xiaomi/mimo-v2.5-pro",
    messages=[
        {
            "role": "system",
            "content": "You are an expert software engineer. Respond with complete, working code."
        },
        {
            "role": "user",
            "content": "Write a Python function that parses a cron expression and returns the next 5 run times."
        }
    ],
    max_tokens=4096,
)

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

Enabling Reasoning Mode#

MiMo-V2.5-Pro supports extended reasoning via a reasoning parameter. This activates the model's internal chain-of-thought before the final response:

response = client.chat.completions.create(
    model="xiaomi/mimo-v2.5-pro",
    messages=[...],
    extra_body={
        "reasoning": {"effort": "high"}
    },
    max_tokens=16384,
)

# Access internal reasoning trace
if hasattr(response.choices[0].message, "reasoning_details"):
    for block in response.choices[0].message.reasoning_details:
        print(f"[Reasoning] {block}")

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

Enabling reasoning increases token consumption but can meaningfully improve results on complex multi-file refactoring or system design tasks.

Using the Xiaomi API Platform#

Xiaomi operates its own platform at platform.xiaomimimo.com, serving the same weights. Launch-period free-token promotions circulated widely in coverage at release, but the terms are not stated on the model card, so check the platform directly rather than budgeting around a figure from an April announcement.

Self-Hosting MiMo-V2.5-Pro#

Self-hosting a 1T-parameter MoE model is not a developer-laptop task. Here is what the infrastructure actually looks like based on official vLLM documentation and AMD's day-0 support announcement.

Minimum Hardware#

The AMD Instinct MI355X is the reference configuration used in AMD's official deployment guide: 288 GB on-chip memory, 8 TB/s bandwidth. For NVIDIA, tensor parallel across 8x H100 SXM (640 GB aggregate HBM3) is the minimum practical configuration. To sanity-check a smaller or quantized deployment against the GPUs you actually have, our LLM VRAM calculator estimates the memory footprint.

vLLM Deployment#

Standard stable vLLM does not yet support MiMo-V2.5-Pro. You need the vLLM nightly build:

pip install vllm --pre --extra-index-url https://wheels.vllm.ai/nightly/

Launch the server:

vllm serve XiaomiMiMo/MiMo-V2.5-Pro \
  --tensor-parallel-size 8 \
  --gpu-memory-utilization 0.95 \
  --max-model-len 32768 \
  --trust-remote-code

A few notes:

• --max-model-len 32768 limits context to 32K for memory management — increase carefully if you have headroom
• --trust-remote-code is required because MiMo's custom attention layers are not in the default vLLM registry
• For AMD GPUs, ROCm 6.x with PyTorch 2.4+ is required; vLLM's ROCm build is separate from the CUDA wheel

SGLang Alternative#

SGLang supports MiMo-V2.5-Pro and can be faster than vLLM for high-concurrency agentic workloads due to its RadixAttention KV cache sharing. Check the SGLang docs for the current compatibility matrix before deploying.

MiMo-V2.5 vs MiMo-V2.5-Pro: Which to Use#

If you're new to the MiMo series, the naming can confuse which model belongs in which pipeline.

MiMo-V2.5-Pro is a language-and-reasoning specialist. It handles text, code, and structured tool use. It's the right choice for:

• Autonomous coding agents
• Long-horizon software engineering tasks
• API-driven coding workflows where token cost matters

MiMo-V2.5 (without "Pro") is the omnimodal model: 310B total / 15B active parameters, trained on ~48T tokens, with native image, video, and audio understanding. Use it for:

• Multimodal workflows (analyzing UI screenshots, processing audio logs)
• Tasks where 15B active parameters is sufficient compute
• Scenarios where model size on disk matters (it's significantly smaller)

Both are MIT-licensed and available on HuggingFace under the XiaomiMiMo organization.

Known Limits and What They Cost You#

The model card is unusually candid about where the model degrades. These are the constraints worth planning around, each with the practical consequence spelled out.

When to Use MiMo-V2.5-Pro — and When to Skip It#

Use it when:

• You run agentic coding pipelines at volume and token cost is a real budget line. This is the case the model is built for, and the cost math above is the whole argument.
• Licensing is the constraint. MIT terms permit commercial fine-tuning and redistribution, which most frontier alternatives do not.
• Code cannot leave your infrastructure for residency or privacy reasons, and you already have multi-GPU capacity.
• You are fine-tuning a frontier-class MoE and want a base checkpoint you can legally build a product on.

Skip it when:

• Your workload is interactive and latency-sensitive. At 42B active parameters, generation is slower than a 7B or 14B model, and no license terms fix that.
• You want one managed vendor and a support contract. Claude and GPT-5.4 are simpler to operate, and simplicity has a real price.
• You need image or audio understanding in the same pipeline.
• Your infrastructure tops out below eight H100-class GPUs and you also cannot use a hosted endpoint.
• You need a benchmark position you can defend to a procurement committee today. The independent listing does not exist yet.

Common Integration Mistakes#

Treating it like a small model. At 42B active parameters, MiMo-V2.5-Pro generates tokens more slowly than a 7B or 14B model. For interactive applications that need sub-second latency, benchmark your specific hardware before committing.

Ignoring the vLLM nightly requirement. Attempting deployment on stable vLLM will fail. The nightly build is necessary until MiMo's hybrid attention lands in a stable release.

Skipping the reasoning parameter for hard tasks. The default chat completion mode does not activate the full reasoning chain. For complex refactoring or algorithm design, the reasoning parameter in the request body can substantially improve output quality at the cost of more tokens.

Not using temperature 0.0 for code generation. Like most coding models, MiMo-V2.5-Pro performs more consistently on deterministic tasks when temperature is set to 0. Sampling at higher temperatures is appropriate for brainstorming but not for producing executable code in production pipelines.

Frequently Asked Questions#

Q: Is MiMo-V2.5-Pro actually better than Claude Opus 4.6 for coding?#

Not answerable from published numbers, which is the honest answer. Xiaomi reports 57.2 on SWE-bench Pro; Scale's independent leaderboard puts Opus 4.6 (thinking) at 51.9 on its public set but does not list MiMo at all, so the two figures were not produced by the same run. Cost is where the comparison is solid, because both prices are published: MiMo is roughly 16x cheaper per output token. Run a pilot on your own repositories before treating the capability question as settled.

Q: Can I fine-tune MiMo-V2.5-Pro?#

Yes. The MIT license explicitly allows continued training and fine-tuning. Xiaomi provides the base checkpoint (XiaomiMiMo/MiMo-V2.5-Pro-Base on HuggingFace) for teams that want to start from pre-RLHF weights. Fine-tuning a 42B-active-parameter MoE still requires substantial compute — at minimum, a multi-GPU setup with gradient checkpointing.

Q: What is ClawEval and why does it matter?#

ClawEval is an agentic benchmark tied to the OpenClaw evaluation framework. It measures a model's ability to complete multi-step, real-world autonomous tasks — coding, system design, tool use, and long-horizon planning — not just single-turn question answering. It's more representative of how coding agents actually behave in production than MMLU or HumanEval, which test isolated knowledge or simple function generation.

Q: How do I use it with Claude Code or other agent frameworks?#

MiMo-V2.5-Pro exposes an OpenAI-compatible endpoint via OpenRouter and the Xiaomi API Platform. Any framework that accepts an OpenAI base URL can route to it: set base_url to OpenRouter's endpoint, api_key to your OpenRouter key, and model to xiaomi/mimo-v2.5-pro. There is also a community guide for integrating it with Claude Code via the ANTHROPIC_BASE_URL override pattern.

Key Takeaways#

• MiMo-V2.5-Pro is a 1.02T total / 42B active MoE model, trained on 27T tokens, released April 22, 2026 under MIT license
• Its capability scores are vendor-reported. SWE-bench Verified 78.9 and SWE-bench Pro 57.2 come from Xiaomi's model card, and the model does not appear on Scale's public SWE-bench Pro leaderboard
• The efficiency claim is the durable one: 64% ClawEval Pass³ at ~70K tokens per trajectory, which Xiaomi puts at 40–60% below frontier peers
• OpenRouter lists $0.40 input / $1.50 output per million against Opus 4.6's $5 / $25 — roughly 16x cheaper on output, or about $0.04 versus $0.63 per agentic trajectory
• The 1M context window degrades measurably past 512K, so treat it as a ceiling rather than a working range
• Self-hosting needs 8x H100 or MI355X class hardware plus a vLLM nightly build; below that, the managed API is the only path
• MiMo-V2.5 without the "Pro" suffix is a different model — 310B/15B active, omnimodal, trained on ~48T tokens

What Effloow Added#

Xiaomi's launch materials lead with a win chart. A team deciding whether to adopt the model needs something different — to know which numbers hold up and what the thing actually costs to run:

• A benchmark table with a provenance column, checking each published score against Scale's independent SWE-bench Pro leaderboard. MiMo is absent from it, which is the single most useful fact for anyone about to quote 57.2 in a procurement document.
• Cost math at current rates, not launch-week rates: $0.043 per agentic trajectory against $0.63 for Opus 4.6, worked from the token split rather than asserted as a multiplier.
• A limitation table built from the model card's own degradation data, including the point past 512K where the 1M context stops retrieving reliably.
• A self-host-versus-API decision with the hardware floor stated plainly, so the choice maps to infrastructure you either have or do not.

Sources#

• XiaomiMiMo/MiMo-V2.5-Pro model card — parameters, training tokens, benchmark scores, long-context degradation
• Xiaomi MiMo-V2.5-Pro product page — ClawEval Pass³, tokens per trajectory, long-horizon demo runs
• Scale SWE-bench Pro public leaderboard — independent comparison scores
• OpenRouter: xiaomi/mimo-v2.5-pro — API pricing and context length
• Anthropic: Claude Opus 4.6 — comparison pricing
• XiaomiMiMo/MiMo-V2.5 model card — omnimodal sibling specifications