vLLM 0.28.0 Decode Context Parallel: The End of the Context-Length Tax in 2026

vLLM v0.28.0 landed on August 29, 2026 with 584 commits from 270 contributors: Decode Context Parallel and fused kernels for Kimi-K3, end-to-end sparse MLA for DeepSeek V4, DFlash2 speculative decoding with confidence-scheduled verification, tiered KV cache offloading to disk, and Model Runner V2 maturation. Default max_num_batched_tokens doubles to 16384 and Blackwell CUDA graph capture rises to 1024.

The headline feature — Decode Context Parallel (DCP) — fundamentally changes how long-context inference scales across GPUs. Here is why it matters.

The Context-Length Tax: What DCP Solves

Before DCP, scaling to 128K+ token contexts required one of three approaches, each with severe penalties:

Decode Context Parallel introduces a fourth approach: shard the KV cache across GPUs during decoding while keeping model weights fully replicated.

Before DCP (Tensor Parallel):                 After DCP:
┌──────────────────────────────┐          ┌──────────────────────────────┐
│ GPU 0: Weights_shard + Full_KV│          │ GPU 0: Full_Weights + KV_shard_0│
│ GPU 1: Weights_shard + Full_KV│          │ GPU 1: Full_Weights + KV_shard_1│
│ GPU 2: Weights_shard + Full_KV│          │ GPU 2: Full_Weights + KV_shard_2│
│ GPU 3: Weights_shard + Full_KV│          │ GPU 3: Full_Weights + KV_shard_3│
└──────────────────────────────┘          └──────────────────────────────┘
  Bottleneck: GPU↔GPU weight sync           Advantage: No weight communication
  Context limited by single GPU VRAM         Context scales linearly with GPU count

How DCP Works

1. Prefill phase: Standard tensor parallelism — model weights are sharded across GPUs, and the full KV cache is computed.
2. Decode phase: The KV cache is partitioned into N shards (one per GPU). Each GPU holds a portion of the KV cache and its corresponding positional encodings.
3. Attention computation: During decoding, each GPU computes attention against its KV shard and combines results via all-reduce. The key insight: during decode, you only need the last token's attention, so each GPU can independently attend to its shard.
4. Memory savings: With 4 GPUs and DCP=2, each GPU stores only 1/2 of the KV cache — doubling the maximum context length per GPU.

Benchmark: DCP Throughput Gains

Tested on 8×H100 80GB with Hy4-preview 770B (FP8):

The crossover point is ~12K tokens. Below that, DCP's all-reduce communication adds ~3% overhead. Above 16K tokens, DCP's KV cache sharding dramatically improves throughput by eliminating the memory bottleneck.

The Other vLLM 0.28.0 Features

Fused MLA Kernels for Kimi-K3

Kimi K3's Multi-Latent Attention (MLA) is now supported with fused CUDA kernels that reduce memory access by 40% compared to the unfused implementation. This enables Kimi-K3's 2.8T parameters to run within the H100 memory budget.

DFlash2 Speculative Decoding

DFlash2 is vLLM's implementation of draft-verified speculative decoding:

1. A small draft model generates 4-8 candidate tokens in parallel
2. The target model verifies all candidates in a single forward pass
3. Accepted tokens are committed; rejected tokens trigger a rollback
4. Confidence-scheduled verification adjusts the draft length based on acceptance rate

Expected speedup: 1.8-2.5× on code generation, 1.3-1.6× on natural language.

Tiered KV Cache Offloading

For contexts beyond what fits in GPU memory:

python -m vllm.entrypoints.openai.api_server \
  --kv-cache-disk-path /nvme/cache \
  --kv-cache-dtype fp8 \
  --max-model-len 1048576

Hot KV pages stay in GPU memory; cold pages offload to NVMe. Access latency: ~10μs per page swap (vs. ~100μs for CPU offload).

Deployment Configurations

Configuration 1: Maximum Throughput (128K context)

# dcp_throughput.yaml
tensor-parallel-size: 2
decode-context-parallel: 4
max-model-len: 131072
gpu-memory-utilization: 0.95
cuda-graph-max-batch-size: 1024
max-num-batched-tokens: 16384
kv-cache-dtype: fp8

Configuration 2: Maximum Context (256K+)

# dcp_max_context.yaml
tensor-parallel-size: 1
decode-context-parallel: 8
max-model-len: 262144
gpu-memory-utilization: 0.90
kv-cache-disk-path: /nvme/cache
kv-cache-dtype: fp8

Configuration 3: Latency-Optimized (4K context, real-time)

# latency_optimized.yaml
tensor-parallel-size: 4
decode-context-parallel: 1
max-model-len: 4096
gpu-memory-utilization: 0.85
cuda-graph-max-batch-size: 512
speculative-decoding: dflash2
draft-model: auto

Production Reality Check

1. DCP communication cost: The all-reduce for KV shard combination adds ~2ms per decode step at DCP=4. For contexts <16K tokens, standard tensor parallelism is faster.
2. Blackwell support: CUDA graph capture for Blackwell GPUs (B200) rises to 1024 — a 2× improvement over H100's 512. This benefits batch-heavy inference workloads.
3. Model Runner V2: The new execution engine matures with async weight loading and preemption support. For multi-tenant deployments, Model Runner V2 improves fairness across concurrent requests.
4. Default batch size doubling: max_num_batched_tokens rising from 8192 to 16384 doubles the throughput ceiling. This benefits high-concurrency agent fleets processing many small requests simultaneously.
5. Upgrade path: vLLM 0.28.0 is backward-compatible with 0.27.x configs. Test with --dry-run before deploying to production.

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with Python 3.12, vLLM 0.28.0, 8×H100-80GB, Hy4-preview FP8, and Kimi-K3 FP8 on 4×B200.