MiniMax M3.1 Flash Is Open-Weight. Should You Self-Host It?

MiniMax launched M3.1 Flash through its API on October 19, and on October 23 (China time, which was the evening of October 22 here in Nashville) it published the model weights on Hugging Face. It's built for coding agents, computer use and multi-step automation, and the API price is $0.15 per million input tokens.

"Open weights" always gets the same question from clients: can we just run it ourselves and stop paying per token? I haven't run it yet. This post is the homework: what the model is, what the API really costs, what hardware the official serving guides call for, and what the license says about using it in a business.

• It's a 428B mixture-of-experts model with 23B active per token. It takes text, image and video input, puts out text, and has a context window of up to 1 million tokens.
• The API is cheap. $0.15 per million input tokens, $0.60 per million output tokens, and $0.015 per million cached input tokens.
• Self-hosting is not a laptop job. The weights are about 252 GB to download, and the official vLLM and SGLang guides start at four data center GPUs like NVIDIA's B200 or AMD's MI355X.
• The license isn't Apache 2.0. Business use is allowed, but you have to show a "Built with MiniMax M3.1-Flash" credit and send MiniMax a notice. Above $20 million in yearly revenue, you need written permission.
• For almost every small business, the API wins on cost. Self-hosting makes sense when the data can't leave your infrastructure, or when your volume is enormous.

Per the Hugging Face model card, M3.1 Flash is a native multimodal mixture-of-experts model with about 428 billion total parameters and 23 billion activated per token. That's the same trick as the Recursive Flint model I wrote about in running a local coding model on your laptop, just much bigger. Only a slice of the model does the work for each token, so it's fast for its size, but all 428B parameters still have to sit in memory.

MiniMax trained it with quantization in mind. The vLLM recipe says the checkpoint stores 8-bit (MXFP8) dense layers and 4-bit (NVFP4) experts, which is why the download is about 252 GB and not the 800+ GB a full 16-bit 428B model would need. It also ships a built-in draft model for speculative decoding, which MiniMax calls DSpark, to speed up output.

On its own API, MiniMax says output speeds reach 200+ tokens per second, with a median of 170+. It also says agent workloads cost 70% less than on the previous M3.

These are MiniMax's own numbers from the model card, so treat them as a starting point:

• DeepSWE v1.1: 73.7%. In MiniMax's comparison, Opus 5 scores 74.0 and DeepSeek V4.1 Flash-1017 scores 77.0.
• Terminal Bench 4.0: 38.1, behind Opus 5's 51.8.
• NL2Repo-Bench: 61.2, behind Opus 5's 75.3.
• CyberGym: 82.2, for vulnerability discovery and validation.
• OSWorld 2.0: 61.7, for computer use.

For an outside view, VentureBeat reports that Artificial Analysis gave it a 42 on its Intelligence Index, up from 29 for M3 and close to DeepSeek V4.1 Flash-1017's 45, at about $0.22 per evaluation task.

There's one finding I'd take seriously. On Artificial Analysis's AA-Omniscience test, M3.1 Flash got 56% of the factual questions right, but when it didn't know, it almost always guessed instead of saying so. That works out to a 93% hallucination rate under that test's definition. For coding, tests catch a lot of that. For an agent that updates records or answers customers, you need checks around it.

MiniMax lists flat pricing per million tokens:

• Input: $0.15
• Output: $0.60
• Cached input: $0.015

Here's an illustrative heavy day for one developer running a coding agent. Agents re-send a lot of context, so most input is cached:

• 50 million input tokens, 80% of them cached: 10 million uncached at $0.15 is $1.50, plus 40 million cached at $0.015 is $0.60.
• 2 million output tokens at $0.60: $1.20.
• Total: about $3.30 for the day.

Your mix will be different, but the point holds. At these prices, one developer's agent usage costs pocket change.

Here's what the official serving guides published for launch say:

• vLLM: The recipe requires vLLM 0.33.0 or newer and runs the model across four GPUs (tensor parallel 4) on NVIDIA GB200 or AMD MI355X. On GB200 that's half a node.
• SGLang: The cookbook covers NVIDIA B200, B300 and GB300, plus AMD MI350X and MI355X. Its validated memory setting is for four GPUs on B300 and on B200. B200 has 192 GB per GPU. Its high-throughput B200 recipe uses eight.
• Other chips: The model card points to FlagOS builds for nine chip vendors. Those are 8-bit (W8A8) versions, and an 8-bit 428B model needs well over 400 GB for the weights alone.

What doesn't fit: a laptop, a single workstation GPU, or even a 128 GB unified-memory machine like the NVIDIA RTX Spark laptops. The weights alone are about twice that, before you count the memory for context.

The software is brand new, too. The SGLang cookbook says M3.1 support isn't merged into SGLang's main branch yet. You install from a pull request or use a dev Docker image, and Blackwell GPUs need MiniMax's sparse attention kernels and CUDA 13.4. Transformers support is listed as still in progress. This will settle down, but on day one it's a project, not a one-liner.

Say you rent the smallest setup the guides support: four B200 GPUs. As of October 22, GPU Economy lists a median B200 rate of $7.50 per GPU-hour across 35 providers. GetDeploying's cheapest in-stock on-demand rate is $3.75.

• Median rate: 4 × $7.50 = $30 an hour, or about $720 a day and $21,900 a month if it runs nonstop.
• Cheapest listed rate: 4 × $3.75 = $15 an hour, or about $360 a day and $10,950 a month.

Now flip it. The $720 a day buys about 1.2 billion output tokens, or 4.8 billion uncached input tokens, through MiniMax's API. That's roughly 220 of the heavy developer days from the example above.

GPU rental isn't the whole bill, either. You're also paying for storage for a 252 GB model, someone to keep the serving stack running, and idle time when nobody's sending requests. The API bills you nothing when you're not using it.

So self-hosting doesn't win on price unless you're pushing billions of tokens a day around the clock. It wins on control.

• The data can't leave your infrastructure. Regulated data, client code under a strict contract, or anything you can't send to a third-party API, including one based in China.
• You need the model to stay the same. Hosted models can change under you. Your own copy of the weights doesn't.
• You already have the GPUs. If you're already paying for Blackwell or MI355X capacity, the math changes.
• You want to fine-tune it. The weights make that possible, but read the license first. Using a fine-tuned version commercially counts as commercial use.

For everyone else, use the API, or one of the hosting providers MiniMax lists as launch partners, and spend the time on your actual product.

The model card lists the license as the "MiniMax Community License." It's not Apache 2.0 like Flint's. Here's what it says:

• The base grant is for non-commercial use.
• Commercial use is allowed if you display "Built with MiniMax M3.1-Flash" on a related website, interface, blog post, about page or product docs.
• If the product makes under $20 million a year, you send MiniMax a one-time notice. Above that, you need written authorization first.
• "Commercial use" includes offering it to customers for a fee, commercial API use, and deploying a fine-tuned version for any commercial purpose.
• There's a list of prohibited uses, including any military purpose.

None of that is unusual for a big open-weight release, but it isn't "do whatever you want." If you're building it into a client product, read the whole license before you ship.

My daily setup is in my AI coding setup for October 2026. I'm not self-hosting a 428B model. The API price is low enough that I'll try it on a few well-defined tasks the same way I'd test Flint: write tests for one function, explain a legacy PHP include, and see how much fixing the output needs.

Open weights at this level are good news even if you never download them. They keep API prices honest, and they give businesses with real privacy requirements a serious option.

If you're a business in Nashville or anywhere in Middle Tennessee trying to decide between an API, a hosted provider, or running a model on your own hardware, I'll walk through the real costs with you. Here's what a free quote from me covers, or send me a message.

You can also email caleb@calebdorris.com or call or text (615) 914-1073. I usually reply within a couple of hours.

Is MiniMax M3.1 Flash open source?

The weights are public on Hugging Face, but the license isn't a standard open source license. It's the MiniMax Community License, which allows commercial use with a "Built with MiniMax M3.1-Flash" credit and a notice to MiniMax, and it requires written permission for businesses over $20 million in yearly revenue.

How much does the MiniMax M3.1 Flash API cost?

MiniMax lists $0.15 per million input tokens, $0.60 per million output tokens and $0.015 per million cached input tokens.

Can I run MiniMax M3.1 Flash on my own computer?

Not realistically. The weights are about 252 GB, and the official vLLM and SGLang guides run it across four data center GPUs like NVIDIA B200 or GB200, or AMD MI355X. It won't fit on a laptop or a single workstation GPU.

What GPUs does MiniMax M3.1 Flash need?

The vLLM recipe uses four GPUs on NVIDIA GB200 or AMD MI355X. The SGLang cookbook covers NVIDIA B200, B300 and GB300 and AMD MI350X and MI355X, with four GPUs as the smallest validated setup. FlagOS publishes 8-bit builds for other chips.

Is it cheaper to self-host MiniMax M3.1 Flash than to use the API?

Usually not. Four rented B200 GPUs at the October 2026 median rate cost about $720 a day, which buys roughly 1.2 billion output tokens through MiniMax's API. Self-hosting pays off for privacy and control, or at very high volume.

How many parameters does MiniMax M3.1 Flash have?

About 428 billion total, with 23 billion activated per token. It's a mixture-of-experts model with a context window of up to 1 million tokens.

• MiniMax, "MiniMax M3.1 Flash: Redefining Agent Performance and Cost"
• Hugging Face, MiniMaxAI/MiniMax-M3.1-Flash model card
• Hugging Face, MiniMax-M3.1-Flash license
• Hugging Face, MiniMax-M3.1-Flash multi-chip deployment with FlagOS
• vLLM Recipes, "MiniMaxAI/MiniMax-M3.1-Flash"
• SGLang Docs, "MiniMax-M3.1" cookbook
• VentureBeat, "MiniMax's new M3.1 Flash beats DeepSeek and Opus 5 on a key business benchmark at lower cost, but with a high hallucination rate"
• ChainCatcher, "MiniMax M3.1 Flash open source"
• GPU Economy, "NVIDIA B200 price per hour"
• GetDeploying, "Nvidia B200 Rental Prices"