MiMo-V2.5-Pro Is Available for Coding Agents, but the Official Weights Are Already FP8

MiMo-V2.5-Pro is Xiaomi’s large language model for coding agents: software that can inspect a repository, edit files, run commands and tests, read the results, then continue working through several steps. It is a text-only model with tool-calling support, a claimed one-million-token context limit, and a Mixture-of-Experts design with 1.02 trillion total parameters and 42 billion active parameters per token.

The important correction for anyone searching for a “non-quantized” MiMo-V2.5-Pro download is that Xiaomi’s official released checkpoint is listed as FP8 mixed precision. FP8 is an eight-bit floating-point format, so the official weights are already stored in a reduced-precision form. The model page does not present a separate full-BF16 or full-FP16 Pro checkpoint as the standard download.

What makes this an agent model

A coding agent needs more than code completion. It needs a loop: form a plan, call a tool such as a shell or file editor, observe the tool’s output, revise its plan, and repeat. MiMo-V2.5-Pro is trained and packaged for that pattern. Its serving guidance includes dedicated reasoning and tool-call parsers, which turn parts of the model response into structured actions for an agent harness to execute.

A Mixture-of-Experts, or MoE, model contains many specialist subnetworks called experts. A router selects only some of them for each token. MiMo-V2.5-Pro has 384 routed experts and activates eight per token. That is why the model can have 1.02 trillion parameters while its per-token active count is 42 billion. The lower active count helps compute efficiency, but it does not mean the whole checkpoint becomes small enough for an ordinary workstation.

The long-context design matters for repository work. The model alternates sliding-window attention, which concentrates on nearby tokens, with global-attention layers that can connect distant parts of the prompt. Xiaomi says this arrangement reduces key-value cache storage compared with using global attention in every layer. A larger usable context can reduce the need to repeatedly summarize files and earlier tool output, although context capacity is not a guarantee that an agent will understand every large codebase correctly.

Why “non-quantized” is the wrong expectation

Quantization reduces the numeric precision used to store or calculate model weights. It commonly lowers memory use and can improve inference throughput, at the possible cost of output quality or numerical stability. The phrase is sometimes used loosely to mean “the original official weights.” Those are different things. MiMo-V2.5-Pro’s official FP8 mixed-precision release is the original release format, even though FP8 is itself reduced precision.

The model’s 1.02 trillion total parameters explain the constraint. At roughly one byte per parameter, an FP8-scale weight representation alone is on the order of one terabyte before runtime overhead, routing data, temporary tensors and the key-value cache needed for a live conversation. A full 16-bit representation would roughly double the raw weight storage. The official distributed SGLang example uses tensor parallelism and expert parallelism set to 16, an indication that the intended deployment is multi-GPU infrastructure rather than a single consumer GPU.

A common misconception is that an open-weight license makes a model easy to run locally. The MIT license makes commercial deployment, fine-tuning and redistribution permissions comparatively straightforward. It does not supply the GPUs, high-speed interconnect, memory capacity or inference-engine support required to operate a trillion-parameter MoE model at useful speed.

The practical way to try it as a coding agent

For most developers, the sensible first test is an API-backed coding agent rather than local inference. Xiaomi exposes MiMo-V2.5-Pro through APIs described as compatible with OpenAI and Anthropic formats, and lists integrations with tools including Claude Code, Codex, OpenCode, Kilo Code and Qwen Code. Compatibility handles the request and tool-call format; it does not make every agent’s prompts, permissions or sandboxing equally reliable.

1. Choose a coding-agent harness that can use an OpenAI-compatible or Anthropic-compatible provider and can run shell commands in a controlled workspace.
2. Create a disposable test repository with a concrete task, such as adding one feature, fixing one reproducible defect or raising coverage for a named module.
3. Give the agent an acceptance test before it begins. For example: preserve the public API, add tests for the new behavior, run the existing test suite, and report every changed file.
4. Restrict its permissions. Start with a container or temporary branch; do not give an experimental agent production credentials, deployment access or unrestricted filesystem access.
5. Review the diff and test output yourself. An agent can produce a passing local test while missing a security requirement, changing an undocumented behavior or relying on a brittle assumption.

How to evaluate a first run

Do not judge a coding agent from one attractive code snippet. Give it a task that requires reading existing code, making a limited change and validating the result. Record whether it identified the relevant files, preserved surrounding conventions, used the available tests, recovered from an error, and stopped when the requested work was complete. Those behaviors reveal more about agent usefulness than a benchmark score alone.

MiMo-V2.5-Pro is most interesting when the work has a long trajectory: a multi-module refactor, a bug whose cause is separated from its symptom, or a task that requires repeated test-and-repair cycles. For a short function, the overhead of agent setup and a very large model may not be justified. For an organization considering self-hosting, a small API trial should come before hardware procurement, because it separates model quality questions from the cost and complexity of operating the model.

Using MiMo-V2.5-Pro with Cline

Cline is a coding-agent interface that works from a development workspace and can ask a connected model to read files, propose edits and run tools. Xiaomi lists Cline among the agent tools in its MiMo ecosystem, so it is a natural place to test the model through an API rather than attempting to host the FP8 checkpoint locally.

Start with Cline in a disposable repository or a dedicated branch. Configure the MiMo provider using the API format Cline supports, then give it a bounded task and explicit approval rules for commands and file changes. Review each proposed action before allowing it to run at first. The point of the trial is to assess whether MiMo can navigate the repository, use test feedback and produce a reviewable diff—not to hand an unfamiliar agent unrestricted access to a working codebase.