How to Run MiniMax-M3.1-Flash Locally (2026): RAM Needed, GGUF Quants and llama.cpp Setup

MiniMax released the open weights of MiniMax-M3.1-Flash on Hugging Face on 23 October 2026: a 428B mixture-of-experts model with 23B active parameters, a 1M token context and image and video input.

The big question is whether you can run it at home. The short answer is yes, but only with a lot of memory. This guide gives the real file sizes, the memory each quant needs, step-by-step llama.cpp commands, the official vLLM route for servers, the licence catch, and the problems to expect.

What MiniMax-M3.1-Flash Is

MiniMax-M3.1-Flash is MiniMax’s fast, cheap agent model. It launched on the MiniMax API on 19 October 2026, and the weights followed four days later in the MiniMaxAI/MiniMax-M3.1-Flash repository.

It is a sparse mixture-of-experts model. Each MoE layer has 128 routed experts plus one shared expert, and only 4 routed experts run per token. That is why a 428B model only uses about 23B parameters for each token, which keeps it fast once it is loaded.

The checkpoint is unusual: dense layers are stored in MXFP8 and the experts in NVFP4, because MiniMax trained it with quantization-aware training. The low-precision weights are the reference model, not a cut-down copy. It also ships a DSpark draft head for speculative decoding.

MiniMax’s own benchmarks put it ahead on agent tests like Automation-Bench (62.8) and LOCA-Bench 256K (60.3), but behind on Terminal Bench 4.0 (38.1). These are vendor numbers and had not been independently reproduced when I wrote this.

Specs at a Glance

Can Your PC Run It?

For MoE models, what matters is RAM + VRAM combined. The experts can sit in system RAM while the GPU handles attention and the shared parts. Unsloth’s guide lists these totals for 16K context and one user:

Not sure what you have? My guides on how much RAM you need for local AI and how much VRAM you need explain how to check and what to upgrade.

GGUF Quants and Sizes

Several groups have published GGUF files. These are the main ones:

I recommend the Unsloth dynamic (UD) files. They keep the most important layers at higher precision, which matters a lot at 1-3 bits. AtomicChat notes its quants are plain, without an importance matrix, and that its Q2_K loses noticeably more quality.

Other community repositories exist, including IQ2_XS and NVFP4 GGUF builds. Some are marked work in progress or need patched engines, so check each model card before downloading 130+ GB.

Run It with llama.cpp (Step by Step)

At the time of writing, Unsloth’s guide says to build llama.cpp from PR #31192 (branch minimax-m31) to get full M3.1 support. Once that PR is merged, a normal llama.cpp release will work, so check the releases page first.

1. Install the build tools. On Windows you need Git, CMake, Visual Studio Build Tools (C++ workload) and the CUDA Toolkit. On Linux: git, cmake, build-essential and CUDA.
2. Get the code and the PR branch:
   git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch origin pull/31192/head:minimax-m31
git checkout minimax-m31
3. Build with CUDA (use -DGGML_CUDA=OFF on a Mac, where Metal is on by default):
   cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
4. Download the quant with the Hugging Face CLI (about 144 GB for UD-Q2_K_XL):
   hf download unsloth/MiniMax-M3.1-Flash-GGUF --include "UD-Q2_K_XL/*" --local-dir unsloth/MiniMax-M3.1-Flash-GGUF
5. Start the server with Unsloth’s recommended settings (point it at the first file of the split):
   ./build/bin/llama-server --model unsloth/MiniMax-M3.1-Flash-GGUF/UD-Q2_K_XL/MiniMax-M3.1-Flash-UD-Q2_K_XL-00001-of-00004.gguf --jinja -fa on -c 16384 --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 --chat-template-kwargs '{"reasoning_effort":"high"}' --host 127.0.0.1 --port 8080
6. Open http://127.0.0.1:8080 for the built-in chat, or connect any OpenAI-compatible app to http://127.0.0.1:8080/v1.

Want a nicer chat window? Point Open WebUI at the llama-server URL as an OpenAI connection. For how llama.cpp compares with other engines, see vLLM vs llama.cpp vs Ollama.

GPU + RAM Offload Settings

On a PC where the model does not fit in VRAM, tell llama.cpp to put the MoE experts in system RAM and everything else on the GPU:

• -ngl 99 puts all layers on the GPU first.
• --cpu-moe then keeps all expert weights in RAM. This is the safest starting point.
• --n-cpu-moe 40 keeps the experts of only the first 40 layers in RAM. Lower the number step by step to move more experts onto the GPU until VRAM is nearly full.
• -c 16384 keeps the context small. Raise it only when memory allows.

AtomicChat measured the attention cache at about 0.14 MB per token: about 1.1 GB at 8K context and 4.5 GB at 32K. That is small for a model this size, so context is not the main problem. The weights are.

If you have two GPUs, llama.cpp splits layers across them automatically. My Qwen3.8-Flash-Next local guide walks through the same MoE offload approach on a smaller model, which is a good way to practise first.

Using Image Input

Unsloth provides a vision projector file, mmproj-BF16.gguf (about 1.74 GB). Download it into the same folder and add --mmproj with its path to the llama-server command. You can then attach images in the web UI.

Video input works on the official API and full-size servers. In llama.cpp, image support is the realistic option for now. AtomicChat says it had not yet tested images with its own projector file.

Serving with vLLM or SGLang

For a business or a rented GPU server, use the official FP8/NVFP4 checkpoint with vLLM or SGLang, which both had day-0 support. Docker Model Runner and TokenSpeed are supported too.

vLLM reported 76 concurrent 256K-token sequences on four B300 GPUs in its launch numbers. A basic start looks like vllm serve MiniMaxAI/MiniMax-M3.1-Flash --tensor-parallel-size 4, but check the model card for the exact flags for DSpark and the KV cache, as they change between vLLM versions.

Renting rather than buying? Compare hourly rates in my cheapest cloud GPU for AI guide.

Licence: The $20M Line

M3.1-Flash is open weights, not open source. It uses MiniMax’s own minimax-community licence instead of MIT or Apache 2.0.

• Personal use, research and testing are fine.
• Commercial deployments must include attribution to MiniMax.
• Companies with more than $20 million in annual revenue need MiniMax’s prior written permission.

Read the full licence in the Hugging Face repository before building a product on it.

Local vs the API: Cost Check

MiniMax’s hosted API charges $0.15 per million input tokens, $0.60 per million output tokens and $0.015 per million cached input tokens. That is very cheap.

At those prices, buying 256 GB of RAM just for this model rarely pays off.

With RAM prices high (see why RAM is so expensive in 2026), run it locally when you need privacy, offline use or fine-tuning, or because you already own the hardware. Compare with other providers in my AI API pricing comparison.

One more caveat: Artificial Analysis’s AA-Omniscience test gave the model a 93% hallucination rate, and thinking cannot be turned off through the API. Check its answers on facts carefully, local or not.

Troubleshooting

“unknown model architecture: minimax-m3” or the model will not load

Your llama.cpp build is too old or lacks the M3.1 changes. Build from the PR branch above, or update to a release that includes it. Ollama and LM Studio will need their own updates before they load it.

Warning that it falls back to dense attention

Sparse attention needs flash attention on. Add -fa on and do not use --kv-unified.

Out of memory while loading

Add --cpu-moe, lower -c, close other apps, or use a smaller quant. On Windows, make sure the pagefile is not disabled, but do not rely on it, since swapping to SSD is extremely slow.

Only part of the model downloads, or llama.cpp cannot find shards

Keep all split files in the same folder with their original names, and point --model at the file ending in -00001-of-0000N.gguf.

Very slow replies

Expected when most experts sit in RAM. Use dual-channel RAM at its rated speed, move more experts to VRAM with --n-cpu-moe, and lower reasoning_effort so it thinks less.

Output gets strange in long chats

AtomicChat notes that llama.cpp runs the first three blocks with dense attention, and that outputs can drift from the reference past about 2,200 tokens of context. Update llama.cpp as fixes land, and use the official server route for long-context work.

Answers look broken or skip thinking

Use --jinja so the model’s own chat template is applied, and keep temperature at 1.0 with top-p 0.95.

My Take

MiniMax-M3.1-Flash is a serious open-weights model, but it is a server-class model. At home, a 128 GB RAM PC with a big GPU can run the 2-bit Unsloth quant to try it, while 256 GB of memory or a large Mac gets you a 4-bit version that is closer to the original.

For most people the API at $0.15/$0.60 is the sensible way to use it, with local runs saved for privacy or experiments. If you want a big MoE model that runs well on a 128 GB desktop today, Qwen3.8-Flash-Next is still the easier choice.

FAQ

Is MiniMax-M3.1-Flash open source?

It is open weights under a custom minimax-community licence, not an open-source licence. Commercial use needs attribution, and companies above $20M yearly revenue need written permission.

How much RAM do I need to run MiniMax-M3.1-Flash?

About 134 GB of RAM + VRAM for the 1-bit quant, 150 GB for 2-bit, 176-208 GB for 3-bit and 256 GB for 4-bit, at 16K context.

Can I run MiniMax-M3.1-Flash on a single RTX 5090?

Only with at least 128 GB of system RAM and a 1-2 bit quant, with the experts offloaded to RAM. The GPU alone cannot hold it.

Does Ollama support MiniMax-M3.1-Flash?

Not at the time of writing. Use a recent llama.cpp build as described above, then check Ollama’s releases for official support.

How big is MiniMax-M3.1-Flash?

About 428B total parameters with 23B active. The official checkpoint is about 252 GB, and GGUF quants range from 129 GB to 259 GB.

What settings should I use?

Temperature 1.0, top-p 0.95, top-k off and min-p off, with --jinja and a reasoning effort of low to high.

Does it support images locally?

Yes, with the Unsloth mmproj-BF16.gguf file and the --mmproj option in llama.cpp. Video input is for the full server setup.

Sources

• MiniMaxAI/MiniMax-M3.1-Flash on Hugging Face
• Unsloth: MiniMax M3.1 Flash run guide (quants, memory, settings)
• AtomicChat/MiniMax-M3.1-Flash-GGUF (sizes, cache use, known issues)
• Data Studios: MiniMax-M3.1-Flash open weights, architecture and hardware
• OrcaRouter: M3.1 Flash weights, licence and pricing