New B200 spot capacity is live in US East from $1.69 per GPU-hour. See availability →
Deploy a GPU
MiniMax · Mixture of experts · released February 2026

MiniMax M2.5 GPU requirements: 114 GB at 4-bit, 457 GB at BF16

MiniMax M2.5 needs 457 GB of GPU memory for its weights at BF16, 230 GB at FP8 and 114 GB at 4-bit, plus 8.32 GB of KV cache for a 32K context. The cheapest node that runs it here is 2× A100 PCIe 80GB at 4-bit, for $0.18 an hour on spot.

Architecture read from the model's config.json on Hugging Face, 26 October 2026 · prices from the live catalogue · all 47 GPUs

Cheapest node · 32K context per node-hour, spot
4-bit2× A100 PCIe 80GB · 123 GB needed $0.18$0.38 on-demand
FP8 (native)8× L40 · 238 GB needed $0.72$1.52 on-demand
BF168× A100 PCIe 80GB · 466 GB needed $0.72$1.52 on-demand
Deploy 2× A100 PCIe All models

Weights plus a 32K 16-bit KV cache, with 10% of the node's memory kept free. Billed per minute.

Parameters
230B10B active per token
Weights, 4-bit
114 GBBF16: 457 GB
KV cache, 32K
8.32 GBOne sequence, 16-bit cache
Context window
192KNative
Memory by format

How much VRAM MiniMax M2.5 needs, format by format.

Weights are parameters × bytes per parameter, except the native FP8 row, which is the size of the published checkpoint. Each context column adds the KV cache of one sequence of that length.

GPUs by memory
Format Weights + 8Kcontext+ 32Kcontext+ 128Kcontext+ 192Kcontext Cheapest node, 32K
BF16Published weights, fine-tuning 457 GB 459 GB466 GB491 GB507 GB 8× A100 PCIe 80GB · $0.72/h
FP8 (native)Hopper, Ada, Blackwell, MI300 230 GB 232 GB238 GB263 GB280 GB 8× L40 · $0.72/h
4-bitAWQ, GPTQ, GGUF Q4 114 GB 116 GB123 GB148 GB164 GB 2× A100 PCIe 80GB · $0.18/h
Arithmetic on published facts, not a benchmark.

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.

Where it runs

GPUs that run MiniMax M2.5, 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.

All prices
Format GPU GPU memory Spot On-demand 730 h spot
4-bit 2× A100 PCIe 80GBAmpere · 123 GB needed 160 GB $0.18 $0.38 $131.40 Deploy
4-bit 4× A40Ampere · 123 GB needed 192 GB $0.24 $0.36 $175.20 Deploy
4-bit 4× A100 40GBAmpere · 123 GB needed 160 GB $0.36 $0.68 $262.80 Deploy
4-bit 4× L40Ada Lovelace · 123 GB needed 192 GB $0.36 $0.76 $262.80 Deploy
FP8 (native) 8× L40Ada Lovelace · 238 GB needed 384 GB $0.72 $1.52 $525.60 Deploy
FP8 (native) 4× RTX PRO 6000 BlackwellBlackwell · 238 GB needed 384 GB $0.76 $1.56 $554.80 Deploy
FP8 (native) 8× L40SAda Lovelace · 238 GB needed 384 GB $1.20 $2.00 $876.00 Deploy
FP8 (native) 2× H200 NVLHopper · 238 GB needed 282 GB $1.38 $1.98 $1,007.40 Deploy
BF16 8× A100 PCIe 80GBAmpere · 466 GB needed 640 GB $0.72 $1.52 $525.60 Deploy
BF16 8× A100 SXM 80GBAmpere · 466 GB needed 640 GB $1.52 $2.32 $1,109.60 Deploy
BF16 8× RTX PRO 6000 BlackwellBlackwell · 466 GB needed 768 GB $1.52 $3.12 $1,109.60 Deploy
BF16 4× H200 NVLHopper · 466 GB needed 564 GB $2.76 $3.96 $2,014.80 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.

Context and the KV cache

What a long context costs in memory.

Grouped-query attention, 8 KV heads of 128 across 62 layers.

Context KV cache, 1 sequence 8 sequences
8K tokens 2.08 GB 16.6 GB
32K tokens 8.32 GB 66.6 GB
128K tokens 33.3 GB 266 GB
192K tokens 49.9 GB 399 GB

Serving several users

KV cache

Every 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 — 66.6 GB here.

  • Recommended node2× A100 PCIe 80GB
  • Weights at 4-bit114 GB
  • Context that fits, 1 sequence114K

Paged attention (vLLM, SGLang) allocates the cache in blocks as requests grow, so a node holds more short requests than the worst case suggests.

Model facts

MiniMax M2.5, as published.

Developer
MiniMaxAgentic and coding mixture of experts (same size and layout as M2)
Parameters
230B total, 10B active per token
Architecture
Mixture of experts, 62 layersGrouped-query attention, 8 KV heads of 128 across 62 layers
Context window
196,608 tokensAs set in the published configuration
Published format
FP8, 230 GB checkpoint
Licence
Custom licence (see the model card)
Released
12 February 2026
Source
MiniMaxAI/MiniMax-M2.5config.json read 26 October 2026

Serve it with vLLM

template: vLLM

On 2× A100 PCIe 80GB, from the instance terminal:

terminal
$ vllm serve MiniMaxAI/MiniMax-M2.5 \
    --tensor-parallel-size 2 \
    --max-model-len 32768

Very recent architectures need a recent vLLM; the model card gives the minimum version and any extra flags.

FAQ

MiniMax M2.5 on a GPU — the questions that come up

How much VRAM does MiniMax M2.5 need?

For the weights alone: 457 GB at BF16, 230 GB at FP8 and 114 GB at 4-bit. Add 8.32 GB of KV cache for one 32K-token context, or 49.9 GB at the full 192K window, and keep about 10% of the memory free for activations.

Can MiniMax M2.5 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): yes, at 4-bit. One B200 SXM (180 GB): yes, at 4-bit. Those answers assume a 32K context and the widest format that still fits.

What is the cheapest way to run MiniMax M2.5?

Here, 2× A100 PCIe 80GB at 4-bit: $0.18 per hour on spot and $0.38 on-demand, billed per minute — $131.40 for a 730-hour month on spot. That node has 160 GB of GPU memory for the 123 GB this setup needs.

Does MiniMax M2.5 need less memory because only 10B 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 230B total. What the 10B 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?

MiniMax M2.5 is published in FP8, a 230 GB checkpoint — the format its developers serve it in, so it is the safe default. 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-M2.5) 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.

Get started

MiniMax M2.5 on 2× A100 PCIe 80GB for $0.18 an hour.

Launch the node with the vLLM template, point it at MiniMaxAI/MiniMax-M2.5, stop it when you are done. Prepaid, billed by the minute.

Deploy 2× A100 PCIe All open models

Billed per minute from the moment the instance is reachable. Minimum credit $30, no subscription.