Skip to content

Build1 publisher3 min readPublished

NVIDIA's 5x first-token figure needs the vision encoder to own four fifths of your TTFT

Dynamo can now run the vision encoder as its own worker, and the win is real where encoding dominates a request. The arithmetic behind the headline number tells you which traffic it transfers to, and NVIDIA names the one topology it never beats.

The Engineer · Build desk

Illustration accompanying NVIDIA's 5x first-token figure needs the vision encoder to own four fifths of your TTFT

What happened

  • NVIDIA's open source Dynamo inference framework supports encode-prefill-decode disaggregation, splitting the multimodal serving pipeline into independently scalable stages instead of one tightly coupled worker.
  • NVIDIA reports up to 5x faster time to first token and 7x faster end-to-end response time from the technique.
  • Encoder workers hand vision embeddings to prefill-decode workers over NIXL, and Dynamo leaves the hardware placement of the two roles open.
  • In NVIDIA's disaggregated test environment, two RTX 6000D GPUs ran the encoder workers while four GB200 GPUs ran the prefill and decode workers.
  • NVIDIA excludes disaggregating the encoder onto same-class GPUs from its analysis, saying that configuration always underperforms colocating encoder and PD workers.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • constraint The gain has a floor condition rather than a dial: where isolated encode work is smaller than coordination and embedding transfer cost, the split adds a second scheduler and a network hop to requests that were never waiting on the encoder.
  • decision Fleet shape decides the topology before workload does, so on a single-GPU-class cluster the live choice narrows to colocating the encoder or leaving the pipeline alone.
  • cost Reaching the separate-tier economics means owning a second, cheaper GPU class, which turns a serving configuration change into a procurement argument.
  • exposure Operators mixing text-only and image traffic on shared workers are billing text users latency for vision encoding they never asked for, and they are the ones with most to gain.

In aggregated serving, one worker owns vision encoding, LLM prefill and decode inside a single request lifecycle [6]. A request carrying several images therefore runs its own vision transformer pass ahead of its own prefill on the same GPU, and that pass can take hundreds of milliseconds or longer while contending with other requests' prefill and decode [7]. Encode-prefill-decode disaggregation breaks that coupling: the encoder becomes its own worker with its own queue and batching, and the resulting embeddings cross to the prefill-decode worker through NIXL [1][9][11].

Four fifths of baseline time to first token has to come off the critical path for the headline speedup to appear. The arithmetic is not subtle: a 5x reduction leaves the new TTFT at one fifth of the old, so 1 - 1/5 = 0.8 of the original latency must be work the split removes or overlaps [1]. Invert it and you get the transfer test for your own traffic. If encode and its queueing are 20% of your TTFT, the ceiling is 1/(1 - 0.2) = 1.25x before you pay anything for coordination [4], and NVIDIA is explicit that the isolated encode work has to be large enough to offset worker coordination and embedding transfer overhead in the first place [10].

The stated scope is narrow: image-heavy prompts, short-to-medium outputs, and quantized mixture-of-experts models [2]. The material gives that last condition without a mechanism, so it reads as an observation from NVIDIA's own runs rather than something you can reason forward from.

The negative cases are the useful part of the post. Aggregated serving stays the right design when media processing is only a small portion of the workload [6]. Disaggregating the encoder onto same-class GPUs is worse than colocation every time, which is why NVIDIA drops that configuration from its comparison entirely [15]. The reason is sizing: the vision encoder is lightweight next to the LLM, so a whole same-class GPU dedicated to encode work sits largely idle [12]. Reserving a top-tier accelerator to run a ViT is an expensive way to keep a device warm.

That leaves colocation as the default on a homogeneous fleet [12], and the separate-tier topology as something you can only buy your way into. NVIDIA's disaggregated test ran one encoder GPU for every two prefill-decode GPUs [14][2], with the encoders on the cheaper class [13]. Note also what the material does not say: the up-to-5x figure is never attributed to that specific topology or to a named workload [3].

Hardware availability decides where the encoder can run, and workload characteristics decide whether moving it pays [16]. Media volume alone does not settle the second question, because what matters is the share of request processing time vision encoding actually consumes [17]. The measurement that decides it is one you take on production concurrency, including the text-only requests currently sitting behind image requests that need no encoder at all [8].

What to watch

  • Whether NVIDIA publishes per-topology TTFT numbers behind the up-to-5x figure, with the image count and output length that produced it.
  • Whether the NIXL embedding transfer cost gets characterised, since that overhead is the threshold isolated encode work has to clear.
  • Whether the colocated-encoder default survives measurement once encoder and PD workers contend for the same GPU under production concurrency.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories