Uncensored MiMo API at 8-Bit Fidelity

Most catalogs sell you parameter count. That is the wrong number to shop on, because every large open-weights model you can actually afford has been compressed to fit somewhere. The honest question is not "how big was this before it was squeezed?" but "how much of it is still here?" This article is about that question, and about the model in our lineup where the answer is almost all of it.

01What the uncensored MiMo API actually gets you

The uncensored MiMo API is one model id, MiMo-V2.5-Pro-W8A16, reachable through three dialects that address the same weights on our own GPU cluster: /v1/chat/completions, /v1/messages and /v1/responses. All three stream and support tool calling and reasoning.

Uncensored has a narrow meaning here: no refusal layer in front of the model, no filter on its output. We do not intercept, classify or rewrite. You get the foundation's own behavior — which for a research-grade open-weights model means it engages with security research, adult or violent fiction, medical and legal reasoning, and the requests hosted commercial endpoints decline by reflex. It is a professional tool under our Responsible Use Policy, not an absence of rules.

02The MiMo lineage: Xiaomi's bet on reasoning-first pretraining

MiMo is not a Llama derivative with a new name; it is a distinct lineage from Xiaomi's MiMo team, and its founding idea matters before you evaluate the model. It opens with MiMo-7B (April 30, 2025, MIT-licensed), whose technical report argues that most labs treat reasoning as a post-training problem to be bolted on with RL, and that this is backwards. Xiaomi restructured pretraining around it instead: a three-stage mixture across 25 trillion tokens, stage two running roughly 70% mathematics and code, stage three folding in synthetic reasoning traces while extending context from 8K to 32K — plus a Multi-Token Prediction objective that doubles as a speculative-decoding head.

The result was a 7B base model that behaved like something far larger. MiMo-7B-Base scored 32.9 on AIME 2024 where Qwen2.5-7B scored 10.1, Gemma-2-9B 0.0 and Llama-3.1-8B 0.3. Post-training then ran RL over 130,000 verifiable math and code problems with a test-difficulty-driven code reward, escaping the sparse-reward trap that destabilizes code RL. The result landed ahead of o1-mini:

AIME 2025, Xiaomi-reported figures from the MiMo technical report (arXiv:2505.07608). MiMo-7B-RL also reported 95.8 on MATH-500 and 57.8 on LiveCodeBench v5.

The family widened rather than drifted: MiMo-VL-7B (June 2025) put a Qwen2.5-ViT encoder on the same backbone, and December 2025 brought MiMo-Audio-7B plus the first MoE entry, MiMo-V2-Flash (309B total / 15B active, 27T tokens, FP8 mixed precision). MiMo-V2-Pro followed in March 2026 at roughly 1T / 42B active with a 1M context, after weeks on OpenRouter as "Hunter Alpha". MiMo-V2.5 and MiMo-V2.5-Pro shipped together on April 22, 2026, both MIT.

03Inside MiMo-V2.5-Pro: what the foundation looks like

Per Xiaomi's published model card, MiMo-V2.5-Pro is a sparse Mixture-of-Experts model with 1.02 trillion total parameters and 42 billion active per token across 70 layers — one dense, 69 MoE — and 384 routed experts, 8 per token. Hidden size is 6144, with a narrow MoE intermediate size of 2048.

Two choices shape how it feels in use. The attention stack is hybrid: 10 full-attention layers and 60 sliding-window layers with a window of 128, plus a learnable attention-sink bias. Xiaomi reports this cuts KV-cache storage close to 7x versus all-global attention while holding long-context quality — the difference between a window that is nominally long and one you can afford to fill. It also ships three Multi-Token Prediction layers, giving the decoder a speculative head.

Training was 27 trillion tokens at a native 32K sequence length in FP8 (E4M3) mixed precision, then supervised fine-tuning, large-scale agentic RL and multi-teacher on-policy distillation. Hold on to that FP8 detail; it is the strongest single argument for serving this foundation at 8 bits.

Xiaomi reports the model at 57.2% on SWE-bench Pro, 72.9 on τ3-Bench for tool use and 48.0% on Humanity's Last Exam — the vendor's own numbers on the uncompressed model, quoted as such.

We serve a 262,144-token window, not the foundation's full 1M — a context we can guarantee at speed, rather than a headline number that degrades under load.

04What W8A16 means, precisely

Every model in this catalog carries a quantization suffix describing an actual, measurable transformation rather than a marketing tier. Ours are 3BIT-REAP, W4A16-AUTOROUND-REAP and W8A16. MiMo-V2.5-Pro is the third.

The notation splits in two. W8 is weight precision: every parameter is stored as an 8-bit integer instead of a 16-bit float, with a shared scaling factor per small group so each group's local dynamic range survives. A16 is activation precision: values flowing between layers at inference stay at 16 bits. Weights get compressed; the arithmetic does not.

That second half does quiet, important work. Activations are much harder to quantize than weights: they contain extreme outlier channels — a few dimensions whose magnitudes dwarf everything else and which carry a disproportionate share of the model's behavior. Push those to low precision and you clip exactly the signal you needed. Weight-only schemes sidestep the problem by leaving the activation path alone, which is why serious quantization work has converged on them.

So the practical question narrows to one thing: how few bits can a weight tolerate?

05W8A16 vs W4A16 vs 3-bit: where the loss actually goes

The largest published study on this is Neural Magic and Red Hat's "Give Me BF16 or Give Me Death"? Accuracy-Performance Trade-Offs in LLM Quantization — over 500,000 evaluations across the Llama-3.1 family at 8B, 70B and 405B. Their headline result, in their numbers:

Format	What is compressed	Reported recovery vs BF16
W8A8-FP (8-bit)	Weights + activations, float	~99.75% avg — "essentially lossless"
W8A8-INT (8-bit)	Weights + activations, integer	99–100% at 8B/70B; 98.2–99.3% at 405B
W4A16-INT (4-bit)	Weights only	98–99.4% (8B); 98.6–99.8% (70B)

Figures reported by Neural Magic / Red Hat (arXiv:2411.02355) on Llama-3.1 models — the shape of the trade-off, not this model's score.

Read honestly, that looks like an argument against caring: 4-bit recovers 98–99%, so why pay attention? Because those are academic multiple-choice benchmarks, close to the worst available instrument for detecting quantization damage. A benchmark question has one right answer reachable in one or two tokens, and quantization error is small, roughly zero-mean noise on every logit; on a short question with a wide margin, that noise is absorbed.

Now write 4,000 tokens of a technical document, hold a voice across a 40,000-token story, or emit JSON that must validate first try. The same noise is sampled thousands of times in sequence, each sample conditioning the next. The failure mode is not a wrong answer — it is drift: a loosening grip on the instruction from turn one, a character who stops sounding like himself around token 3,000, a closing brace that never arrives.

Where the bits actually go

Quantization error is not spread evenly across a model's abilities; it concentrates in the tail. High-mass behaviors — grammatical English, the shape of a Python function, the top thousand facts about the world — are encoded redundantly across many weights and survive almost anything. The precisely-tuned, small-magnitude corners of the weight distribution hold the rare stuff: an obscure API's exact signature, a specific author's cadence, the difference between two adjacent CVEs. Those are the values a coarse grid rounds into each other.

The step from 4 bits to 3 is where this stops being a tax and becomes a cliff. Dettmers and Zettlemoyer's k-bit inference scaling laws found 4-bit to be the point that maximizes zero-shot accuracy per bit of model memory, with degradation dominating below it. Four bits gives 16 levels per group; three gives 8. You are halving the resolution of an already coarse grid, and the round-off error per weight roughly doubles.

The arithmetic that decides it

The comparison worth making is arithmetic, not a benchmark. What survives compression is approximately parameters × bits per parameter — the information-bearing volume of the weight file. Take two hypothetical foundations of equal quality per parameter:

• Foundation A: 400B parameters at 3 bits → roughly 150 GB of retained weight.
• Foundation B: 160B parameters at 8 bits → roughly 160 GB of retained weight.

By raw parameter count A wins two and a half to one — the number the model card leads with. By retained information they are equivalent, and B has a structural advantage besides: its weights sit on a grid fine enough that its tail behavior is intact, whereas A's tail has been quantized into the bulk. A knows more things; B knows what it knows more sharply. For long generation, exact formatting, stylistic control and faithful long-context adherence, take B.

Illustrative arithmetic, not a benchmark: it shows why "bigger foundation" and "better served model" are different claims.

06Why 27 trillion training tokens make aggressive quantization worse

A second, less intuitive result bears directly on this foundation. Kumar et al.'s ICLR 2025 paper Scaling Laws for Precision finds that the more data a model was trained on, the more damage post-training quantization does to it. Low precision reduces a model's effective parameter count, and that degradation grows with the pretraining data absorbed — far enough that extra pretraining data can be net harmful if you intend to quantize aggressively, because you are laying down fine structure the grid will erase.

A model trained on 5T tokens has coarse, redundant weight structure and slack to spare. A model trained on 27T tokens — MiMo-V2.5-Pro's budget — spent that extra data writing finer distinctions into more precise weight values, which is exactly what a 3-bit grid cannot represent.

Then there is the FP8 fact from section 03, the cleanest argument in this article. MiMo-V2.5-Pro was pretrained in FP8 mixed precision. Its weights were shaped from the start by an optimizer working at roughly eight bits of precision. Serving it at 8-bit weights is therefore not a lossy afterthought imposed on a 16-bit model — it is close to returning the weights to the numeric regime they were learned in. Little fine structure exists below the eighth bit to lose. The same cannot be said of those weights forced down to three.

07REAP: why expert pruning is a different kind of loss than rounding

Two of the three tiers carry a REAP suffix — a categorically different operation from quantization. REAP (Router-weighted Expert Activation Pruning, Cerebras Research, arXiv:2510.13999, ICLR 2026) is one-shot compression for sparse MoE models: it scores each expert by the router's gate values and the expert's activation norm, then deletes the lowest scorers. Cerebras report near-lossless results on code generation and tool calling even at 50% of experts pruned.

We use REAP for the reason it exists: on the largest foundations it is what makes them servable. But note the difference in kind. Quantization blurs every weight a little; pruning removes experts entirely. If your workload routes heavily to a capability that lived in a rarely-selected expert — a minor programming language, a specialized vocabulary — it is not degraded. It is gone, and no prompting recovers it. The averages stay excellent; your tail case may not.

MiMo-V2.5-Pro · W8A16 carries no REAP suffix. All 384 experts are present, and the router chooses from the full set the foundation was trained with.

Tier	Weight bits	Experts	What you trade
W8A16	8	All present	Nothing structural. The fidelity tier.
W4A16-AUTOROUND-REAP	4	Pruned	Fine weight detail plus low-traffic experts, in exchange for a much larger foundation in the same price band.
3BIT-REAP	3	Pruned	Substantial weight resolution plus low-traffic experts — the price of running the very largest foundations at speed.

The middle tier deserves a fair hearing. AutoRound is not naive rounding: Intel's method (arXiv:2309.05516) uses signed gradient descent over roughly 200 steps to tune the rounding decisions and the clipping range per weight group, and is reported near-lossless at 4 bits in most settings, beating GPTQ, AWQ, HQQ and OmniQuant across most tested configurations. A W4A16-AUTOROUND model is a genuinely good 4-bit model. It is still a 4-bit model.

08Who should pick the 8-bit tier — and who shouldn't

MiMo-V2.5-Pro · W8A16 sits at the floor price of the entire catalog — $0.50 in / $2.00 out per million tokens, the same band as the entry-tier 4-bit models and roughly a quarter of the input price of the most expensive model we serve. You are not paying a premium for fidelity; you are choosing a different axis of the same budget.

Pick it when

• Output length is the job. Long-form technical writing, chapter-length fiction, full documentation passes — every generated token is one where compression noise compounds.
• Voice and consistency matter. Character work, brand tone, a register held across a long session. Style lives in the tail, and the tail is what coarse quantization eats first.
• Structured output must validate first try. The model supports json_schema and response_format; schema adherence is a precision property, and every retry avoided is money and latency saved.
• You are filling the context. Instruction adherence at token 200,000 is harder than at token 2,000, and it degrades with weight precision — as does a long reasoning trace, where errors compound the same way.
• The work is uncensored by nature. Security research, red-teaming, unfiltered fiction, sensitive medical or legal analysis — where a hedged answer is worse than none.

Pick something else when

• You need vision. This model is text-only; its sibling MiMo-V2.5 · W8A16 is vision-capable at the same price and tier.
• You need the broadest world knowledge on short queries. That is the regime where a much larger 3-bit foundation's extra parameters win and its quantization damage barely shows.
• Your workload is high-volume short classification. Quantization damage is nearly invisible there — buy whatever is fastest.

09Calling the uncensored MiMo API

If your code targets the OpenAI SDK, changing the base URL and model id is the entire migration:

curl https://api.shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer $SHANNON_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiMo-V2.5-Pro-W8A16",
    "messages": [
      {"role": "user", "content": "Draft the threat model section."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 16384,
    "stream": true
  }'

/v1/messages and /v1/responses accept the same id and capabilities. Parameter reference, tool-calling schemas, structured-output examples and a live playground are in the Shannon AI API documentation.

Capability	MiMo-V2.5-Pro · W8A16
Context window	262,144 tokens
Max output per request	16,384 tokens
Streaming	Yes — all three dialects
Tool calling	Yes
Reasoning / reasoning_effort	Yes
json_schema structured output	Yes
response_format	Yes
Vision / image input	No — use MiMo-V2.5
Refusal layer / output filter	None
Price per 1M tokens	$0.50 in / $2.00 out

10Frequently asked questions

---

Sources: MiMo technical report, arXiv:2505.07608 · MiMo-V2.5-Pro model card (Xiaomi) · "Give Me BF16 or Give Me Death"?, arXiv:2411.02355 · REAP the Experts, arXiv:2510.13999 · AutoRound, arXiv:2309.05516 · k-bit inference scaling laws, arXiv:2212.09720 · Scaling Laws for Precision, Kumar et al., ICLR 2025. All benchmark figures are as reported by their authors. Shannon AI is a product of Shannon Lab LLC, New Mexico, USA.