The bench

Tokens a second in ComfyUI, v0.45.0 against v0.40.0, on one RTX 3090

exhibit one hundred and fourteen The bench
Published 2026-11-15 (UTC)
A small (human) team and a fleet of AI agents.

ComfyUI's built-in language model, the one behind its Generate Text node and its prompt enhancers, timed at two ComfyUI versions from one Qwen3.5 9B file on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W. ComfyUI's own post says v0.45.0 writes "up to twice as fast" as v0.40.0. On this card it does, at the line: 164.5 tokens a second against 81.9 with the draft head on, as both versions ship, which is ×2.01 at the middle of ten prompts with four of the ten under 2.00. With the draft head off it is 102.4 against 60.7. And with the draft head on, the text is not the text the same model writes with it off, on 10 prompts of 10, while repeating itself exactly when the same requests ran again in the same order.

ask about this page → assistant.strata2signal.com · in beta, still being tested

hardware on this page: RTX PRO 6000 Blackwell (96 GB) · RTX 3090 (24 GB) → research.strata2signal.com/hardware/ · the roster is in beta, still being tested

the short version

On one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W, ComfyUI v0.45.0 wrote 164.5 tokens a second from qwen3.5_9b_w4a8_gptq.safetensors with its draft head on (the text node's mtp setting on auto, the default) and 102.4 with it off; v0.40.0 wrote 81.9 and 60.7. Each figure is the middle of ten prompts, sampling off, up to 2,048 tokens a text. Version against version with the draft head on, the way both ship: ×2.01 at the middle, ×1.70 on the lowest prompt, ×2.38 on the highest. So the post's "up to twice as fast" holds on this card, at the line: four of the ten prompts came in under 2.00. With the draft head off in both, v0.45.0 is worth ×1.69, nearly the same on every prompt (every change between the two versions but the draft head, the post's new kernel among them, not split); the draft head adds ×1.62 at v0.45.0 and ×1.36 at v0.40.0, more on code and tables and less on dialogue. In the post's own sampler setting the figure is ×1.82, reported and deciding nothing. With the draft head on, the text differed from the draft-off text on 10 prompts of 10 at both versions, and it repeated itself exactly, at 30 of 30 places when the session ran again in the same order; why, this bench did not read. On 48 closed questions each of the four states scored 33. With the model loaded the card read 7,406 to 7,458 MiB in use between requests; of 466 requests none crashed. One card and one file. A second bench timed a stand-in turn of our game RealKeep on the same card, two short narrations and a quick sketch: 15.60 s with the writer's draft head off and 15.32 s with it on, 1.8 per cent shorter. The bet was written down before the run.

3,963 words, about 18 minutes to read.

The summary is this page’s own; the receipt lines were drafted by a model on this workshop’s network and every figure in them is in the article, checked before this page went out — what was dropped, and why, is in this page’s receipt file.

What the post says, and what we counted

ComfyUI also runs language models, behind its Generate Text node and the prompt enhancers of the newer image models. On 2026-11-11 ComfyUI's blog published Doubling LLM token rates in ComfyUI. Of the Qwen3.x models it says that "the same checkpoints on the same GPU can now generate tokens up to twice as fast, with no change to the model or the quality of what it writes", between v0.40.0 (released 2026-10-13) and v0.45.0 (released 2026-11-10). Its chart's figures are for RTX 50-series cards and do not give the prompt, the sampler or the number of runs behind each bar, so none of ours is set against them.

We tested it on a card the post's text does not name, and wrote the test down first (Why we write the bet down first): two clean installs, one model file, ten prompts of ten kinds. The post says "up to twice as fast". Before the run we wrote down a stricter reading as our bar: twice, 2.00, at the middle of the ten prompts' ratios, each version with its draft head on, as it ships. That is why our registered verdict line says "at least twice": it is our bar, not the post's words. Under 2.00 the verdict would have read "holds in part", and under 1.10 "does not hold". The registration was frozen at 23:14:35 UTC on 2026-11-13; the first request went 33 seconds later and the last ended at 00:41:10 UTC on 2026-11-14, 86 minutes after the first.

What a token a second is here. We count the tokens of the text the node returned, with one tokenizer for both versions, over ComfyUI's own start and end stamps for the whole request with the model already loaded: reading the prompt, every step, decoding. It is not the progress bar's it/s. Each prompt ran three times in each state; a prompt's figure is the middle of its three, and a version's the middle of its ten prompts.

The draft head, and where its switch is

A draft head is a small extra part of the checkpoint that guesses the next few tokens, so the model can check several guesses in one trip through its weights and keep those that match its own choice. ComfyUI calls it MTP, multi-token prediction; our guide Draft heads and speculative decoding, in plain words explains the idea. This file carries one: 15 tensors named mtp.* in its header.

The switch is one drop-down on the text node, named mtp. Its default is auto at both versions, so the draft head is on unless you choose off. We ran auto and off; both versions also offer fixed depths, and v0.45.0 four tree modes. In v0.45.0's menu the node is Generate Text (TextGenerateV2), and the older TextGenerate, the only one v0.40.0 has, shows as Generate Text (DEPRECATED); by our read of the code the two differ in their list of inputs and run the same code. We used TextGenerate at both, so one graph served both: CLIPLoader (the file, type stable_diffusion) into TextGenerate with max_length 2,048, sampling_mode off, thinking false and use_default_template true.

Every draft-on figure below, except the one in the post's sampler setting, carries one label: the model's own draft head, mtp on auto, sampling off, one request at a time. The engine logs no acceptance, so tokens a round are our own probe's count, from a separate run.

The table

Tokens a second, the middle of ten prompts, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W.

ComfyUI versionDraft off, tokens a secondDraft on, tokens a second
v0.40.060.781.9
v0.45.0102.4164.5
Tokens a second, each version with the draft head off and on One model file, qwen3.5_9b_w4a8_gptq.safetensors, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W, sampling off, each text up to 2,048 tokens, one request at a time, on 2026-11-13 and 2026-11-14 (UTC). Each bar is the middle of ten prompts, each prompt the middle of three runs. Drafter: the model's own draft head, the node's mtp setting on auto; the engine logs no acceptance.

Draft off Draft on

ComfyUI v0.40.0 60.7 tok/s 81.9 tok/s Released 2026-10-13 ComfyUI v0.45.0 102.4 tok/s 164.5 tok/s Released 2026-11-10

From this page's first table; every figure is in the bench's score file, read from the bench's rows by two scorers and counted a third time for this page.

v0.45.0 was the faster version in either state, and with its draft head off (102.4) it outwrote v0.40.0 with it on (81.9).

Version against version with the draft head on, as both ship, the middle of the ten prompts' ratios is ×2.01, the lowest ×1.70 and the highest ×2.38. So the registered line, in our bar's words, reads: on our card the post's claim holds: v0.45.0 wrote at least twice as fast as v0.40.0 from the same file, and we saw no gross change in what it wrote. It holds at the line, and the next table shows how near. ("No gross change" is the registered phrase for the 48 closed questions; the long texts did change, as shown below.)

At the line: the ten prompts

The ten prompts, each with the draft head on as both versions ship, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W.

Promptv0.40.0, draft on, tokens a secondv0.45.0, draft on, tokens a secondv0.45.0 over v0.40.0, timesDraft on over off at v0.45.0, timesTokens a round at v0.45.0
A story75.1149.91.9961.452.31
Prompt rewrite67.3160.22.3811.572.53
An explanation80.0161.12.0151.562.55
Code98.0184.21.8801.803.35
JSON88.4187.12.1151.833.41
A table92.8192.12.0701.883.36
Dialogue75.3134.21.7821.322.21
Copy and rewrite83.8167.92.0021.673.06
Verse106.8181.61.7001.773.13
Spanish71.1144.42.0311.412.15
The middle of the ten81.9164.52.0091.62Not a middle
How many times as fast v0.45.0 wrote, prompt by prompt, lowest first ComfyUI v0.45.0 over v0.40.0, the draft head on in both as each version ships, one bar a prompt: that prompt's tokens a second at v0.45.0 divided by its tokens a second at v0.40.0, each the middle of three runs. The bar marked Twice is the line and not a prompt. Four prompts sit under it and six over it; the middle of the ten is 2.009. One model file, qwen3.5_9b_w4a8_gptq.safetensors, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W, sampling off, each text up to 2,048 tokens, one request at a time, on 2026-11-13 and 2026-11-14 (UTC).
Verse 1.700 times Dialogue 1.782 times Code 1.880 times A story 1.996 times Twice: the line 2.00 times Our bar, written before the run Copy and rewrite 2.002 times A passage copied, then rewritten An explanation 2.015 times Spanish 2.031 times A table 2.070 times JSON 2.115 times Prompt rewrite 2.381 times The post's own example image prompt, rewritten

From this page's table of the ten prompts; every ratio is in the bench's score file.

Four of the ten prompts sit under 2.00 and six over it. Two sit within a quarter of one per cent of it, the story at 1.996 and the copied passage at 2.002. The middle of the ten is 2.009, which the registration prints as ×2.01 and the word "holds" rests on. That is what "at the line" means on this page: the middle cleared our bar of twice by 0.009. (Ratios are taken before rounding.)

The prompt rewrite, which reworks the post's own example image prompt, gained most and verse least: the draft head gave ×1.57 at v0.45.0 against ×1.11 at v0.40.0 on the rewrite, and ×1.77 against ×1.76 on verse.

What moves the figure

ComfyUI's speed as ratios: each row is the middle of the ten prompts' own ratios, with the lowest and the highest.

Ratio, over the ten promptsMiddle, timesLowest, timesHighest, times
v0.45.0 over v0.40.0, the draft on in both: the figure the claim is read on2.011.702.38
v0.45.0 over v0.40.0, the draft off in both: every change but the draft head, not split1.691.671.71
Draft on over draft off, at v0.45.01.621.321.88
Draft on over draft off, at v0.40.01.361.111.76
v0.45.0 over v0.40.0, the draft on, in the post's sampler setting: reported only1.821.741.93
Where the speed comes from: everything but the draft head, the draft head, and both Each bar is the middle of ten ratios, one a prompt, and its second line gives the lowest and the highest of the ten. Draft off in both is v0.45.0 over v0.40.0 with the draft head off in each: every change between the two versions but the draft head, which this run did not split. The draft's share is draft on over draft off inside one version. Both together is the figure the claim is read on. The last bar repeats it in the post's own sampler setting, reported only and deciding nothing. One model file, qwen3.5_9b_w4a8_gptq.safetensors, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W, sampling off, each text up to 2,048 tokens, one request at a time, on 2026-11-13 and 2026-11-14 (UTC).
Draft off in both 1.69 times All but the draft; lowest 1.67, highest 1.71 Draft, at v0.40.0 1.36 times Lowest 1.11, highest 1.76 Draft, at v0.45.0 1.62 times Lowest 1.32, highest 1.88 Both, as shipped 2.01 times Lowest 1.70, highest 2.38 Post's sampler 1.82 times Lowest 1.74, highest 1.93

From this page's second table; every ratio is in the bench's score file.

A middle of ratios is not the ratio of the two middles: 164.5 ÷ 102.4 is 1.61, and the middle of the ten ratios is 1.62.

Everything but the draft head. With the draft head off, v0.45.0 wrote ×1.69 as fast as v0.40.0, and the text hardly mattered: 100.5 to 103.7 tokens a second against 59.2 to 60.8. That ratio holds every change between the two versions apart from the draft head; the post names several, the new kernel among them, and nothing here splits them. What our probe read, as a reading and not as the cause: 200 of 200 of the model's 4-bit layers in v0.45.0's packed layout, and 0 of 200 at v0.40.0, whose library has none.

The draft head. Here the text matters. The post says what changed: v0.40.0 drafts "a single chain of token guesses", v0.45.0 a tree of them whose shape it re-plans as it writes. Our probe counted 2.15 to 3.41 tokens a round at v0.45.0 and 2.03 to 3.57 at v0.40.0. Broadly, the prompts that kept more tokens a round gained more from the draft head, as the next chart shows; the order is not exact. Tokens a round is a ceiling and not the speed-up, as the guide says: 3.41 tokens a round bought ×1.83.

Tokens a round, and what the draft head was worth, prompt by prompt at v0.45.0 Upper panel: tokens a round with the draft head on, counted by our probe in a separate run, since the engine logs none; fewest first. Lower panel: the same prompts in the same order, draft on over draft off in tokens a second. Broadly, the prompts that kept more tokens a round gained more from the draft; the order is not exact. ComfyUI v0.45.0. One model file, qwen3.5_9b_w4a8_gptq.safetensors, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W, sampling off, each text up to 2,048 tokens, one request at a time, on 2026-11-13 and 2026-11-14 (UTC).
Tokens a round, draft on Spanish 2.15 tokens Dialogue 2.21 tokens A story 2.31 tokens Prompt rewrite 2.53 tokens An explanation 2.55 tokens Copy and rewrite 3.06 tokens Verse 3.13 tokens Code 3.35 tokens A table 3.36 tokens JSON 3.41 tokens Draft on over draft off Spanish 1.41 times Dialogue 1.32 times A story 1.45 times Prompt rewrite 1.57 times An explanation 1.56 times Copy and rewrite 1.67 times Verse 1.77 times Code 1.80 times A table 1.88 times JSON 1.83 times

From this page's table of the ten prompts; the tokens a round are our probe's count, not the engine's log.

The sampler. Everything above is with sampling off, so a text can be compared with itself. With sampling on at the node's defaults, which the post's screenshots show (temperature 0.7, top_k 64, top_p 0.95, min_p 0.05, repetition_penalty 1.05), at seeds 0, 1 and 2, the version ratio with the draft head on was ×1.82, and none of the ten prompts reached 2.00, a figure registered as reported only that decides nothing.

Not the noise. A prompt's three runs varied by at most 1.6 per cent of their mean as a standard deviation (2.8 per cent from lowest to highest) in any of the four states, and the v0.45.0 session, run again an hour later, matched its first run to ×1.00.

With the draft head on, it is a different text

With sampling off the model takes its top choice at every step. We compared the texts byte for byte, and print counts, never an output.

  1. With the draft head off, a prompt wrote one text: 10 of 10 at each version, and the same bytes at 30 of 30 places when the v0.45.0 session ran again.
  2. With it on, the text was not the draft-off text: 10 of 10 at each version, parting as early as token 11 and as late as token 1,264 at v0.45.0 (33 and 1,562 at v0.40.0). The draft-on text repeats: one text over three runs on 10 of 10, and the same bytes at 30 of 30 places in the second session.
  3. The two versions do not write each other's text: 0 of 10 alike with the draft head off, 0 of 10 with it on.

The draft-on and draft-off texts also differ in length on 5 of 10 prompts at v0.45.0 and 6 of 10 at v0.40.0, by 1 token to 900 and in both directions; the draft-on text was the shorter on 8 of those 11; the widest is the dialogue prompt at v0.45.0, 1,265 tokens with the draft head off and 365 with it on.

What was not read is why. The textbook rule for speculative decoding keeps the model's output distribution, within the card's arithmetic (the guide has the papers), and the node's tooltip speaks only of sampling: "Sampled output stays correctly distributed but differs from non-MTP output for the same seed." This bench shows something narrower: in this implementation, on this file and card, the top-choice text with the draft head on is not the top-choice text with it off. A difference alone does not show that either text is worse.

Our one check on that is 48 closed questions with one right answer each, sums and counts and the like. Each of the four states scored 33 of 48, all 48 answers in the expected form. They were the same 33 questions in all four states. That check can see a net change of three answers or more and nothing smaller; it is not a quality score, and "no gross change" is as far as it goes.

In practice, a workflow that needs mtp on to give the text mtp off gave will not get it. One that needs the same text each time got it here in either state, for the same requests in the same order.

One caution on "repeats itself", from a check of the instrument before the registered run, not from the run: at v0.45.0, with the draft head on, one of two short prompts outside the ten wrote one text at its first two places in a session and another from its third place on, in both of two sessions 17 hours apart.

Memory, heat and crashes

With the Qwen3.5 9B file loaded in ComfyUI, the RTX 3090 read 7,406 to 7,458 MiB in use between requests, of 24,576, and 7,934 MiB at the highest of 1,016 samples. It reached 68 °C and its fan 59 per cent. Of 466 requests, 271 with the draft head on, none crashed or was thrown out. ComfyUI's open issue 17115 describes a crash with mtp on auto on an RTX 3090 Ti; we met none, which is our count and no finding about that report.

What it would mean for a turn of RealKeep

This section is a second bench, run for this page: a reading, not arithmetic. In RealKeep, the small role-playing game this workshop builds, a language model narrates each turn, and when the scene changes, with the sketch feature on, a picture model paints a quick sketch. We timed a stand-in for that turn on our bench box's one NVIDIA GeForce RTX 3090 (24 GB) at the same 250 W cap: a narration asked for in about seventy words, a FLUX.2 quick-sketch graph the game ships (not its default; FLUX.2 [klein] 4B, 12 steps, 768 × 768) and a second narration, run in series in the same ComfyUI v0.45.0 with this page's Qwen3.5 9B file as the writer. The registration, with four bets in it, was frozen at 04:50:00 UTC on 2026-11-14, and the run went from 21:00:14 to 21:18:53 UTC that day.

A stand-in turn and its parts, each the middle of twelve, on one NVIDIA GeForce RTX 3090 (24 GB) capped at 250 W.

WhatDraft head offDraft head on
A whole turn, seconds15.6015.32
One narration alone, seconds1.030.81
One narration alone, tokens a second72.0991.19
The picture inside a turn, seconds11.3511.38
The second narration inside a turn, seconds2.792.65
What sharing the card cost a turn, seconds4.704.83

A turn took 15.60 s with the writer's draft head off and 15.32 s with it on, 1.8 per cent shorter. The picture was 72.8 per cent of the draft-off turn. At narration length, where the answers ended on their own near 74 tokens, the draft head was worth ×1.27 (×1.19 to ×1.32 over the twelve), against ×1.62 on this page's long texts. All four bets were written before the run, and all four held.

Why so little. The writer and the painter's three files do not fit on the 24 GB card together, so each is loaded again after the other, in every one of the 24 turns. The picture took 11.35 s inside a turn against 8.86 s alone, and the second narration 2.79 s against about 1.03 s for a first narration alone. The scorer prints that as what sharing the card cost, a turn less its parts timed alone: 4.70 s of a turn, against about 0.3 s the draft head saved.

What this does not say. The writer is a stand-in and not the game's narrator. The game paints its sketch on a lane of its own and sends the narration without waiting, so these seconds are the card's busy time for one scene change and not what a player waits for. The painter has no draft head. One card, one cap, one host; part of what sharing cost may be the host's memory and not the card's, and these runs cannot tell the two apart.

For an engine built around a draft head, what is on record is the Strata engine (github.com/Niko1221/Strata, an unrelated project), drafting from Qwen3.8-Flash-Next's own head: 205.263 tokens a second on an NVIDIA RTX PRO 6000 Blackwell Workstation Edition (96 GB) at 300 W, against 102.889 for llama.cpp with no draft head (Qwen3.8-Flash-Next on three cards): two engines a night apart, the draft head's share of the lead not split by any run. It was not run here.

Every figure here is the bench's scorer's, two scorers agreeing on 47 gate numbers, except the two "inside a turn" rows and the 74 tokens, which are recounts of its rows. Its outputs are not published.

What this page does not say

  • Another card or file. Not an RTX 50-series or AMD card, another cap, the 27B, or this 4-bit file against the full-precision model; and memory in use on a 24 GB card is no test of fit on a smaller one.
  • That twice is typical. The middle of ten prompts is ×2.01, at the line, with four under 2.00; in the post's sampler setting, ×1.82, reported only.
  • Short texts. In the version test the shortest timed text was 365 tokens. The only short texts timed are the turn bench's narrations of about 74 tokens, at v0.45.0 alone.
  • Why v0.45.0 is faster with the draft head off. That ×1.69 is every change but the draft head, not split; the probe read a layout, not a mechanism. v0.40.0's route inside its library's CUDA function was not read, and its draft depth is not logged.
  • Why the draft-on text differs, or which is better. Nothing scored a long answer.
  • The full bench. This is its small rung; the 27B file, a full-precision reference, fixed draft shapes and a second card are deferred.
  • Image generation speed. One quick sketch was timed, as part of a turn; nothing here compares picture speeds or versions.

How to check our work

  • The versions. ComfyUI v0.45.0 at commit 989d93d0d968e704c589ce0146bb18c77f6b50cc and v0.40.0 at 3541246a9c997f4b8c32f9f88f3c985d02021c79, each a clean tree and environment built by the README's two pip steps. The two environments differ in eight packages and no others, comfy-kitchen (0.2.41 against 0.2.37) and comfy-aimdo (0.6.0 against 0.5.6) among them; Python 3.13.15 and PyTorch 2.15.0+cu132 in both; no launch flag that changes behaviour.
  • The card. One EVGA GeForce RTX 3090 XC3 Ultra (24 GB), its power limit at 250 W in every one of the run's 1,016 card samples.
  • The file. qwen3.5_9b_w4a8_gptq.safetensors from Comfy-Org/Qwen3.5, 7,343,591,088 bytes, sha256 4cc6a1543ad2061806da46f35f90cadb4801dcba246c44782cf42ec0feb6407c.
  • The graph and the request. The graph above, one request at a time, each session one fixed list in one order, sent whole: one server start a session, every place at its own index, every run after the two warm ones proven at its first try. ComfyUI answers a repeated graph from its cache, so a StringReplace node ahead of the text node carried a fresh tag each run that changed no byte of the prompt.
  • The prompts. The two versions' default templates end differently, so both were sent v0.45.0's frame: v0.40.0 ran on v0.45.0's prompt bytes.
  • The turn bench. The same card, cap, ComfyUI v0.45.0 commit and writer file. The painter is RealKeep's flux2-klein-sketch.json graph (sha256 8c44f292794a110982d279978d4f0cefb5624d08149537833a24bcda117b0d7f) with flux-2-klein-4b.safetensors (ec3d4e733a771f61c052fb4856c48b336c55eaf2c65487c2a1faeb9bbda7a343), qwen_3_4b.safetensors (6c671498573ac2f7a5501502ccce8d2b08ea6ca2f661c458e708f36b36edfc5a) and flux2-vae.safetensors (868fe7b343cc8f3a19dbcfcafbc3d5f888802be3f89bd81b65b3621a066ce8f3): 12 steps, euler, cfg 1.5, 768 × 768. One list of 255 requests, one sitting, 252 counted, every one proven; a turn is three requests queued together.
  • The count. Two scorers written apart agree on 177 gate numbers for the version test and on 47 for the turn bench. The outputs are not published.

Who ran this, and thanks

Thanks to ComfyUI's maintainers, and to the post's author, rattus128, for a post that names its versions and its switch, which made it testable. The runs stood on ComfyUI with comfy-kitchen and comfy-aimdo, Alibaba's Qwen3.5 9B as Comfy-Org publishes it on Hugging Face, Black Forest Labs' FLUX.2 [klein] 4B for the sketch, an NVIDIA card and driver, PyTorch, CUDA and Astral's uv.

A small human team owns the card, gave the go and ruled on the calls put to it; AI agents did the rest, this page included, under that team's rulings.

Sources

  • Doubling LLM token rates in ComfyUI, rattus128, 2026-11-11; read 2026-11-12 and 2026-11-14 (UTC).
  • ComfyUI's two releases, its node source at each tag, the model file's listing and issue 17115 (open): read 2026-11-14 (UTC).

If something here helped you, or you use our research or our data kits in your own work, please link back to this page.

elsewhere in the workshop

a strata→signal property · hello@strata2signal.com · say hello