What LLMs can a B200 run?

Models that fit on one B200

The most precise weights that still fit with 8K tokens of context and one request, the memory that takes, the longest context at that precision and the writing speed. Bigger models come first. gpt-oss-120b (67.7 GB, 354–772 tokens/s on the B200) and gpt-oss-20b (14.8 GB, 388–872 tokens/s on the B200) are listed at MXFP4 only, as published.

Too big for one B200 at 8K context

How many B200 cards these need at Q4_K_M with 8K context and 0.5 GB to spare, in one tensor-parallel group; some need more than 8.

• MiniMax M3: 2 cards
• Ling 3.1 Flash 560B-A25B: 2 cards
• DeepSeek V3 / R1: 4 cards
• DeepSeek V3.2: 4 cards
• GLM-5.3: 4 cards
• GLM-5.2: 4 cards
• DeepSeek V4.1 Flash 1017: 4 cards
• DeepSeek V4.1 Flash: 4 cards
• Hy4 Preview 770B-A49B: 4 cards
• MiMo V2.6 Pro: 4 cards
• DeepSeek V4 Pro: 8 cards
• Qwen3.8 2.4T-A95B: more than 8 cards
• Kimi K3: more than 8 cards

Best models for B200 with room for long context

The biggest models that still fit at Q4_K_M with 32,768 tokens of context (or their whole window, if shorter), the memory left over, the longest context the card takes at that precision and the writing speed with that context in the cache, from 8,000 GB/s of bandwidth.

llama-server commands for one B200

GGUF repos checked 2026-09-29; -c is the longest context with 0.5 GB free on the B200. No -ngl: llama.cpp’s -fit, on by default since b7440, places the layers.

MiniMax M2.7, Q4_K_M with 132K tokens: 55–94 tokens/s on the B200

llama-server -hf unsloth/MiniMax-M2.7-GGUF:Q4_K_M -c 135168

UD-Q4_K_M/MiniMax-M2.7-UD-Q4_K_M-00001-of-00004.gguf, 140.2 GB: 179 GB used and 754 MB free of the B200's 180 GB, 55–94 tokens/s once the 132K cache is full.

Step 3.7 Flash 196B-A11B, Q4_K_M with 256K tokens: 103–185 tokens/s on the B200

llama-server -hf unsloth/Step-3.7-Flash-GGUF:Q4_K_M -c 262144 -np 1

UD-Q4_K_M/Step-3.7-Flash-UD-Q4_K_M-00001-of-00004.gguf, 122.1 GB: 139 GB used and 41.1 GB free of the B200's 180 GB, 103–185 tokens/s once the 256K cache is full. -np 1: one slot, one sliding window.

How fast the B200 writes as the context fills

Tokens per second at Q4_K_M (gpt-oss-120b at MXFP4) for the biggest models that fit with 32K tokens, with 8K and 32K tokens in the cache and at the longest context the card holds, and at Q8_0 with 8K where that fits. Each token reads the active weights and the whole cache once, so the speed follows the 8,000 GB/s of bandwidth and falls as the cache grows. The ceiling is that bandwidth divided by the bytes read per token, which no runtime reaches; the reply time is for 1,000 new tokens with 32K (or the longest context) in the cache, prompt processing aside.

Near misses on B200

Models that miss at Q4_K_M with 32,768 tokens of context (or their whole window), or leave under 0.5 GB free there, but fit with a shorter context or 3-bit weights, or are short by at most a quarter of the memory and fit with MoE offload. Smallest shortfall first.

What more cards or MoE offload unlock

One, two and four B200 cards in one tensor-parallel group (vLLM or SGLang), with the models each step adds at Q4_K_M and 8K context and their tokens per second on that group, and the median on-demand rent for that many cards (getdeploying.com, 2026-09-29).

Run locally or rent a B200?

Renting a B200 costs a median of $6.64 an hour on demand, across the providers getdeploying.com tracks (checked 2026-09-29), so every $1,000 of purchase price equals about 151 hours of rent, 6 days around the clock. At that rate MiniMax M2.7 at Q4_K_M with 32K tokens, the biggest model here that fits with a long context, writes 134–244 tokens/s for one request: about $7.5–14 per million generated tokens. Electricity and resale value are left out, and no card prices are listed because 2026 street prices vary widely between sellers; compare current ones before you decide.

Serving with vLLM on the B200

The KV cache pool vLLM builds at its default --gpu-memory-utilization 0.92 and --max-model-len 32768, weights as published, from the vLLM KV cache calculator. The pool is shared by every request; the last column assumes 4,096 tokens each.

How these numbers are worked out

Memory is the weights at each precision plus the KV cache for 8,192 tokens in FP16 and runtime overhead (0.5 GB plus 10%), computed from each model's files on Hugging Face with the LLM VRAM Calculator. Speed is estimated from memory bandwidth and the parameters read per token with the LLM Speed Calculator. Both tools take any other model from Hugging Face.

Nearby GPUs and setups

How many of the tracked models each one holds at Q4_K_M with 8K context, against 51 here.