NF Independent Queue

If you've wired an LLM into your graph to write prompts, you already know the annoyance: you want a second draft of the prompt, but pressing Queue re-runs the whole workflow, and by the time you get a prompt you like you've watched the sampler do ten generations you didn't want. Or you turn the LLM seed to fixed, and now you can't reroll the prompt at all.

NF Independent Queue is a node with a Run button that executes only the part of the graph upstream of it and shows you the result right there on the node. Regenerate the prompt as many times as you like. Nothing downstream moves.

Why it exists

Prompt-writing nodes are mainstream now - the whole "prompt enhancer" pattern went from a browser-tab habit to a node in a couple of years, and it fits the architecture, because the encoder is often an LLM reading an instruction anyway. The problem is that an LLM in a ComfyUI graph behaves badly under the normal execution model: it's cheap to run, it's stochastic, and you want to iterate on it without paying for the expensive half of the graph behind it.

The node gives you that iteration loop. And crucially, it gives it to you without breaking the normal Run. Connect the thing you want to watch to value, press Run on the node, look at the text, press it again until you like what you see. Then press the normal Queue - and here's the payoff - with the upstream LLM's own seed control set to fixed, its output is cached exactly as you left it, so the image you generate is built from the prompt you chose without re-running the LLM at all.

How it works

The mechanism is neat and worth understanding, because a lot of what looks like weird behaviour follows from it.

The node you place has no outputs and is not an output node. ComfyUI runs a graph backwards from its output nodes, so a node that feeds nothing is never executed by a normal Run. Instead, the Run button on the node does a partial queue: the frontend grabs the workflow, swaps this node's class_type to NF_IndependentQueueRun - a hidden output-node variant - and posts the prompt with partial_execution_targets set to this node. ComfyUI then executes only that target and its ancestors. The node id stays the same, so progress and results render on the node you actually placed.

seed_mode exists because partial runs bypass ComfyUI's normal control_after_generate handling. If nothing rerolled the seeds, pressing Run again would just hit the cache and show you the identical result. So before each Run the frontend walks the upstream branch and updates every widget that has a linked control_after_generate, including nodes nested inside upstream subgraphs.

The two inputs

• value - type *, i.e. anything. Wire the output you want to inspect here: a STRING from a text or LLM node, an IMAGE, whatever. Text arrives with a Copy button; images come through as a preview; other types get a readable summary (a latent shows its shape, a tensor its dtype and dimensions, long text is truncated for display).
• seed_mode - randomize (default) rolls a fresh random value for every upstream seed that has a control_after_generate; follow applies each seed's own control setting; off leaves all seeds untouched.

off is the one that catches people. With seeds unchanged, the second Run hits the cache and shows the same result - which looks like the button is broken when it's doing exactly what you asked.

There are no outputs to wire. The Run and Cancel buttons are part of the node's UI, added by the pack's frontend.

Installing it

One pack, one install. In ComfyUI Manager search ComfyUI-NF_Suite (it registers as "NF Suite"), or:

cd ComfyUI/custom_nodes
git clone https://github.com/NyaFuP/ComfyUI-NF_Suite.git

Restart after. No requirements.txt, no Python dependencies, no model files - and the built frontend ships in web/, so npm is not involved. Node lives under NF Suite/queue.

Worth repeating because it bites beginners: this pack needs ComfyUI 0.22.0+ and frontend 1.44.19+. It's written against the V3 node API, and the Run button is a custom Vue widget, so on an older frontend the node can show up with no button at all.

Common issues

Run does nothing, or shows the same thing twice. Check seed_mode first - off means the upstream seeds don't change, so you get a cached result. Then check that the node you're trying to reroll actually has an int seed widget with a control_after_generate; a node with a plain text field and no seed can't be rerolled by this node at all.

Nothing happens and there's no button. You're on an old frontend, or the node's JS didn't load. Confirm the version requirements above before debugging anything else.

Put the node in the root graph. The Run button only works at the top level - inside a subgraph it won't function. The upstream seeds inside subgraphs are handled fine when you Run from the root; it's the node itself that has to sit outside.

It's a partial run, so it's not the workflow. Only this node's ancestors execute. If your prompt comes from a node that depends on something set further down the graph, that branch won't run, and the node will show you whatever the upstream produced from its cached state.

Cancel stops the job, not the queue. Cancel interrupts the running job through the normal ComfyUI interrupt path. Anything already queued stays queued.