TL;DR
- Was Space Bunny Alpha, the anonymous OpenRouter model that served 14 trillion tokens on 21 October alone
- 428B total and 23B active; Hugging Face shows 220B because the NVFP4 experts are packed two per byte
- Best raw accuracy in its class at 56%, with a 93% hallucination rate against M3 18.4%
System Requirements
| RAM | Server class, 252 GB of weights across 48 shards |
| GPU | Multi-GPU server via vLLM, SGLang or TokenSpeed, not a single card |
| VRAM | Large; ships only as MXFP8 with NVFP4 experts, no BF16 checkpoint, 19 community quantizations exist |
For ten days in October, the most-used model on OpenCode had no name. It was listed as "Space Bunny Alpha," provider "Stealth," and on 21 October it burned through 14 trillion tokens in a day, roughly a third of everything the platform served. MiniMax claimed it as M3.1 Flash on 19 October and published the weights today. The model card says 428B parameters, Hugging Face's own file counter says 220B, and both numbers are correct.
First, the name, because MiniMax made this hard again
M3.1 Flash is not MiniMax M3, though it is built on it, and it is definitely not MiniMax Music 3, which shares nothing but a numeral. M3 is still served. Before you pull 252 GB, check which repo you are pointed at.
What shipped
MiniMax launched M3.1 Flash as an API-only model on 19 October and published the weights four days later. It is a natively multimodal mixture of experts taking text, images and video and returning text, with a 1,048,576-token context. The API id is MiniMax-M3.1-Flash at $0.15 per million input tokens, $0.60 per million output and $0.015 cached. The download is 252 GB across 48 shards plus a separate 2.3 GB drafter.
Where the 220B comes from
The card says "approximately 428B total; 23B activated per token." The file-info box on the same page says 220B params. The card does not explain the gap, so here is the arithmetic from config.json.
The model has 60 layers at a hidden size of 6144. The first three are dense at an intermediate size of 12288; the other 57 are MoE layers holding 128 experts each at 3072, routing 4 per token plus one shared expert. Vocabulary is 200,064 and the output head is untied.
| Component | Total weights | Active per token |
|---|
| Routed experts (57 layers x 128) | 413.1B | 12.9B |
| Shared experts and routers | 3.3B | 3.3B |
| Attention (60 layers) | 6.4B | 6.4B |
| Sparse attention index branch | 0.2B | 0.2B |
| Dense MLP (first 3 layers) | 0.7B | 0.7B |
| Embedding and output head | 2.5B | - |
| Vision tower and projector | 0.7B | - |
| Total | ~427B | ~23.5B |
So the card is right, and the 220B is a packing artefact. quantization_config sets moe_quant_format to nvfp4-pack-quantized, which stores two 4-bit expert weights in every uint8 element. Halve the 416.4B sitting in expert layers, add back the 10.4B that is not packed, and you get 218.7B. Hugging Face is counting tensor elements, not weights.
The control proves it. M3's config is architecturally identical, same 60 layers, same 6144 hidden, same 128 experts, same vocabulary. It carries no quantization_config at all and a torch_dtype of bfloat16. Hugging Face displays M3 as 427B.
Which gets us to the part that matters if you plan to serve this: there is no BF16 checkpoint. The file types in the repo are F32, BF16, F8_E4M3 and U8, with the experts in that last one. MiniMax did quantization-aware training on the routed experts and attention paths, then shipped only the quantized result. The 4-bit build is not a convenience upload alongside the real weights, it is the release.
What actually changed from M3
Less than the version number suggests, and the changes are all about serving cost rather than capability.
| Property | M3 | M3.1 Flash |
|---|
| Layers / hidden size | 60 / 6144 | 60 / 6144 (same) |
| Experts / active per token | 128 / 4 + 1 shared | 128 / 4 + 1 shared (same) |
| Vocabulary / context | 200,064 / 1M | 200,064 / 1M (same) |
| Sparse attention layers | 57 of 60 | 60 of 60 |
| Quantization | none, bfloat16 | MXFP8 with NVFP4 experts, QAT |
| Speculative decoding | EAGLE-style MTP | DSpark drafter |
M3 kept its first three layers on full attention. M3.1 Flash makes all 60 sparse, which you can read straight off sparse_attention_freq: three zeros in M3's config, sixty ones in this one. That is the whole architectural delta, and MiniMax reports it as roughly 3x faster than its predecessor.
DSpark, the drafter nobody has documented
The dspark/ directory holds a separate 2.3 GB model named DSparkMiniMaxDraftModel. It is a 5-layer MoE at the same 6144 hidden size and the same 128 experts, drafting in blocks of 7 tokens. Rather than running independently it reads hidden states from layers 3, 17, 31, 45 and 59 of the target model, and carries a confidence head to decide when a draft is worth proposing. Its config sets use_mtp to false and num_mtp_modules to zero, so this replaces multi-token prediction rather than adding to it.
The gotcha: nothing documents how to turn it on. The vLLM and SGLang commands on the card serve the main model and mention no draft model or speculative decoding flag.
MSA, and the number not to transfer
The mechanism is MiniMax Sparse Attention, published in June: an index branch scores blocks of keys and values, picks a top-k subset per attention group, and a main branch runs exact attention over only those. The paper claims 28.4x less per-token attention compute at 1M context and 14.2x faster prefill on H800s. Both were measured on a 109B model, not this 427B one, so do not carry them across.
The benchmarks, and the independent read
On its own card it leads Automation-Bench v1.0.6 at 62.8, takes LOCA-Bench 256K at 60.3, and ties Claude Opus 5 at 76.2 on BankerToolBench. Artificial Analysis measured Automation-Bench at 62.2 instead, close enough to be a harness difference and far enough to quote both. Then there is the comparison the launch coverage skipped: we covered DeepSeek-V4.1-Flash-1017 four days ago, and it sits on MiniMax's own table.
| Benchmark | M3.1 Flash | DeepSeek V4.1-Flash-1017 | Opus 5 |
|---|
| Automation-Bench v1.0.6 | 62.8 | 60.5 | 50.3 |
| LOCA-Bench 256K | 60.3 | - | 53.7 |
| Terminal Bench 4.0 | 38.1 | 42.3 | 51.8 |
| DeepSWE v1.1 | 73.7 | 77.0 | 74.0 |
| NL2Repo-Bench | 61.2 | 68.2 | 75.3 |
| AA Intelligence Index | 42 | 45 | - |
| AA cost per task | $0.22 | $0.26 | - |
Artificial Analysis puts it at 42 on its composite index, level with GLM-5.3 Flash and behind DeepSeek at 45. Against its own predecessor the jump is large: M3 scored 29 at about $0.51 per task, so this is 13 points better at 57% less cost. Humanity's Last Exam went from 39% to 48%, CritPt from 4% to 22%.
The honest summary: this is not the smartest flash model available, it is the cheapest one at this capability level. The cost-per-task figure makes that case better than the benchmark table does.
Credit where it is due: the harness is disclosed
Four days ago we argued that DeepSeek should publish which harness produced each benchmark row, because it had quietly changed one between releases and carried the old number forward. MiniMax's card does exactly that: harness per benchmark, including Claude Code versions, context lengths and judge models, plus a note that results are for the official weights and third-party quantizations may differ. It also ships a chat template, which the DeepSeek release pointedly does not. Two labs, four days apart, opposite choices on the same question, and the harness problem turns out to be solvable with three extra lines in a model card.
It almost never says "I don't know"
Here is the finding that should govern how you deploy it. On Artificial Analysis's AA-Omniscience benchmark, M3.1 Flash has the best raw accuracy in its class at 56%, ahead of DeepSeek V4.1 Flash-1017 at 43% and GLM-5.3 Flash at 28%. Its hallucination rate is 93% and its Omniscience score is 16.
That 93% is not the share of answers that are wrong. It is the share of its non-correct responses that were confident inventions rather than partial answers or refusals, and M3's equivalent figure was 18.4%. The model got substantially more knowledgeable and roughly five times less willing to admit a gap.
The defaults make that worse: MiniMax's docs say reasoning_effort starts at max and thinking cannot be disabled, only turned down. Put this behind anything resembling a factual lookup and you want the effort down and the output gated.
About those 200 trillion tokens
Every launch writeup quotes a usage figure, and they do not agree with each other. We have seen 1 trillion, 56.7 trillion, 100 trillion and 200 trillion, all for the same model in the same week. OpenCode publishes a per-model dashboard, so this is checkable.
| Figure | Where it comes from | What it actually is |
|---|
| "over 200 trillion tokens" | MiniMax | Company total across all testing, unaudited |
| 186.5 trillion | OpenCode dashboard | Cumulative on one platform, 23 Sep to 23 Oct |
| 14 trillion in a day | OpenCode dashboard | Peak day, 21 Oct, against a platform record of 40T |
| 92 billion | OpenCode dashboard | Today, with DeepSeek V4.1 Flash back on top at 12T |
The last row is the interesting one. Traffic went from 14 trillion tokens a day to 92 billion, and the OpenRouter listing explains why in one sentence: "The free stealth period has ended." Today's figure is partial, read mid-afternoon, but no partial day accounts for a drop that size.
Which reframes the engagement story. The 186.5 trillion tokens were real and almost entirely free. A stealth launch is not just anonymous marketing: it is load testing and bug reports that users pay for in time and the lab gets for the price of the inference. By OpenRouter's provider-reported account, the anonymous run produced fixes that cut time to first token and roughly halved the error rate before anyone knew whose model they were filing issues against.
What the licence actually says
This is open weights. It is not open source, and several outlets have it wrong.
The MiniMax Community License grants use, modification and distribution for non-commercial purposes. Commercial use is defined broadly enough to include paid products, hosted APIs and deploying your own fine-tunes. Under $20 million in annual revenue you send a one-time notice to MiniMax; over it, you need prior written authorisation before you ship. Either way you must display "Built with MiniMax M3.1-Flash" where a user can see it, and the prohibited-use appendix rules out military applications entirely.
That is the third release this month to gate at exactly $20 million, after Meta's Muse Spark Open and Datalab's Indra OCR. Three labs, one threshold. If your company might plausibly cross it, licences are now a per-model dependency to track, not a thing you check once.
Our June scorecard
Our M3 piece was headlined "Open Weights Pending," and it complained that the weights were undownloadable, the licence unpublished, and every benchmark run by MiniMax on MiniMax hardware. Two of those three are now fixed: the weights shipped four days after the API, and the licence is in the repo. The third is better, because Artificial Analysis publishes independent numbers now and they are less flattering than MiniMax's.
Running it
252 GB is the floor, and the official paths are vLLM, SGLang and TokenSpeed, all exposing an OpenAI-compatible endpoint.
vllm serve "MiniMaxAI/MiniMax-M3.1-Flash"
Or through Docker Model Runner, which is the shortest route to poking at it:
docker model run hf.co/MiniMaxAI/MiniMax-M3.1-Flash
Recommended sampling is temperature=1.0 and top_p=0.95. Transformers, KTransformers, unsloth and ATOM support are listed as in progress, and there are already 19 community quantizations if you want a smaller build for llama.cpp, Ollama or LM Studio. Set reasoning_effort explicitly on every call: left alone it runs at max and bills you for a full reasoning trace at $0.60 per million output tokens.
Who should care
Serve it if you want the cheapest credible agentic model with a 1M context and have 252 GB of GPU memory to point at it. Automation-Bench and LOCA-Bench are where it genuinely leads, and both are long-horizon agent benchmarks rather than single-shot ones.
Stay on DeepSeek if your work looks like Terminal-Bench, DeepSWE or repository-scale code generation. It wins all three, it is three points ahead on the composite index, and it is MIT rather than non-commercial.
Do not put it near factual retrieval without a gate. A 93% confident-error rate on misses is a product risk, not a benchmark footnote, and the default settings push it in exactly the wrong direction.
One last thing for anyone who watches the stealth slots. Ox Alpha is live on OpenRouter right now, 1M context, reasoning, coding, no lab attached. We used that name before, in August, for a cloaked model that turned out to be GLM-5.3-Flash, so OpenRouter is recycling codenames and this is a different model wearing an old one. It is the next to work out.
Sources and further reading
Your under-ten-minutes move: open the OpenCode dashboard, find M3.1 Flash, and compare its 21 October column against today's. That one chart tells you more about how stealth launches actually work than any launch post will, and it takes about two minutes to read.
Tested on: not independently tested. Benchmark figures, parameter counts and speed claims are MiniMax-reported and were read from the Hugging Face model card on the date below, except the Intelligence Index, cost-per-task and AA-Omniscience figures, which are Artificial Analysis measurements reported by VentureBeat. Parameter totals above were computed from the published config.json. Token-volume figures were read from the OpenCode public dashboard, where the current day is partial. The stealth-period latency and error-rate improvements are OpenRouter-reported and not independently verified.
Date checked: 2026-10-23
