Execution Pause (VantageV2)

Half of ComfyUI's workflow problem isn't generation, it's the loop between you and the graph: change a value, run, look, change another value, run again - usually re-sampling a base latent that didn't need to change. This node gives you a deliberate stopping point in the middle of execution.

What it does

Wire any value into value, and route the branch you want to control through the value output. On the first Run, the input is evaluated, the branch downstream is blocked, and the node reports that it's waiting. You look at what came out, adjust whatever you like, and press Run again. This time the value passes through unchanged and the rest of the graph continues. Then it re-arms itself for the next run.

resume is the BOOLEAN that encodes that state - false means "pause on this run", true means "let it through". You'll usually leave it alone and let the Run-twice rhythm do the work; it's there so a saved workflow can define its own default.

The single output is value, the same thing you put in, unchanged.

The mechanism, honestly

Three things are going on, and they're all things the KB's plumbing notes treat as engine fundamentals:

IS_CHANGED returns float("NaN") - the idiom that forces a node to run on every single queue rather than being served from cache. NaN isn't equal to itself, so the engine's comparison always says "changed". This is why the node can respond to each Run instead of being skipped as up-to-date.

When it's pausing, the function returns an ExecutionBlocker. That's ComfyUI's sanctioned way to say "this branch produces nothing this run" - downstream nodes on that path don't execute, and don't error.

It's also an OUTPUT_NODE, which is how it reports its waiting state to the UI.

The consequence of that design: independent branches are not stopped. Anything not downstream of this node keeps evaluating and may finish. If you've got a Save Image on a side branch, it'll happily write a file while your main pipeline sits paused. That's not a bug, it's the shape of execution blocking.

The bit that catches people

Run does not resume an old execution snapshot. It re-submits the workflow, and ComfyUI's cache decides what actually re-runs. So if you change an upstream value while paused, upstream nodes may re-execute - which is fine and occasionally useful, but it means "pause" is not a snapshot-and-continue, it's a checkpoint-and-restart-the-tail.

Which means: use it with manual Run. Automatic queueing, or a pre-queued batch of jobs, is not a manual review checkpoint - the queue will just barrel through the pause on the second submission with whatever state it has. The README says this plainly, and it's the one place users get surprised.

Reloading a workflow resets the node to pause, which is the sensible default and also why a saved graph always asks you once more than you expected.

Where it shines

Long-running tails. Generate a base image, pause, then try three different upscale/refine passes without paying for the base again. Or a hand-off in a shared workflow: pause here, and whoever's driving the session gets to look before the expensive part.

The pack's Image Compositor uses the same execution-blocking trick for layer arrangement, so if you've used that one and liked the "press Run again to commit the layout" rhythm, this is the general-purpose version.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/vantagewithai/Vantage-NodesV2.git

Restart, hard-refresh the browser, then find Execution Pause (VantageV2) under Vantage/Utils. ComfyUI Manager should also carry the pack as Vantage-NodesV2; the clone is the documented route.

No dependencies to install - the node imports ExecutionBlocker from comfy_execution, which ships with ComfyUI itself. There's no requirements file and no declared packages in the pack at all. It does need a reasonably modern ComfyUI, since the status display relies on the newer frontend.

Troubleshooting

Nothing downstream runs at all. It's paused - that's the point. Press Run again and watch for the status to clear.

Downstream runs immediately every time. resume is True, or the workflow has been reloaded and re-armed in a state you didn't expect. Reload resets to pause.

The queue blew through it. You used automatic/queued runs. This node needs you to press Run.

Upstream nodes re-sampled after you resumed. Because Run submits the current workflow, and the cache keys on inputs - change something upstream and it re-runs. Keep the paused branch's upstream untouched and the cache behind it holds.