Kimi K2.6 GPU requirements: 595 GB at INT4, 2.05 TB at BF16
Kimi K2.6 needs 2.05 TB of GPU memory for its weights at BF16, 1.03 TB at FP8 and 595 GB at INT4, plus 2.3 GB of KV cache for a 32K context. The cheapest node that runs it here is 8× RTX PRO 6000 Blackwell at INT4 (native), for $1.52 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
- 1T32B active per token
- Weights, INT4
- 595 GBBF16: 2.05 TB
- KV cache, 32K
- 2.3 GBOne sequence, 16-bit cache
- Context window
- 256KNative
How much VRAM Kimi K2.6 needs, format by format.
Weights are parameters × bytes per parameter, except the native INT4 row, which is the size of the published checkpoint. Each context column adds the KV cache of one sequence of that length.
| Format | Weights | + 8Kcontext | + 32Kcontext | + 128Kcontext | + 256Kcontext | Cheapest node, 32K |
|---|---|---|---|---|---|---|
| BF16Published weights, fine-tuning | 2.05 TB | 2.05 TB | 2.06 TB | 2.06 TB | 2.07 TB | more than one node |
| FP8Hopper, Ada, Blackwell, MI300 | 1.03 TB | 1.03 TB | 1.03 TB | 1.04 TB | 1.05 TB | 8× MI300X · $7.92/h |
| INT4 (native)AWQ, GPTQ, GGUF Q4 · the published checkpoint | 595 GB | 596 GB | 598 GB | 604 GB | 614 GB | 8× RTX PRO 6000 Blackwell · $1.52/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 Kimi K2.6, 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 |
|---|---|---|---|---|---|---|
| INT4 (native) | 8× RTX PRO 6000 BlackwellBlackwell · 598 GB needed | 768 GB | $1.52 | $3.12 | $1,109.60 | Deploy |
| INT4 (native) | 8× H100 NVLHopper · 598 GB needed | 752 GB | $3.92 | $6.32 | $2,861.60 | Deploy |
| INT4 (native) | 4× MI300XCDNA 3 · 598 GB needed | 768 GB | $3.96 | $5.80 | $2,890.80 | Deploy |
| INT4 (native) | 4× MI325XCDNA 3 · 598 GB needed | 1024 GB | $4.36 | $6.36 | $3,182.80 | Deploy |
| FP8 | 8× MI300XCDNA 3 · 1.03 TB needed | 1536 GB | $7.92 | $11.60 | $5,781.60 | Deploy |
| FP8 | 8× MI325XCDNA 3 · 1.03 TB needed | 2048 GB | $8.72 | $12.72 | $6,365.60 | Deploy |
| FP8 | 8× B200 SXMBlackwell · 1.03 TB needed | 1440 GB | $13.52 | $19.92 | $9,869.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.
Multi-head latent attention: one compressed 576-value vector per token and layer, 61 layers.
| Context | KV cache, 1 sequence | 8 sequences |
|---|---|---|
| 8K tokens | 0.58 GB | 4.61 GB |
| 32K tokens | 2.3 GB | 18.4 GB |
| 128K tokens | 9.21 GB | 73.7 GB |
| 256K tokens | 18.4 GB | 147 GB |
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 — 18.4 GB here.
- Recommended node8× RTX PRO 6000 Blackwell
- Weights at INT4595 GB
- Context that fits, 1 sequence256K
Paged attention (vLLM, SGLang) allocates the cache in blocks as requests grow, so a node holds more short requests than the worst case suggests.
Kimi K2.6, as published.
- Developer
- Moonshot AIKimi K2 line with native INT4 weights (same layout as K2.5)
- Parameters
- 1T total, 32B active per token1.03T in the published checkpoint (embedding tables, prediction or vision modules included); memory figures use this count
- Architecture
- Mixture of experts, 61 layersMulti-head latent attention: one compressed 576-value vector per token and layer, 61 layers
- Context window
- 262,144 tokensAs set in the published configuration
- Published format
- INT4, 595 GB checkpoint
- Licence
- Custom licence (see the model card)
- Released
- 14 April 2026
- Source
- moonshotai/Kimi-K2.6config.json read 26 October 2026
Serve it with vLLM
template: vLLMOn 8× RTX PRO 6000 Blackwell, from the instance terminal:
$ vllm serve moonshotai/Kimi-K2.6 \ --tensor-parallel-size 8 \ --max-model-len 32768
Very recent architectures need a recent vLLM; the model card gives the minimum version and any extra flags.
Kimi K2.6 on a GPU — the questions that come up
How much VRAM does Kimi K2.6 need?
For the weights alone: 2.05 TB at BF16, 1.03 TB at FP8 and 595 GB at INT4. Add 2.3 GB of KV cache for one 32K-token context, or 18.4 GB at the full 256K window, and keep about 10% of the memory free for activations.
Can Kimi K2.6 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 Kimi K2.6?
Here, 8× RTX PRO 6000 Blackwell at INT4 (native): $1.52 per hour on spot and $3.12 on-demand, billed per minute — $1,109.60 for a 730-hour month on spot. That node has 768 GB of GPU memory for the 598 GB this setup needs.
Does Kimi K2.6 need less memory because only 32B 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 1T total. What the 32B 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?
Kimi K2.6 is published in INT4, a 595 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 (moonshotai/Kimi-K2.6) 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.
Kimi K2.6 on 8× RTX PRO 6000 Blackwell for $1.52 an hour.
Launch the node with the vLLM template, point it at moonshotai/Kimi-K2.6, 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.