MiMo-V2.5 in Production: Specs, Pricing, and the Code I Actually Ship

Xiaomi shipped MiMo-V2.5 on April 22, 2026, and I've spent the last stretch wiring it into a couple of agentic and multimodal pipelines. The short version: it's a sparse MoE model with a genuinely absurd context window and pricing that undercuts almost everything in its class. The longer version involves a lot of decisions about when not to use it.

Here's what I found worth knowing before you commit.

What you're actually calling

MiMo-V2.5 pairs a sparse MoE language backbone with dedicated encoders for vision and audio. Per the official model card, you feed it text, images, video, and audio, and you get text back.

That 15B-active / 310B-total split is the whole point. You get the capacity of a very large model with the inference economics of a much smaller one — which is exactly why the per-token price looks the way it does.

One caveat that has bitten me: the model's native modality support and what a given provider route actually accepts are two different things. I validate the exact image/audio/video payload shape against the live endpoint before I ship a feature, not after.

Benchmarks: useful for scoping, not for shipping

Xiaomi's reported numbers:

The multimodal agent score (23.8) is the one I'd stare at hardest. It's the weakest number on the board, and it's exactly the category MiMo-V2.5 markets itself into. If your workload is "agent that looks at screenshots and clicks things," benchmark it yourself before you build on it — the profile here suggests repo-scale code plus tools is the stronger story.

My rule: benchmarks pick the two candidates. My own eval set picks the winner. Measure task success, token spend, p50/p99 latency, retry rate, and how often a human has to fix the output.

MiMo-V2.5 vs Pro

Note the asymmetry: Pro is text-in only. Anything multimodal stays on the standard route regardless of how hard the reasoning is.

The pattern I've landed on is a tiered router. Default everything to mimo-v2.5, and escalate a narrow class of requests — the ones your eval shows a real accuracy delta on — to Pro. Sending all traffic to Pro is the lazy configuration and it costs 3x for gains you probably can't measure on most requests.

The first call

Keep the key server-side. Environment variable, secrets manager in prod, rotation on a schedule.

export COMETAPI_KEY="your_api_key_here" 

$env:COMETAPI_KEY = "your_api_key_here" 

The endpoint is OpenAI-compatible, so migration is base URL + model ID:

curl https://api.cometapi.com/v1/chat/completions \ -H "Authorization: Bearer $COMETAPI_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "mimo-v2.5", "messages": [ {"role": "system", "content": "You are a careful coding assistant."}, {"role": "user", "content": "Explain the bug and propose a minimal patch."} ], "temperature": 0.2 }' 

import os from openai import OpenAI client = OpenAI( api_key=os.environ["COMETAPI_KEY"], base_url="https://api.cometapi.com/v1", ) response = client.chat.completions.create( model="mimo-v2.5", messages=[ {"role": "system", "content": "You are a precise engineering assistant."}, {"role": "user", "content": "Review this migration plan for hidden risks."}, ], temperature=0.2, ) print(response.choices[0].message.content) 

If you're already routing across multiple model vendors, a unified gateway is genuinely worth it here — one key, one base URL, and model switching becomes a string change rather than a client rewrite. (CometAPI is the one I've been using for this.)

Never log full authorization headers or raw prompt bodies. Both tend to contain things you don't want in a log aggregator.

Streaming

For anything long-form, stream. The perceived-latency win is larger than any tuning you'll do elsewhere.

stream = client.chat.completions.create( model="mimo-v2.5", messages=[{"role": "user", "content": "Draft a safe database migration checklist."}], stream=True, ) for chunk in stream: delta = chunk.choices[0].delta.content if delta: print(delta, end="", flush=True) 

In a web service, forward deltas over SSE or WebSocket, handle client disconnects, and actually abort upstream generation on cancel. Leaked streams are a silent cost leak.

Multimodal and structured output

Image plus instruction in the same user message:

{ "model": "mimo-v2.5", "messages": [ { "role": "user", "content": [ {"type": "text", "text": "Extract the visible error and suggest the next diagnostic step."}, {"type": "image_url", "image_url": {"url": "https://example.com/error.png"}} ] } ] } 

Treat that as a payload pattern — confirm the route accepts it before you depend on it.

For machine-readable output, ask for compact JSON, then validate it against your own contract. Parsing successfully is not the same as being correct:

import json raw = response.choices[0].message.content result = json.loads(raw) required = {"summary", "risks", "next_action"} missing = required - result.keys() if missing: raise ValueError(f"Missing fields: {sorted(missing)}") 

The cost math

Assume 10,000 input tokens and 2,000 output tokens per request, 100 requests:

MiMo-V2.5 input: 100 × 10,000 / 1,000,000 × $0.112 = $0.1120 MiMo-V2.5 output: 100 × 2,000 / 1,000,000 × $0.224 = $0.0448 MiMo-V2.5 total: $0.1568 Pro input: 100 × 10,000 / 1,000,000 × $0.348 = $0.3480 Pro output: 100 × 2,000 / 1,000,000 × $0.696 = $0.1392 Pro total: $0.4872 

That's roughly a 68% saving on the standard route. Verify against the live provider price before you put it in a budget deck.

Levers that matter: max-output caps, prompt compression, cached context, request classification, and the router. But track cost per successful task, not cost per request. A request that's cheap and fails three times cost you four requests.

Long context is a ceiling, not a target

A 1M-token window doesn't repeal attention tradeoffs. Some things I do:

• Task statement, output contract, and decision criteria go at the top, not the bottom.
• Documents get stable IDs and explicit delimiters.
• Anything that can't change the answer gets cut.
• Ask for citations back — document ID or line reference — so you can verify grounding.
• Chart accuracy against input size. The curve usually bends before you hit the limit.

Retrieval still earns its keep even when the whole corpus fits. More context means more tokens and more ways to distract the model.

Retries that don't make things worse

Retry transient failures with exponential backoff plus jitter. Don't retry auth errors, malformed payloads, or policy rejections — you'll just burn quota producing the same failure.

import random import time def delay_for(attempt: int) -> float: return min(30.0, (2 ** attempt) + random.random()) for attempt in range(5): try: result = call_model() break except TransientAPIError: if attempt == 4: raise time.sleep(delay_for(attempt)) 

Guardrails I won't ship without: connection and overall request timeouts, idempotency keys on anything with external side effects, structured logs of model ID / latency / token counts / retry count / status, redaction before logging, tool allowlists with explicit confirmation for destructive actions, and a fallback model or queue for outages.

Error triage

Where I landed

MiMo-V2.5 is my default for multimodal input, large-context analysis, and cost-sensitive agent traffic. Pro is a deliberate escalation, gated on evidence that it earns the 3x.

Start with a small eval set, instrument every request, and don't promote the integration until you've tested real payloads, long-context degradation, retry behavior, and failure recovery. The model is easy to call. The pipeline around it is where the work is.

Originally published at cometapi.com