Kimi K3.1 vs DeepSeek V4.1 on One B300 Node: Speed and Cost

$6.65 vs $2.01 per million output tokens on one 8x B300 node, 8 Nov 2026. That is Kimi K3.1 Pro against DeepSeek V4.1 Flash (the 1017 weights), both served with vLLM on the same rented node, with 64 requests at once, priced at the $49.61 an hour we actually paid for it.

TL;DR: Kimi K3.1 vs DeepSeek V4.1 on One B300 Node

DeepSeek V4.1 Flash wrote 3.3 times the output of Kimi K3.1 Pro on the same 8x B300 spot node on Spheron (Spheron ES, UK South 1), measured with vLLM on 8 Nov 2026.

Costs use the $49.61 an hour paid for the node that day. The live B300 spot rate on Spheron is $7.84/hr per GPU as of 09 Nov 2026.

Kimi K3.1 vs DeepSeek V4.1: results on one B300 node

We rented one 8x B300 node (Spheron ES, UK South 1, spot) and ran both models end to end: download, cold start, single-user speed, 64-user throughput and a five-prompt spot check. If you want the background on each model first, see our Kimi K3 deployment guide and the DeepSeek V4.1 Flash GPU requirements. Every number below comes from that one run, and the raw table and exact commands are further down.

The video version of this test: Kimi K3.1 vs DeepSeek V4.1 on one B300 node.

Kimi K3.1 Pro vs DeepSeek V4.1 Flash on one 8x B300 SXM6 node, vLLM, measured 8 Nov 2026. Rate: $49.61 an hour (average paid). NVFP4 column: NVIDIA's 4-bit build of DeepSeek, shown for reference.

† Kimi's first start failed at graph capture with the recipe defaults (see the fix below). The working start came about 10 minutes later, so the weights may still have been in the host's page cache and the compile cache was on the volume. Counting the failed attempt, Kimi took 39 min 35 s from first launch to ready.

Pricing fluctuates based on GPU availability. The prices above are based on 08 Nov 2026 and may have changed. Check current GPU pricing → for live rates.

How much GPU memory do Kimi K3.1 and DeepSeek V4.1 need?

Each B300 on this node reports 275,040 MiB (about 288 GB), so the node has about 2.3 TB of GPU memory.

Kimi K3.1 Pro has 2.8 trillion parameters and its weights are 1,561.4 GB, already in 4-bit (MXFP4 weights with MXFP8 activations, from quantization-aware training). At tensor parallel 8, that is 193.66 GiB of weights on every GPU. vLLM used 248,210 of 275,040 MiB per GPU, about 90 percent, and the rest of its share went to 34.74 GiB of KV cache per GPU: room for 2,151,492 tokens. It takes the whole node.

DeepSeek V4.1 Flash is 510.3 GB. At tensor parallel 4, each GPU holds 79.25 GiB of weights, so we ran two copies side by side on the same eight GPUs. Each copy still had 144.66 GiB of KV cache per GPU, room for 85,171,942 tokens. The vLLM recipe's Blackwell default goes further, two GPUs per copy with the Engram tables offloaded to host memory, which would fit four copies on the node. We did not measure that layout.

Note that vLLM reserves most free memory for cache up front, so "used" is what it reserved, not what one request needs.

How long from an empty disk to the first answer?

Downloads used hf download with hf-xet. DeepSeek's 510.3 GB took 526.95 s (8 min 47 s) with nothing else running. Kimi's 1,561.4 GB took 672.18 s (11 min 12 s), while DeepSeek was compiling on the GPUs after its weights had loaded, so the timed load never shared the disk.

Starting the server was the slow part. From docker run to the first healthy response, DeepSeek took 2,418.99 s (40 min 19 s; its second copy was ready at 2,424.07 s) and Kimi took 1,800.13 s (30 min 0 s).

Most of that is not reading weights. The vLLM logs put weight loading at 1,021.87 s for DeepSeek with the default loader and 167.58 s for Kimi with fastsafetensors. After the model loaded, engine start-up (kernel compile, autotuning, CUDA graph capture) took 1,222.26 s for DeepSeek and 1,493.59 s for Kimi.

At the rate we paid, download plus start cost $40.60 for DeepSeek and $34.07 for Kimi before the first token. Kimi's figure counts only its working start. Call this round a draw.

How fast is Kimi K3.1 vs DeepSeek V4.1 for a single user?

Kimi uses 104 billion active parameters per token; DeepSeek V4.1 Flash uses 16 billion. With one request at a time (8 requests in a row, 1,000 tokens in, 1,000 out):

• DeepSeek: 268.6 output tokens a second, 37.8 ms mean time to first token.
• Kimi: 101.1 output tokens a second, 298.1 ms mean time to first token.

For one developer with one agent, that is the difference between watching it type and not noticing.

How many tokens a second with 64 users?

A node is rarely serving one person, so we sent 64 requests at once, 256 in all. Kimi ran as one server on all eight GPUs with 64 concurrent requests. DeepSeek ran as two copies with 32 each.

• DeepSeek: 6,851.2 output tokens a second across the node, 110.2 per user, 272.8 ms mean time to first token.
• Kimi: 2,073.2 output tokens a second, 34.2 per user, 1,624.3 ms mean time to first token.

That is 3.3 times the output from the same hardware.

What does a million output tokens cost?

We computed cost once from the raw numbers:

$ per million output tokens = hourly rate / (node output tokens a second x 3,600) x 1,000,000

The hourly rate is $49.61, the average we paid for this spot node ($139.58 billed over 2 h 48 min 48 s). At 64 users:

• Kimi K3.1 Pro: $6.65 per million output tokens.
• DeepSeek V4.1 Flash: $2.01.

Same node, same hour, about a third of the cost per token. The single-user figures ($136.30 for Kimi, $51.31 for DeepSeek) show why batching matters more than the GPU: an idle node costs the same per hour as a busy one. For more on the formula, see our cost per million tokens explainer and the B300 vs B200 cost-per-token guide.

Do both models get the answers right?

Speed is no use if the answers are wrong, so both got the same five prompts: a billing sum, a counting puzzle, a code task run against a reference implementation, a strict JSON reply and a clock sum. Reasoning effort high, model-card sampling (temperature 1.0, top_p 0.95), one sample each, scored by a script.

Both got all five right. Completion tokens per prompt, in that order:

• DeepSeek: 186, 184, 395, 188, 91.
• Kimi: 396, 248, 336, 111, 187.

Five prompts is a spot check, not a benchmark. For quality, read both model cards.

Which one should you run?

If you need the biggest open model there is, Kimi K3.1 Pro runs on one B300 node, and at full load it costs $6.65 per million output tokens.

If you want speed and the lowest cost per token, DeepSeek V4.1 Flash does 3.3 times the work on the same node, for $2.01.

One more data point: NVIDIA's NVFP4 build of DeepSeek V4.1 Flash wrote 7,070.1 tokens a second at 64 users, 3 percent more than the 1017 weights, for $1.95 per million. It is built from the launch weights, not 1017. That is our next video.

Exact commands

Images (pulled 8 Nov 2026):

• DeepSeek: vllm/vllm-openai:latest, vLLM 0.33.0, torch 2.14.0+cu130, sha256:ce429874fcb2f22e87abec76226e454b90390720c14fc3e5238d0ec564008a27
• Kimi: vllm/vllm-openai:kimi-k31, vLLM 0.1.dev24216+g266e88c05, torch 2.14.0+cu130, sha256:1a8a702f2bfeded3c90259ae60fefbd9e4ca014241946e7d5f3396badce99e76
• NVIDIA driver 580.173.02

The volume is mounted at /mnt/models on the host and at /vol in every container.

Download

HF_XET_HIGH_PERFORMANCE=1 uv tool run --from 'huggingface_hub[hf_xet]' hf download \
  deepseek-ai/DeepSeek-V4.1-Flash-1017 --revision main \
  --local-dir /mnt/models/hf/ds1017 --max-workers 32

HF_XET_HIGH_PERFORMANCE=1 uv tool run --from 'huggingface_hub[hf_xet]' hf download \
  moonshotai/Kimi-K3.1-Pro --revision main \
  --local-dir /mnt/models/hf/kimi --max-workers 32

DeepSeek V4.1 Flash 1017: two copies at TP4

Copy 0 on GPUs 0 to 3, port 8001. Copy 1 is the same command with device=4,5,6,7 and --port 8002.

docker run -d --gpus '"device=0,1,2,3"' --ipc=host --network host \
  -v /mnt/models:/vol -v /mnt/models/cache/vllm:/root/.cache/vllm \
  -e VLLM_ENGINE_READY_TIMEOUT_S=3600 -e VLLM_USE_RUST_FRONTEND=1 -e HF_HUB_OFFLINE=1 \
  --entrypoint vllm vllm/vllm-openai:latest serve /vol/hf/ds1017 \
  --served-model-name ds --tokenizer-mode deepseek_v41 --tensor-parallel-size 4 \
  --attention-config '{"backend":"FLASHINFER_MLA_SPARSE_DSV41","indexer_kv_dtype":"mxfp4","indexer_sparse_logits":true}' \
  --kv-cache-dtype fp8 --engram-config '{"cpu_offload":true}' \
  --max-cudagraph-capture-size 8190 --max-num-batched-tokens 8192 --max-num-seqs 256 \
  --reasoning-parser deepseek_v41 --tool-call-parser deepseek_v41 --enable-auto-tool-choice \
  --mm-encoder-tp-mode data --port 8001

Kimi K3.1 Pro: TP8, with the --max-num-seqs fix

docker run -d --gpus '"device=0,1,2,3,4,5,6,7"' --ipc=host --network host \
  -v /mnt/models:/vol -v /mnt/models/cache/vllm:/root/.cache/vllm \
  -e VLLM_ENGINE_READY_TIMEOUT_S=3600 -e VLLM_USE_RUST_FRONTEND=1 -e HF_HUB_OFFLINE=1 \
  --entrypoint vllm vllm/vllm-openai:kimi-k31 serve /vol/hf/kimi \
  --served-model-name kimi --trust-remote-code --tensor-parallel-size 8 \
  --load-format fastsafetensors \
  --enable-auto-tool-choice --tool-call-parser kimi_k3 --reasoning-parser kimi_k3 \
  --max-num-seqs 256 --port 8001

The fix is --max-num-seqs 256. Without it, vLLM's default of 1,024 sequences is more than the 603 slots Kimi's linear-attention cache has on B300, and start-up fails at graph capture with:

max_num_seqs (1024) exceeds available Mamba cache blocks (603)

Benchmark client

Run inside the server container, one client per copy, started together. Node throughput is the sum over copies.

vllm bench serve --backend openai --base-url http://127.0.0.1:8001 \
  --endpoint /v1/completions --model ds --tokenizer /vol/hf/ds1017 --trust-remote-code \
  --dataset-name random --random-input-len 1000 --random-output-len 1000 --ignore-eos \
  --num-prompts 128 --max-concurrency 32 --request-rate inf --seed 7 \
  --percentile-metrics ttft,tpot,itl,e2el --metric-percentiles 50,90,99 \
  --save-result --result-dir /vol/run/bench --result-filename ds_tp4_c64_copy0.json

• One user: --num-prompts 8 --max-concurrency 1, one client.
• DeepSeek, 64 users: --num-prompts 128 --max-concurrency 32 on each of the two copies (ports 8001 and 8002).
• Kimi, 64 users: --num-prompts 256 --max-concurrency 64 on its one server, with --model kimi --tokenizer /vol/hf/kimi.

Method

• Node: 8x B300 SXM6 spot, Spheron ES, UK South 1, 192 vCPUs, 2,768 GB RAM, with a 3,000 GB network volume for the checkpoints.
• Rate: $139.58 billed over 2 h 48 min 48 s, which is $49.61 an hour on average. The live spot rate moved from $56.20 to $46.71 during the run, so we priced everything at what we paid.
• Order: one model on the GPUs at a time. A download only overlapped with the previous model's benchmark or warm-up, never with a timed load.
• Cold load: page cache dropped before each timed load, timed from docker run to the first healthy response.
• Speed: vllm bench serve, random prompts of 1,000 tokens in and 1,000 out, EOS ignored so every request writes the full 1,000 tokens. One user: 8 requests one at a time. 64 users: 256 requests at 64 concurrent across the node.
• Memory: nvidia-smi every 5 s for the whole run, plus a snapshot at each steady state.
• Cost: hourly rate / (node output tokens a second x 3,600) x 1,000,000, computed once from the raw numbers and rounded half up.
• Spot check: five fixed prompts, reasoning effort high, temperature 1.0, top_p 0.95, one sample each, scored automatically (the code task runs against a reference).
• The node was terminated the moment the run ended.

Caveats

• Kimi's start was a second attempt. The first start failed at graph capture with the recipe defaults. The working start came about 10 minutes later, so its weights may have been in the host's page cache and the compile cache was already on the volume. Its 167.58 s weight read and 1,800.13 s start are likely better than a true cold start.
• Layouts we did not measure. DeepSeek at TP2 (the recipe's Blackwell default, four copies per node) and Kimi's low-latency decode mode were dropped to stay inside the approved spend. Either could change the result.
• The spot check is 5 prompts, not a benchmark. One sample each at temperature 1.0. Read the model cards for real quality numbers.
• Synthetic load. Random prompts with EOS ignored measure raw decode throughput, not your traffic. Real prompts that stop early, or long contexts, will give different numbers.
• Spot pricing. The rate moved during the run. Your cost per token scales directly with the hourly rate you pay.
• Licences. Kimi K3.1 Pro is open weights under a modified MIT licence: a model-as-a-service business above $20M revenue in 12 months needs a separate agreement with Moonshot, and products above 100M monthly users or $20M monthly revenue must display "Kimi K3.1-Pro". DeepSeek V4.1 Flash is MIT.

Sources

• Kimi K3.1 Pro model card
• DeepSeek V4.1 Flash 1017 model card
• DeepSeek V4.1 Flash NVFP4 (NVIDIA)
• vLLM recipes, B300 flags as of 7 Nov 2026: Kimi K3.1 Pro recipe and DeepSeek V4.1 Flash recipe

Transcript of the video

The narration of the video, by chapter.

0:00 Can you run Kimi K3.1 and DeepSeek V4.1 yourself?

Kimi K3.1 Pro came out this week with 2.8 trillion parameters. DeepSeek updated V4.1 Flash three weeks ago, at about a fifth of that size. We rented one B300 node with eight GPUs and ran both, to answer the questions you would ask before running them yourself: do they fit, how long until the first answer, how fast are they, and what does a million tokens cost.

0:31 How much GPU memory do they need?

Each B300 has 288 gigabytes of memory, so the node has two point three terabytes. Kimi's weights are one point five six terabytes, already in four-bit. It takes all eight GPUs, ninety percent of every one of them. DeepSeek is five hundred and ten gigabytes. It fits on two GPUs. We ran it on four, two copies side by side, and each copy still had room for eighty-five million tokens of cache. Round one: DeepSeek.

0:54 How long until the first answer?

Next, from an empty disk to a first answer. DeepSeek downloaded in under nine minutes. Kimi, three times bigger, in eleven. Then the surprise. Starting the server took forty minutes for DeepSeek and thirty for Kimi. Most of that is not reading weights. It is the server compiling and tuning its kernels for these GPUs. And Kimi's recipe failed on the first try. It needs one extra flag on this node. It is in the description. Either way, you spend thirty-five to forty dollars before the first token. Round two: a draw.

1:26 How fast is it for one user?

Now speed, starting with a single user. Kimi uses 104 billion parameters for every token. DeepSeek uses 16 billion. For one request, DeepSeek writes two hundred and sixty-nine tokens a second. Kimi writes one hundred and one. For one developer with one agent, that is the difference between watching it type and not noticing. Round three: DeepSeek.

1:49 How fast is it with 64 users?

A node is rarely serving one person. So we sent sixty-four requests at once. Kimi, on all eight GPUs: two thousand and seventy-three tokens a second. DeepSeek, as two copies on the same eight GPUs: six thousand eight hundred and fifty-one. That is three point three times the output from the same hardware. Round four: DeepSeek.

2:09 What does a million tokens cost?

Here is what that means in money. We paid an average of forty-nine dollars sixty an hour for this spot node. At sixty-four users, a million output tokens from Kimi costs six dollars sixty-five. From DeepSeek, two dollars and one cent. Same node, same hour, a third of the cost per token. Round five: DeepSeek.

2:27 Are the answers right?

Speed is no use if the answers are wrong. We gave both the same five questions: a billing sum, a counting puzzle, a code task we ran against a reference, a strict JSON reply and a clock sum. Both got all five right, with short answers. Five questions is a spot check, not a benchmark. For quality, read both model cards.

2:49 Which one should you run?

So which one should you run? If you need the biggest open model there is, Kimi runs on one B300 node, and at full load it costs six sixty-five per million output tokens. If you want speed and the lowest cost per token, DeepSeek V4.1 Flash does three times the work on the same node, for two dollars. One more thing: NVIDIA's four-bit build of DeepSeek ran three percent faster again. That is our next video. The commands and the raw numbers are in the description. Rates as of 8 November 2026.

We rented this node by the second and shut it down the moment the run ended. Browse GPUs at spheron.network.

Run Kimi K3.1 Pro or DeepSeek V4.1 Flash on the same kind of 8x B300 node we used here, billed by the second.

Rent B300 → | View all pricing → | Launch a GPU →