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

*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.*

*Published 2026-11-15 (UTC) · A small (human) team and a fleet of AI agents.*

**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 (at 220 words/min) · 4 tables · data kit: no

https://research.strata2signal.com/tokens-a-second-in-comfyui/

---

## What the post says, and what we counted {#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*](https://blog.comfy.org/p/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](https://github.com/Comfy-Org/ComfyUI/releases/tag/v0.40.0) (released 2026-10-13) and [v0.45.0](https://github.com/Comfy-Org/ComfyUI/releases/tag/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*](/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 {#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*](/draft-heads-and-speculative-decoding/) 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 {#the-table}

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

| ComfyUI version | Draft off, tokens a second | Draft on, tokens a second |
|---|---:|---:|
| v0.40.0 | 60.7 | 81.9 |
| v0.45.0 | 102.4 | 164.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.*

Tokens a second, each version with the draft head off and on. ComfyUI v0.40.0: Draft off 60.7 tok/s; Draft on 81.9 tok/s. Released 2026-10-13. ComfyUI v0.45.0: Draft off 102.4 tok/s; Draft on 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 {#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.**

| Prompt | v0.40.0, draft on, tokens a second | v0.45.0, draft on, tokens a second | v0.45.0 over v0.40.0, times | Draft on over off at v0.45.0, times | Tokens a round at v0.45.0 |
|---|---:|---:|---:|---:|---:|
| A story | 75.1 | 149.9 | 1.996 | 1.45 | 2.31 |
| Prompt rewrite | 67.3 | 160.2 | 2.381 | 1.57 | 2.53 |
| An explanation | 80.0 | 161.1 | 2.015 | 1.56 | 2.55 |
| Code | 98.0 | 184.2 | 1.880 | 1.80 | 3.35 |
| JSON | 88.4 | 187.1 | 2.115 | 1.83 | 3.41 |
| A table | 92.8 | 192.1 | 2.070 | 1.88 | 3.36 |
| Dialogue | 75.3 | 134.2 | 1.782 | 1.32 | 2.21 |
| Copy and rewrite | 83.8 | 167.9 | 2.002 | 1.67 | 3.06 |
| Verse | 106.8 | 181.6 | 1.700 | 1.77 | 3.13 |
| Spanish | 71.1 | 144.4 | 2.031 | 1.41 | 2.15 |
| The middle of the ten | 81.9 | 164.5 | 2.009 | 1.62 | Not 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).*

How many times as fast v0.45.0 wrote, prompt by prompt, lowest first. Verse: v0.45.0 over v0.40.0 1.700 times. Dialogue: v0.45.0 over v0.40.0 1.782 times. Code: v0.45.0 over v0.40.0 1.880 times. A story: v0.45.0 over v0.40.0 1.996 times. Twice: the line: v0.45.0 over v0.40.0 2.00 times. Our bar, written before the run. Copy and rewrite: v0.45.0 over v0.40.0 2.002 times. A passage copied, then rewritten. An explanation: v0.45.0 over v0.40.0 2.015 times. Spanish: v0.45.0 over v0.40.0 2.031 times. A table: v0.45.0 over v0.40.0 2.070 times. JSON: v0.45.0 over v0.40.0 2.115 times. Prompt rewrite: v0.45.0 over v0.40.0 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 {#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 prompts | Middle, times | Lowest, times | Highest, times |
|---|---:|---:|---:|
| v0.45.0 over v0.40.0, the draft on in both: the figure the claim is read on | 2.01 | 1.70 | 2.38 |
| v0.45.0 over v0.40.0, the draft off in both: every change but the draft head, not split | 1.69 | 1.67 | 1.71 |
| Draft on over draft off, at v0.45.0 | 1.62 | 1.32 | 1.88 |
| Draft on over draft off, at v0.40.0 | 1.36 | 1.11 | 1.76 |
| v0.45.0 over v0.40.0, the draft on, in the post's sampler setting: reported only | 1.82 | 1.74 | 1.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).*

Where the speed comes from: everything but the draft head, the draft head, and both. Draft off in both: Times as fast 1.69 times. All but the draft; lowest 1.67, highest 1.71. Draft, at v0.40.0: Times as fast 1.36 times. Lowest 1.11, highest 1.76. Draft, at v0.45.0: Times as fast 1.62 times. Lowest 1.32, highest 1.88. Both, as shipped: Times as fast 2.01 times. Lowest 1.70, highest 2.38. Post's sampler: Times as fast 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, and what the draft head was worth, prompt by prompt at v0.45.0. Tokens a round, draft on. Spanish: ComfyUI v0.45.0 2.15 tokens. Dialogue: ComfyUI v0.45.0 2.21 tokens. A story: ComfyUI v0.45.0 2.31 tokens. Prompt rewrite: ComfyUI v0.45.0 2.53 tokens. An explanation: ComfyUI v0.45.0 2.55 tokens. Copy and rewrite: ComfyUI v0.45.0 3.06 tokens. Verse: ComfyUI v0.45.0 3.13 tokens. Code: ComfyUI v0.45.0 3.35 tokens. A table: ComfyUI v0.45.0 3.36 tokens. JSON: ComfyUI v0.45.0 3.41 tokens. Draft on over draft off. Spanish: ComfyUI v0.45.0 1.41 times. Dialogue: ComfyUI v0.45.0 1.32 times. A story: ComfyUI v0.45.0 1.45 times. Prompt rewrite: ComfyUI v0.45.0 1.57 times. An explanation: ComfyUI v0.45.0 1.56 times. Copy and rewrite: ComfyUI v0.45.0 1.67 times. Verse: ComfyUI v0.45.0 1.77 times. Code: ComfyUI v0.45.0 1.80 times. A table: ComfyUI v0.45.0 1.88 times. JSON: ComfyUI v0.45.0 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-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 {#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](https://github.com/Comfy-Org/ComfyUI/issues/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 {#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](https://realkeep.strata2signal.com), 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.**

| What | Draft head off | Draft head on |
|---|---:|---:|
| A whole turn, seconds | 15.60 | 15.32 |
| One narration alone, seconds | 1.03 | 0.81 |
| One narration alone, tokens a second | 72.09 | 91.19 |
| The picture inside a turn, seconds | 11.35 | 11.38 |
| The second narration inside a turn, seconds | 2.79 | 2.65 |
| What sharing the card cost a turn, seconds | 4.70 | 4.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*](/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 {#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 {#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](https://huggingface.co/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 {#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 {#sources}

- [*Doubling LLM token rates in ComfyUI*](https://blog.comfy.org/p/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).

<!-- derived 2026-11-16 (UTC) by tools/derive_md.py from the pour source.
     source html sha256: 54b887b7ff4ce55aebfd2958b80c17b6fb20763b93bb0b72574745605c2c4def
     derivation sha256:  86a413fb7ddc67458fe226fb6013283aeb8ca69dbcdddc78f5420da59d4960ca
     the {#id} on each heading is the anchor that heading carries on the page. -->
