Neo H3 Add Guides (Multiframe)

Anchoring keyframes in MiniMax H3 is normally a per-frame affair: one guide node per pose, stacked in a chain. NeoH3AddGuides is the batch version - eight image/frame pairs in a single node, all appended to the same conditioning. If you've been poking around inside ComfyUI-Neo-Nodes' H3 Video Director and wondering what this thing in the menu is for, that's your answer: the director's chunked runs wire it up invisibly to pin each storyboard keyframe at its cumulative start frame, and you only touch it by hand if you're building the graph yourself.

Worth saying up front, since this is H3: MiniMax's open weights ship under a Community License whose Applicable Territory excludes the US, EU, UK and South Korea. Outside those regions you're fine. Inside them, you're running these weights without a licence - the hosted Hailuo API is the licensed path there. H3 itself is genuinely good (33B omni-modal, native stereo audio generated jointly with the picture rather than bolted on) and ComfyUI had day-zero support for it, but that geofence is real, not a footnote.

How it works

The node walks guide_0 through guide_7, takes the first frame of whatever batch you hand it, and VAE-encodes it. If you connect the optional latent, it first resizes that frame to the target AV latent's canvas - that latent is [B, 24, T, H/16, W/16], so multiplying the spatial dims by 16 gives you the pixel canvas. That's how a square storyboard panel doesn't break a 1280×720 recipe.

Each frame lands in the conditioning as a {"resolved_frame_index": n, "latent": ...} entry appended to minimax_keyframes, sitting alongside any minimax_refs already there. The node also wraps the MODEL output in a continuity wrapper so anchors and references coexist on one timeline. That wrapper is the trick you can't reproduce by hand-wiring two other nodes: core keeps refs and drops keyframes when both are present, and the wrapper merges them back before the model is called.

The inputs that actually matter

• model, conditioning, vae - required, and they're the standard H3 trio. Feed model and conditioning from your H3 conditioning node (MiniMaxH3ImageToVideo / MiniMaxH3ReferenceToVideo family) and the video VAE from its loader. The audio VAE does not belong here.
• guide_N_image / guide_N_frame - the pairs. One IMAGE plus the integer frame index it should be pinned to (default 0, i.e. the shot's first frame). Negative values get clamped to 0, and only frame 0 of a batch is used, so a 5-frame batch gives you one anchor, not five.
• latent - optional, and it's the mode switch. Connect it and guides are resized to the target canvas. Leave it off and they encode at their original resolution - legacy behaviour, kept so old workflows still run, and the usual source of a patchify error when your guide image isn't canvas-sized.

Outputs are model and conditioning. Wire both into the sampler, replacing the raw model and the raw positive conditioning. Keep the original conditioning and you've built a very expensive no-op.

You only get eight pairs on the canvas - the pack's director passes more through at runtime. Eight is the ceiling for hand-built graphs.

Install

Through ComfyUI Manager, search Neo Nodes (the pack is published to the ComfyUI Registry) and hit install. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/neoneo-ai/ComfyUI-Neo-Nodes.git

Restart ComfyUI. The pack's requirements.txt pulls openai, Pillow, PyYAML and pypinyin - note the README lists requests and omits openai, so trust the file on disk. llama_cpp_python is optional and only needed for the pack's local-GGUF prompt tools, which have nothing to do with this node.

The real weight is H3 itself: tens of gigabytes of diffusion weights plus a minimax-type text encoder, a video VAE, and a separate audio VAE. This node is the cheap part.

Where people get burned

The patchify error is almost always latent left unconnected with a guide image that isn't the recipe's canvas size. Connect it - in a hand-built graph that's the intended path anyway; the legacy mode exists for old workflows, not new ones.

Second: anchors pinned to frame numbers that don't exist in the actual render. The frame index is absolute, so in a chunked run you're responsible for knowing where each chunk starts. Nothing validates it for you.

Third: a guide with no image connected is skipped silently, which is fine, but if no pair is connected at all the node returns model and conditioning untouched. You get a successful run and zero anchoring, no warning.