Execution Gate
The node that stops a branch from running at all, not just from being used
- value
- output
Most "switch" nodes in ComfyUI choose between values that were already computed. Execution Gate does something rarer and more useful: with open off, the branch feeding the gate is never evaluated. Not evaluated and discarded - never run. On a graph where upstream is a 60-step sampler and downstream is a video save, that's the difference between a checkbox and a coffee break.
It takes any type. value is a lazy input, so nothing wired into it gets computed while the gate is closed, and the output passes the value straight through while it's open. Which means you can put it anywhere: after a face detector that sometimes finds nothing, in front of an upscale pass you only want on the good runs, or after an expensive conditioning chain you're experimenting with.
The two ways it closes
This is the part to read twice, because the node behaves differently depending on whether open is a widget or a wire.
Leave open as a widget (the default) and turn on bypass_downstream. When you set the switch to false, every node after the gate is drawn as bypassed on the canvas and never reaches the run. It's visual and honest: you can see the dead branch in the graph, and it comes back instantly when you flip the switch. This is the mode to use when you're toggling things by hand, and it's a nicer version of what rgthree's Fast Groups Bypasser does for whole groups.
Wire something into open - a boolean from a detector, a comparison, an expression node - and bypass_downstream stops applying. The frontend can't decorate the graph for a value it won't know until execution, so instead the gate stops the node from the run and ComfyUI draws the first blocked node as failed. The branch is still skipped; it just looks like an error rather than a bypass. Don't panic at the red node if you wired the switch.
closed_message covers the third case: an empty string stops the run quietly, and any text - no face found, nothing to upscale - is drawn on the first blocked node as an error and raised as a notification. That's the difference between "my graph silently did nothing" and a graph that tells you why. Use it. It costs nothing and it's the single best habit this node enables.
How it's able to skip work
The gate is a small node written against ComfyUI's newer backend authoring API - the io.ComfyNode / io.Schema style where a node declares a check_lazy_status() and the engine asks it which inputs to bother evaluating. value is declared lazy, and check_lazy_status() returns it only when the gate is open. When it's closed, that input is never asked for, which is why the whole upstream branch goes unevaluated instead of being computed and thrown away.
That's also the honest catch: this node needs a ComfyUI new enough to have the lazy-input and execution-blocking machinery. The pack's floor is ComfyUI 0.14.0. On anything older the node either won't register or won't block cleanly, and no amount of rewiring will fix it. Update ComfyUI.
Wiring it
[anything] ──value──► Execution Gate ──output──► [the rest of the branch]
▲
open (widget, or a BOOLEAN wire)
Nothing else needed. One input, one output, two optional behaviours.
Install
Part of WAS Node Suite v3 - ComfyUI Manager, search WAS Node Suite v3, or:
cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui.git
Restart after. It installs no Python packages, which is worth saying out loud for this pack specifically, because the versions people find in search results are the old ones: the 2023–2024 WAS Node Suite pinned OpenCV and pulled in face/BLIP dependencies, fought with ComfyUI updates, and produced a memorable wave of "Import Failed" threads after unrelated installs. The author has said publicly more than once that the old pack was more than one person could keep up with. v3 is a rewrite with zero default dependencies - so if you're installing packages to make these nodes load, stop, you're on the wrong branch.
First start writes config.yaml at <ComfyUI user dir>/was-node-suite/ and takes a second longer than later starts. Feature gates for optional node groups live in that file under features:; nothing about the logic nodes is gated.
What it doesn't do
It isn't a value switch - it won't pick between two inputs. It isn't a group mute, and it can't bypass nodes upstream of itself. And unlike a reroute, it costs you something: while closed, everything downstream of the gate is dead, including Save nodes you might have assumed were independent. That's usually the point. Just don't put it in front of your final save without meaning it.
Inputs (4)
| Name | Type | Default | Description |
|---|---|---|---|
| open | BOOLEAN | true | Whether the branch runs. `true` passes value on. `false` skips everything wired into value and stops every node after the gate. |
| valueopt | COMFY_MATCHTYPE_V3 | What to pass on, of any type. The first connection fixes the type. Nothing wired here is evaluated while the gate is closed. | |
| bypass_downstreamopt | BOOLEAN | false | `true` sets every node after the gate to bypass on the canvas while open is off, so they are drawn as bypassed and never reach the run. Read only where open is the gate's own switch: wire anything into open and the value is not known until the run, so the gate stops the nodes from the run instead and ComfyUI draws the first of them as failed. |
| closed_messageopt | STRING | Empty stops the run quietly. Any text, such as `no face found, nothing to upscale`, is drawn on the first blocked node as an error and raised as a notification. |
Outputs (1)
| Name | Type | Description |
|---|---|---|
| output | COMFY_MATCHTYPE_V3 | The value, while the gate is open. Nothing downstream of it runs while the gate is closed. |