H3 Pass Gate

A long video is rendered twice: once cheap at low resolution to check the cut, then again at full size for the segments you approved. In a normal ComfyUI graph those two branches both exist, and the only way to stop the expensive one running is to bypass seven nodes by hand - every time, without forgetting one.

H3 Pass Gate decides which half of the graph runs, from a widget. It sits right after the base sampler, takes the latent and the shot token, and hands out two of each.

How it avoids the cost

ComfyUI can't bypass nodes from Python. What it can do is refuse to execute a branch: anything downstream of an ExecutionBlocker is skipped entirely. So the blocked half isn't just idle - it costs no VRAM and no time. When H3 Project is set to draft, the upscale branch is dead weight that never spins up.

The two outputs each get their own copy of the shot token with the pass stamped on it: draft_shot says draft, final_shot says final. That's the trick that keeps the wiring dumb. You wire one H3 Vault Write to the draft decode and another to the final decode, and each files into the right slot with nothing to configure.

Inputs and outputs

Two inputs, both required:

• shot - from H3 Shot Dispatcher. This is the wire that goes around the sampler, and it's what carries the segment id, pass and take.
• latent - the base video latent. The tooltip is specific: this wants the latent straight off LTXVSeparateAVLatent. The draft branch decodes that latent as it is; the final branch feeds it to your latent upscaler and second sampler.

Outputs: draft_latent, draft_shot, final_latent, final_shot, and info. The info string tells you the mode and which branch is live for this run, which is the fastest way to confirm you actually got the cheap pass.

The mode comes from render_pass on H3 Project: draft runs the base branch only, final runs the upscale branch and stores finals, one_go runs both from a single base sample and stores a draft and a final for every segment.

Why you need it at all

Without the gate there's only one pass name in the graph. Add a second Vault Write and it overwrites the first one - your carefully promoted final and your draft share a filename, and the promote isn't reversible because there's nothing left to go back to.

With the gate, a draft and a final for the same segment are separate vault entries under (segment, pass, take). Promotion never overwrites, so demoting is just changing which one the stitcher prefers.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/AIJigyasa/ComfyUI-H3-Planner

Restart, or install MiniMax H3 Planner from ComfyUI Manager. The gate itself has no dependencies; the pack needs ffmpeg on PATH (or pip install imageio-ffmpeg) and a ComfyUI with the MiniMax H3 nodes, since sampling stays in your graph.

Where people get burned

Switching render_pass to draft does not make drafting cheap if the gate isn't in the graph. This is the most annoying gotcha in the whole pack, and it's documented in the pack's own workflow notes: if your latent upscaler is wired unconditionally with its own megapixels widget, it still upscales to that value no matter what pass you asked for. The gate is the thing that actually skips it. Either insert it or bypass the upscale nodes by hand.

render_pass alone is not a promote either. Change it to final without a second Vault Write and the upscaled clip lands on top of the draft. Gate plus two Vault Writes, or don't bother.

Feed it the right latent. The gate doesn't sample; it routes. Point latent at the pre-upscale AV latent and let the final branch do the upscaling - hand it something already upscaled and the final branch just gets slower for no gain.

The base pass always samples at draft size, even when you're making finals. A final is the draft latent put through the upscaler, not a bigger base render. That's deliberate: it's what makes the promoted segment the same video you approved rather than a similar one at higher resolution.