H3 Relay · Assemble

Assemble is the last node in an H3 Relay graph, and it does two very different jobs. First, the boring one: it concatenates every accepted shot into one final MP4 and publishes it to output/. Second, the interesting one: it carries the pack's signature Run staged · bounded RAM action, which is what makes long multi-shot sequences actually survivable on a consumer GPU. If you've ever queued five H3 continuation shots plus five LTX finishes as one monolithic prompt and watched VRAM explode, you already know why that second job exists.

H3 Relay is built on MiniMax H3's Context Loop ecosystem - the same steering and continuation machinery you'd use in the stock context-loop workflows - but it wraps the whole thing in a staged, resumable pipeline. Assemble sits at the end of that pipeline and understands the whole graph.

What it wires into

You feed it one input: enhanced, the H3_RELAY_ENHANCED stream that comes out of your last H3 Relay · LTX 2× Enhance or H3 Relay · Interpolate node. That single wire carries the whole finished timeline - which is why the pack's docs call the two graph streams sequence (raw H3 continuation state) and enhanced (everything after LTX and interpolation).

Three settings, and honestly only one needs your attention:

• output_stage - auto, interpolated, or ltx. Auto picks interpolated if every shot got interpolated, otherwise LTX. This is also where the README's framing pays off: bypass every interpolation node to assemble LTX video at 24 fps; enable them to assemble the interpolated version. The node refuses to assemble interpolated output until every shot is interpolated, and it needs one consistent frame rate across the timeline.
• filename - defaults to a dated name like h3_relay_movie_2026-08-26_14-30-00. You can throw %date% and time tokens in there.
• audio_bitrate - 256 kbps default, 64–512. This muxes the audio that came along from the H3 shots, so pick something that matches how you'll deliver it.

Outputs are video (a VIDEO socket you can preview or feed straight into a core Save Video node), video_path (the actual file path, handy for scripting), and status (a text report). The node always writes the final movie under ComfyUI's output/ folder.

The staged action - why it's the point

ComfyUI's normal queue runs your whole graph as one prompt, which means every model stays loaded at once. H3 Relay's staged action does the opposite: it reads the visible graph, derives the dependency order, and queues each H3 shot, LTX enhancement, interpolation, and the final assembly as separate jobs. Accepted state is restored from disk manifests, and a release barrier clears the executor cache and unloads models between jobs. A failed stage stops the sequence instead of queueing dependents that can't run.

The trade-off is a small reload cost between stages. The payoff is memory bounded by one active shot instead of the whole movie. For a four-shot 58-second sequence on a 4090, that's the difference between "runs" and "runs out of VRAM at shot three."

If you want the old behavior, the ordinary queue action still works - it treats the graph as one monolithic prompt. The README's recommendation is clear: use staged for long sequences, plain queue if you explicitly want one prompt.

Getting it installed

Install the pack via ComfyUI Manager (search H3 Relay) or:

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/akatz-ai/h3-relay.git

You need FFmpeg on PATH, and the separate model files in MODELS.md (MiniMax H3, LTX 2.5, and a RIFE interpolation checkpoint). ComfyUI 0.32.0+ is required. Heads-up on the licensing, because it's easy to miss: the MiniMax H3 community license geofences out the US, EU, UK, and Korea, and LTX's community license caps you at $10M revenue before you need a paid deal. H3 Relay's own GPL-3.0 code license doesn't change any of that - it doesn't redistribute model weights at all.