MiniMax M3.1 Flash Open Weights: 428B Coding Model, 1M Context — Can You Actually Run It?

Nothing here is sponsored — no affiliate links on this page. Every link goes to official docs or the launch reporting we cite.

MiniMax released the open weights for M3.1 Flash on October 23, 2026 — four days after the model went live on its API. The spec sheet demands attention: 428B total parameters in a mixture-of-experts design with only 23B active per token, a 1M-token context window, and native text, image, and video input, tuned for coding, AI agents, and computer-use tasks. We dug through the release materials and launch-week reporting to separate the real deal from the marketing. Here's the spec sheet, the hardware math nobody puts in the headline, the license decoded into plain English, and the fair comparison against DeepSeek V4.1-Flash, which launched six days earlier.

What actually dropped

The spec sheet, straight from MiniMax's release:

• 428B total parameters, MoE, 23B active per token. Sparse enough that inference costs stay sane — if you have the GPUs.
• 1M-token context. Full-repo agents and long-horizon computer-use tasks are the target, not chat.
• Native multimodal input. Text, image, and video all go in directly — relevant for computer-use agents that need to see screens and screencasts, not just read DOM dumps.
• Built for coding and agents. MiniMax's positioning is explicit: a workhorse model for agentic coding, not a generalist chatbot.

Under the hood, the engineering reads like a cost-cutting manifesto: full-model sparse attention, quantization-aware training (QAT), power-aware scheduling, and speculative decoding via MiniMax's DSpark recipes. The FP8 checkpoint lands at roughly 220GB. MiniMax also reports that real users pushed over 100 trillion tokens through the API in its first 72 hours — an official claim, not an independent measurement, but it tells you the API demand is serious.

On benchmarks, MiniMax reports (vendor-run, so handle with gloves): 73.7% on DeepSWE v1.1, 61.7 on OSWorld 2.0, and 82.2 on CyberGym. The DeepSWE number is the one that matters for coding credibility — and it's the number we come back to in the DeepSeek comparison below.

Day-one ecosystem support is unusually complete: vLLM, SGLang, and Docker Model Runner all ship with support, community quants for llama.cpp, Ollama, and LM Studio were already circulating, Together AI offers hosted production inference, and roughly ten chip vendors — Huawei Ascend, NVIDIA, AMD among them — announced support. Community reports say the model serves on 4x NVIDIA DGX Spark with TP4 under vLLM. That last detail matters a lot. Here's why.

Can you actually run it? The hardware math

Let's be blunt. 428B parameters at FP8 is ~220GB of weights. That's the checkpoint size — before KV cache, before activations, before any context actually gets loaded. A 1M-token context on a model this size will eat VRAM for breakfast even with sparse attention.

The community's working answer: 4x NVIDIA DGX Spark, tensor-parallel across all four, served with vLLM. Each DGX Spark is a roughly $4,000 desktop-class AI box. So the realistic self-hosted floor is somewhere around $16,000 of hardware — and that's the cheap path, reported by the community, not a vendor recommendation. Datacenter GPUs (H100/H200 clusters) will serve it more comfortably and cost you far more.

What about quants? Community quantization for Ollama and LM Studio lowers the bar, but a 428B model doesn't quantize down to laptop territory. Even aggressive quantization leaves you with 100GB+ of weights, and quantization shaves capability exactly where you bought this model: precise coding and long-horizon agentic reasoning. Running a heavily quantized 428B model to save on hardware is like buying a race car and running it on two cylinders — at some point the smaller dense model you could run at full precision wins.

The honest segmentation:

• You have a GPU fleet or a lab budget: download the weights, run vLLM or SGLang, fine-tune to your heart's content. This release is for you.
• You're an indie dev or small team: the API at $0.15 per 1M input / $0.60 per 1M output is the rational move. That's aggressively cheap for a model in this class — run the math in our AI API Cost Calculator — and it sidesteps the entire hardware conversation.
• You're on a laptop: enjoy the community quants as an experiment, but don't build production on them.

And note what this means: "open weights" at this scale is mostly a gift to people who already have serious compute. The rest of us get cheaper API pricing as the downstream effect. That's fine — it's still a good deal — but don't let the word "open" convince you the model is free to run.

The license, decoded: "open weights" is not "open source"

This is the section most launch coverage will skim. Don't skim it.

M3.1 Flash ships under the MiniMax Community License — not Apache 2.0, not MIT. Here's what it actually says, in plain language:

• Under $20M in annual revenue: commercial use is allowed. Two conditions: (1) you send MiniMax a notification email, and (2) you display a clearly visible "Built with MiniMax M3.1-Flash" credit on your product.
• Over $20M in annual revenue: you need written authorization from MiniMax. That's a negotiation, not a checkbox — terms can change at that point.
• Military uses: prohibited. Full stop.

What this means in practice: if you're an indie hacker or an early-stage startup, the license is generous — genuinely free commercial use with an attribution line and an email. The credit requirement is the real tax: "Built with MiniMax M3.1-Flash" has to be visible on your product, which is a branding decision you'll live with. If you're a funded company on a growth trajectory, that $20M line is a cliff you need to plan around — your licensing cost at scale is "whatever MiniMax decides," and you won't know until you ask.

One more distinction worth making: this is open weights, not open source. The weights and inference recipes are public; the training data, full training pipeline, and everything else stay with MiniMax. MiniMax isn't hiding this — the license name says "Community," not "Open Source" — but the headlines will say "open-sourced" anyway. Now you know the difference.

M3.1 Flash vs DeepSeek V4.1-Flash: the six-day gap

The timing is the story here. DeepSeek launched V4.1-Flash on October 17 — six days before MiniMax's weights dropped. Both are "flash"-class efficiency models aimed at coding and agents. Both sets of benchmark numbers are vendor-run.

The headline comparison: DeepSeek reports 77.0 on DeepSWE v1.1; MiniMax reports 73.7. That's a 3.3-point gap in DeepSeek's favor on the one benchmark both vendors trumpet for coding. (We covered DeepSeek's launch in Gemini 4 Argon vs DeepSeek V4.1 Flash.)

Three caveats before you treat that gap as gospel:

• Both numbers are vendor-run. Neither has been independently reproduced on a shared harness as of this writing. A 3.3-point gap on vendor numbers is directional, not decisive — harness differences alone can move scores by that much.
• Different strengths. MiniMax's pitch leans harder on computer-use and multimodal input (native video in!) plus the 1M context. DeepSeek's pitch is raw coding efficiency. If your workload is "agent that watches a screen and clicks things," the spec sheets point different directions than DeepSWE alone.
• License and ecosystem differ more than the scores do. DeepSeek's licensing history is permissive; MiniMax's Community License has the $20M clause and the credit requirement. For a startup choosing a base model to build on, the legal terms will outlive any 3-point benchmark gap.

Our take: if you need the best vendor-reported coding score this week, DeepSeek's number is higher. If you need 1M context with native video input for computer-use agents, MiniMax's spec sheet is more interesting. Either way, wait for independent evals before making architecture decisions on vendor numbers — both vendors are marketing.

The pattern worth noticing: API first, weights days later

M3.1 Flash hit the API on October 19; weights landed October 23. Four days. And it wasn't alone — MOSS-Image did the same "API now, weights days later" move this same week.

This is the new default playbook, and it's worth understanding why vendors do it: the API window generates real usage data (MiniMax's 100T-tokens-in-72h claim is exactly the kind of number that comes out of this), stress-tests serving infrastructure, and lets the vendor tune the release — all before the weights go public and the story becomes about self-hosting. The weights are increasingly a delayed artifact of an API business, not the product itself.

For developers, the implication is practical: when a model launches API-only, start your evaluation on the API immediately. The weights will follow, and by the time they do, you'll know whether the model is worth the hardware conversation at all.

What we'd actually do

Evaluating coding/agent models this week? Start on the API — $0.15/$0.60 per 1M tokens makes experimentation nearly free. Benchmark it on your tasks, not the vendor's; the DeepSWE gap to DeepSeek is directional until someone reproduces both on one harness.

Planning to self-host? Budget the hardware honestly (~$16K floor per community reports) and read the Community License before you ship — the notification email and visible credit are easy to miss, and the $20M line is a cliff, not a slope.

Building computer-use agents? The native video input and 1M context are the genuinely differentiated specs here. That's the workload where M3.1 Flash's spec sheet beats the benchmark conversation.

The bottom line: a serious model with a serious spec sheet, a genuinely permissive license for small players, and a hardware reality that keeps it in well-GPU'd hands. Download it if you have the iron. API it if you don't. And read the license before you ship — the $20M clause and the credit line are the parts of this release that will actually touch your business.

FAQ