MiniMax just dropped the open weights for a 428B-parameter coding and agent model — and the fine print matters more than the headline. M3.1 Flash went live on MiniMax's API on October 19, and the weights followed on October 23 via Hugging Face and ModelScope. The numbers are genuinely impressive: 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.
Here's the honest read before we go further: this is the most capable open-weights coding/agent model you can download this week — and most of you will still end up using the $0.15/$0.60 API instead of self-hosting. The hardware bill is brutal, the license is not Apache, and the benchmark gap to DeepSeek's rival is real. Everything below walks through what dropped, what it costs to actually run, what the Community License lets you do, and how it stacks up. No hands-on testing claims here — I haven't deployed the weights myself. This is researched analysis from MiniMax's release materials and launch-week reporting, stated plainly.
Reader note: I write these breakdowns from release docs and verified reporting — no affiliate links in this one, every link goes to an official page or the coverage I cite.
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 here, 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: this is 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'll come back to in the DeepSeek comparison.
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. We'll get to it.
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 ~$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 — cheaper than most frontier APIs by a wide margin — 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 (reportedly) inference recipes are public; the training data, full training pipeline, and everything else stay with MiniMax. By the OSI's definition, that's not open source. 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.
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.
My 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.
FAQ
Is MiniMax M3.1 Flash really open source?
No — it's open weights under the MiniMax Community License, not open source. Commercial use is allowed under $20M annual revenue with a notification email to MiniMax and a visible "Built with MiniMax M3.1-Flash" credit; above $20M requires written authorization. Military use is prohibited. The weights are public; training data and pipeline are not.
Can I run M3.1 Flash on my laptop?
Realistically, no. The FP8 checkpoint is ~220GB. Community reports put the practical floor at 4x NVIDIA DGX Spark with tensor parallelism under vLLM — roughly $16K in hardware. Community quants for Ollama/LM Studio exist, but a 428B model stays heavy even quantized, and you lose capability exactly where this model is strongest.
What does the license cost a startup?
Nothing in cash under $20M/year in revenue — but you owe MiniMax a notification email and a visible product credit ("Built with MiniMax M3.1-Flash"). Above $20M, it's a negotiated written authorization. Plan for that cliff if you're growing fast.
Is it better than DeepSeek V4.1-Flash?
On vendor-reported DeepSWE v1.1: DeepSeek leads 77.0 to 73.7 — but both numbers are vendor-run and unreproduced, so treat the gap as directional. MiniMax counters with 1M context and native video input for computer-use agents. The bigger differences are licensing terms and ecosystem, not three benchmark points.
What's the cheapest way to actually use it?
The API: $0.15 per 1M input tokens and $0.60 per 1M output tokens. For anyone without a GPU fleet, that's the rational path — Together AI also offers hosted inference if you want a non-MiniMax endpoint.
Where do I get the weights?
Hugging Face and ModelScope, released October 23, 2026. Day-one serving support exists for vLLM, SGLang, and Docker Model Runner, with community quants for llama.cpp, Ollama, and LM Studio.
The bottom line: M3.1 Flash is a serious model with a serious spec sheet, a genuinely permissive license for small players, and a hardware reality that keeps it in the hands of the well-GPU'd. 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 affect your business.
Top comments (0)