vLLM v0.25.0 shipped on July 11 with a line in the changelog that should stop anyone who has followed this project: the legacy PagedAttention implementation is retired.
PagedAttention is the thing vLLM is. The 2023 paper and first release were built on one idea — manage the KV cache the way an operating system manages memory, in fixed-size blocks, instead of reserving one contiguous slab per sequence sized for the longest output it might ever produce. That single move is what let vLLM pack far more concurrent requests onto a GPU than anything before it, and it's the reason "vLLM" and "high-throughput serving" became synonyms. So a release that deletes PagedAttention reads, at first, like a project removing its own foundation.
It isn't. It's the opposite, and the distinction is the whole story.
The idea didn't die. It dissolved.#
What v0.25 removed is the implementation — the standalone PagedAttention code path from vLLM's original architecture. The technique it embodied is now everywhere else. Block-based KV paging lives inside the modern attention backends — FlashAttention, FlashInfer — and inside the V1 engine and Model Runner V2 execution path that every current deployment already runs on. Paging is still exactly how vLLM manages KV memory. There is simply no longer a separate piece of code whose job is to carry it.
An abstraction hasn't fully won until the special-case code that first implemented it can be deleted. PagedAttention just got there.
Think about what that means. In 2023, block-paged KV was a distinct innovation that needed its own machinery bolted into the runner. Six years of the entire inference ecosystem building on the idea later, it is table stakes — the standard attention kernels everyone ships assume it. Keeping the original implementation around meant maintaining and testing a second, redundant path to do something the primary path now does natively. Retiring it removes a burden without removing a single capability. The feature graduated from "named thing you enable" to "how it works."
The other half: there is no old core to be on anymore#
The PagedAttention line is the memorable one, but the load-bearing change is quieter. v0.25 makes Model Runner V2 the default for all dense models.
That closes an arc. MRv2 — the ground-up rewrite that computes input preparation on the GPU with Triton kernels and treats zero CPU–GPU synchronization as a design invariant, so the scheduler prepares step N+1 while the device is still running step N — rolled out deliberately, one model family at a time: Qwen3, then Llama and Mistral dense in v0.23, then quantized models and GraniteMoE in v0.24. The incrementalism was the risk management: swap the execution core under a stable API for one architecture at a time, so any regression is scoped to a family and a rollback is a one-line default flip.
v0.25 finishes the job for dense models. The practical consequence is that "am I on the new core?" stops being a per-family question — because there is no legacy runner left to fall back to. If your family was one of the stragglers still on the old path, this is the release that moves you, whether or not you were watching the default list. The action item is the same one it has been all along: upgrade, then benchmark your own traffic. The MRv2 wins concentrate at the small-to-medium batch sizes that real agent workloads actually produce — a stream of short completions and concurrent tool calls — where per-step host overhead was proportionally largest. A headline tokens/sec on a saturated batch won't show it; your own workload will.
Two smaller lines that matter more than they look#
The Transformers backend now runs as fast as native vLLM. vLLM can serve a model either through a hand-tuned native implementation or through the model's Hugging Face Transformers definition. The Transformers path was the slower correctness fallback you reached for when no native implementation existed yet. Parity changes the day-one story for new architectures: a model that only ships a Transformers implementation is now servable at full speed immediately, so the gap between "this model exists" and "vLLM serves it fast" — the gap that used to send you hunting for a bespoke fork the week a hot model dropped — narrows to almost nothing.
A unified Streaming Parser standardizes how tool-call and reasoning deltas come out of the token stream. If you have ever written brittle client code to reassemble a partial function call from streamed chunks — and handled the case where the stream lies to you — a consistent parser across models and paths is the kind of unglamorous fix that quietly deletes a class of bug.
The through-line#
vLLM spent its first era proving open-source inference could be fast, and PagedAttention was the proof. This release is what maturity looks like from the inside: the founding innovation is so thoroughly absorbed into the standard path that the code named after it can be thrown away, and the newer rewrite it enabled becomes the only core there is. Nothing you run got worse. A maintenance burden got smaller, a fallback got faster, and the special case became the rule. For the project most of the self-hosted world now serves on, deleting your own most-famous line of code and having it change nothing for users is the strongest possible statement that the idea won.
