MiniMax M3 GPU requirements: 214 GB at 4-bit, 854 GB at BF16
MiniMax M3 needs 854 GB of GPU memory for its weights at BF16, 427 GB at FP8 and 214 GB at 4-bit, plus 4.03 GB of KV cache for a 32K context. The cheapest node that runs it here is 4× A100 PCIe 80GB at 4-bit, for $0.36 an hour on spot.
Weights plus a 32K 16-bit KV cache, with 10% of the node's memory kept free. Billed per minute.
- Parameters
- 428B23B active per token
- Weights, 4-bit
- 214 GBBF16: 854 GB
- KV cache, 32K
- 4.03 GBOne sequence, 16-bit cache
- Context window
- 1MNative
How much VRAM MiniMax M3 needs, format by format.
Weights are parameters × bytes per parameter. Each context column adds the KV cache of one sequence of that length.
| Format | Weights | + 8Kcontext | + 32Kcontext | + 128Kcontext | + 1Mcontext | Cheapest node, 32K |
|---|---|---|---|---|---|---|
| BF16Published weights, fine-tuning | 854 GB | 855 GB | 858 GB | 870 GB | 983 GB | 4× MI325X · $4.36/h |
| FP8Hopper, Ada, Blackwell, MI300 | 427 GB | 428 GB | 431 GB | 443 GB | 556 GB | 8× RTX PRO 6000 Blackwell · $1.52/h |
| 4-bitAWQ, GPTQ, GGUF Q4 | 214 GB | 215 GB | 218 GB | 230 GB | 342 GB | 4× A100 PCIe 80GB · $0.36/h |
The serving engine adds its own buffers, and an 8-bit KV cache halves the context columns. We keep 10% of a node's memory free when we say a model fits. Speed is a separate question: it follows memory bandwidth and, for a mixture of experts, the active parameters.
GPUs that run MiniMax M3, cheapest first.
For each format, the smallest node of each GPU model that holds the weights and a 32K context, sorted by spot price. One row per GPU model; larger nodes of the same GPU work too.
| Format | GPU | GPU memory | Spot | On-demand | 730 h spot | Action |
|---|---|---|---|---|---|---|
| 4-bit | 4× A100 PCIe 80GBAmpere · 218 GB needed | 320 GB | $0.36 | $0.76 | $262.80 | Deploy |
| 4-bit | 8× A40Ampere · 218 GB needed | 384 GB | $0.48 | $0.72 | $350.40 | Deploy |
| 4-bit | 8× A100 40GBAmpere · 218 GB needed | 320 GB | $0.72 | $1.36 | $525.60 | Deploy |
| 4-bit | 8× L40Ada Lovelace · 218 GB needed | 384 GB | $0.72 | $1.52 | $525.60 | Deploy |
| FP8 | 8× RTX PRO 6000 BlackwellBlackwell · 431 GB needed | 768 GB | $1.52 | $3.12 | $1,109.60 | Deploy |
| FP8 | 2× MI325XCDNA 3 · 431 GB needed | 512 GB | $2.18 | $3.18 | $1,591.40 | Deploy |
| FP8 | 4× H200 NVLHopper · 431 GB needed | 564 GB | $2.76 | $3.96 | $2,014.80 | Deploy |
| FP8 | 4× H200 SXMHopper · 431 GB needed | 564 GB | $3.00 | $4.36 | $2,190.00 | Deploy |
| BF16 | 4× MI325XCDNA 3 · 858 GB needed | 1024 GB | $4.36 | $6.36 | $3,182.80 | Deploy |
| BF16 | 8× H200 NVLHopper · 858 GB needed | 1128 GB | $5.52 | $7.92 | $4,029.60 | Deploy |
| BF16 | 8× H200 SXMHopper · 858 GB needed | 1128 GB | $6.00 | $8.72 | $4,380.00 | Deploy |
| BF16 | 8× MI300XCDNA 3 · 858 GB needed | 1536 GB | $7.92 | $11.60 | $5,781.60 | Deploy |
Spot capacity can be reclaimed with a 2-minute notice; for a live endpoint, use on-demand. How spot works · serving a language model.
What a long context costs in memory.
Block-sparse attention over a full cache: 4 KV heads of 128 across 60 layers (each token reads part of the cache, all of it is kept).
| Context | KV cache, 1 sequence | 8 sequences |
|---|---|---|
| 8K tokens | 1.01 GB | 8.05 GB |
| 32K tokens | 4.03 GB | 32.2 GB |
| 128K tokens | 16.1 GB | 129 GB |
| 1M tokens | 129 GB | 1.03 TB |
Serving several users
KV cacheEvery concurrent request keeps its own cache, so memory for context grows with users × context length. A server batching 8 requests of 32K needs eight times the single-sequence figure — 32.2 GB here.
- Recommended node4× A100 PCIe 80GB
- Weights at 4-bit214 GB
- Context that fits, 1 sequence592K
Paged attention (vLLM, SGLang) allocates the cache in blocks as requests grow, so a node holds more short requests than the worst case suggests.
MiniMax M3, as published.
- Developer
- MiniMaxSparse-attention mixture of experts with a 1M-token context
- Parameters
- 428B total, 23B active per token
- Architecture
- Mixture of experts, 60 layersBlock-sparse attention over a full cache: 4 KV heads of 128 across 60 layers (each token reads part of the cache, all of it is kept)
- Context window
- 1,048,576 tokensAs set in the published configuration
- Published format
- BF16, 854 GB
- Licence
- Custom licence (see the model card)
- Released
- 2 June 2026
- Source
- MiniMaxAI/MiniMax-M3config.json read 26 October 2026
Serve it with vLLM
template: vLLMOn 4× A100 PCIe 80GB, from the instance terminal:
$ vllm serve MiniMaxAI/MiniMax-M3 \ --tensor-parallel-size 4 \ --max-model-len 32768
Very recent architectures need a recent vLLM; the model card gives the minimum version and any extra flags.
MiniMax M3 on a GPU — the questions that come up
How much VRAM does MiniMax M3 need?
For the weights alone: 854 GB at BF16, 427 GB at FP8 and 214 GB at 4-bit. Add 4.03 GB of KV cache for one 32K-token context, or 129 GB at the full 1M window, and keep about 10% of the memory free for activations.
Can MiniMax M3 run on a single GPU?
One RTX 4090 (24 GB): no. One RTX 5090 (32 GB): no. One H100 SXM (80 GB): no. One H200 SXM (141 GB): no. One B200 SXM (180 GB): no. Those answers assume a 32K context and the widest format that still fits.
What is the cheapest way to run MiniMax M3?
Here, 4× A100 PCIe 80GB at 4-bit: $0.36 per hour on spot and $0.76 on-demand, billed per minute — $262.80 for a 730-hour month on spot. That node has 320 GB of GPU memory for the 218 GB this setup needs.
Does MiniMax M3 need less memory because only 23B parameters are active?
No. A mixture-of-experts model routes each token through a few experts, but every expert has to be resident in GPU memory, so the memory bill follows the 428B total. What the 23B active parameters change is the work per token: generation reads far less of the weights each step than a dense model of the same size would, which is why it is fast for its size.
Which format should I run it in?
BF16 keeps the published weights untouched and is the format for fine-tuning. FP8 halves the memory and runs in hardware on Hopper, Ada, Blackwell and MI300-class GPUs. 4-bit quantisation (AWQ, GPTQ, GGUF) quarters it, at a quality cost that is larger on small models than on big ones; check it against your own evaluation before relying on it.
How do I deploy it?
Pick the node in the table above and launch it with the vLLM template; the model downloads from Hugging Face (MiniMaxAI/MiniMax-M3) on first start. Spread the weights over the node with --tensor-parallel-size equal to the GPU count, and set --max-model-len to the context you need. New architectures need a recent vLLM: check the model card for the minimum version.
Sizing another model? GPU requirements for 64 open models · serving a language model · fine-tuning.
MiniMax M3 on 4× A100 PCIe 80GB for $0.36 an hour.
Launch the node with the vLLM template, point it at MiniMaxAI/MiniMax-M3, stop it when you are done. Prepaid, billed by the minute.
Billed per minute from the moment the instance is reachable. Minimum credit $30, no subscription.