H3 Context Taper Noise (latent)

H3 - MiniMax's 33B open-weights video model - doesn't have a memory. It has context. When you chain shots in a character-swap continuation workflow, the previous clip's tail gets pinned as context_latent into the next generation. And here's the trap: if that context is too clean, the model copies the last shot's textures and colors almost verbatim, and color residue bleeds past the trim boundary. This node exists to stop that, and it does it before anything reaches the pixel level.

What it is. MiniMaxH3ContextLatentTaperNoise is the context_latent path of Beijinren's ComfyUI-H3-Context-Noise pack. It takes the previous shot's saved AV latent, injects Gaussian noise into the tail latent steps, and hands the result to H3 Motion Context (NikoDemon80's pack). The audio stream rides along untouched, so the sound stays continuous across the join.

It's the node you actually want on a latent-chained graph, because of a quirk worth knowing: once context_latent is wired, H3 Motion Context completely ignores context_frames. Its pixel-level sibling only matters if you're on the frames path. Latent wins.

How it works. The noise follows a validated taper: a flat injection strength alpha across the pinned steps, ramping down to alpha_end at the step that touches the seam. The goal is to make the carried frames color-damaged but motion-readable - the model can't copy the previous appearance wholesale, so it has to re-synthesize from the identity references. That's the line between "seam residue gone" and "ghost edges".

The recipe is 22 frames / 0.45 / 0.10, lifted straight from MacroSony's inject_tail_taper.py (this pack is the in-graph implementation, minus the offline mp4 round-trip):

| steps | flat | ramp | seam | |---|---|---|---| | alpha | 0.45 | 0.333 → 0.217 | 0.100 |

The inputs that matter. Four of them, really:

• context_latent - the previous clip's AV latent, straight from H3 Motion Context Load Latent. The node only accepts H3's video+audio nested pair; a plain single-stream latent is explicitly rejected, so don't wire anything else in.
• tail_frames - an enum, because only 5 / 22 / 39 / 56 convert to whole numbers of latent steps (2 / 7 / 12 / 17). Set it to match H3 Motion Context's context_length.
• alpha and alpha_end - flat strength and seam strength; alpha_end must not exceed alpha. The defaults (0.45 / 0.10) are the validated values, so start there.
• ramp_steps - how many trailing latent steps taper down. 2 is roughly the pixel recipe's 3-frame ramp.

You can leave seed alone (one stream, so the whole sequence is reproducible from it alone) and keep noise_scale on match_latent_std - that scales the Gaussian to the carried window's own standard deviation, so alpha means the same thing whatever the latent's scale.

Outputs. You get the noised context_latent and an alpha_schedule STRING that prints the actual injection sequence. The last entry lands on alpha_end when everything's aligned - that's your quick verification the taper applied. And a hard warning from the node itself: the output is for context_latent only, do not wire it into a VAE decode.

Install. ComfyUI Manager, search "ComfyUI-H3-Context-Noise", or:

cd <ComfyUI>/custom_nodes
git clone https://github.com/Beijinren/ComfyUI-H3-Context-Noise

Restart ComfyUI and the nodes appear under conditioning/minimax. No extra Python dependencies - just ComfyUI's bundled torch and Pillow (the pyproject declares zero). You do need H3 Motion Context installed, plus H3's weights themselves, and remember the Community License's territory carve-out before you get excited.

Gotchas. Three, all from the README. The output is one-shot - never feed the noised latent back in as the next link's context. If you see "the N step tail starts at cycle position … not 0", your clip length and tail_frames are misaligned and H3 will refuse the window; fix one or the other, don't ignore it. And again: this output is context, not a frame - VAE-decoding it is a mistake.