By The algorithm that made vLLM famous is officially legacy. vLLM v0.25.0, released July 11, deletes the original PagedAttention implementation and makes Model Runner V2 (MRv2) the default execution backend for all dense models. For anyone running self-hosted LLM inference, this is the most consequential architectural shift in vLLM’s three-year history — and almost nothing breaks.
Model Runner V2 Takes Over
The original vLLM execution path (gpu_model_runner.py) had grown past 6,700 lines. It worked, but contributing to it was miserable, and the monolithic design made optimization increasingly painful. MRv2 is a ground-up rewrite built on three constraints: modular by design, GPU-native for bookkeeping, and async-first rather than async-as-an-afterthought.
The result is measurable. On Qwen3-0.6B running on a single GB200, MRv2 hits 25,000 output tokens per second against MRv1’s 16,000 — a 56% throughput improvement. The gain comes from two places: the scheduler and worker now prepare step N+1 while the GPU executes step N, and speculative decoding drops its CPU–GPU synchronization points entirely. The largest file in MRv2 is now under 1,300 lines.
For most users, the upgrade is invisible. Standard vLLM API calls behave identically. The change only matters if you were reaching into internal vLLM classes and touching PagedAttention directly — which you probably weren’t.
Why the Retirement of PagedAttention Is a Big Deal
PagedAttention was the insight that launched vLLM: borrow the OS virtual memory trick of paging, apply it to transformer KV caches, and stop wasting 60–80% of GPU memory on pre-allocated but unused space. The original 2023 announcement showed 24x higher throughput versus HuggingFace Transformers. It made vLLM the de facto inference serving engine almost overnight.
Retiring that specific implementation doesn’t mean the concept is gone. MRv2 still manages KV caches with paged block allocation — it just does it inside a better-structured, GPU-native execution path instead of a sprawling single file. The idea survived; the original code didn’t.
That’s actually the right outcome. Production software that outlives its founding innovation usually means the innovation got absorbed into something better, not that it was abandoned. vLLM now runs in production at Meta, Mistral AI, Cohere, and IBM. AWS, Google Cloud, and Azure pre-install it on GPU instances. A project at that scale needs architecture that’s maintainable, not just functional.
The Transformers Backend Finally Catches Up
vLLM added a HuggingFace Transformers modeling backend a year ago so that models implemented in Transformers could run inside vLLM without being rewritten. The problem: the Transformers backend was slower than native vLLM implementations, so research teams still had to rewrite models in vLLM-native form for production serving.
v0.25 closes that gap. The Transformers backend now matches or beats native vLLM throughput across models from 4B to 235B parameters, including tensor parallel and MoE setups. Hugging Face CEO Clement Delangue called it a “big unlock for open-source AI inference.” The practical consequence: model authors can implement an architecture once in Transformers and immediately ship it for production inference via vLLM, without a separate hand-optimized port.
Agentic Workloads Get a Proper Parser
vLLM v0.25 also ships a unified Streaming Parser Engine for tool calls and reasoning traces — and if you’ve tried to build reliable agentic pipelines on top of vLLM before, you know why this matters. Every model family (Qwen3, DeepSeek, Kimi) previously shipped its own parser; none handled streaming properly; none worked with speculative decoding.
The new engine handles prefix buffering, partial delimiters across streaming deltas, and mixed token-ID/text parsing uniformly. It covers Gemma4, GLM-4.7, MiniMax M2, Nemotron V3, Qwen3, Kimi k2.5 through k2.7, and DeepSeek V4. Universal speculative decoding across heterogeneous vocabularies also lands in this release — draft and target models no longer need to share the same tokenizer.
What to Check Before Upgrading
The upgrade is straightforward for most teams, but three things are worth auditing:
- PyTorch version: vLLM v0.25 ships on torch 2.11. If you’re on XPU, you were previously pinned to 2.10 — that changes now.
- HuggingFace Transformers: Must be >= 5.0.
- Custom integrations: If any internal code references the PagedAttention implementation classes directly, those need to be removed. Standard API users are unaffected.
Install the patch release: pip install vllm==0.25.1 (fixes two targeted bugs from the 0.25.0 baseline).
What This Signals
vLLM v0.25 is the project graduating from its founding paper. PagedAttention was the wedge that got it adopted; MRv2 is the architecture that will carry it forward. The MRv2 design post is worth reading if you operate vLLM at scale — the modular structure finally makes it practical to contribute optimizations without understanding every corner of a 6,700-line file.
In 2026, inference cost has overtaken training cost as the primary GPU budget line for most AI teams. A 56% throughput improvement on the most-deployed open-source inference engine isn’t a release note footnote — it’s a meaningful reduction in that bill.
