MiniMax H3 Director in ComfyUI: seed hunt, two-stage sampling and the Stubelius refine

Stubelius Director is my fork of the Muse Collective MiniMax H3 Director V1.2 for ComfyUI. It scouts up to 4 seeds at low resolution (I use 0.25 megapixels, 672×384), then finishes only the seed you pick with a learned 2× latent upscale and a polish pass, 1344×768 on my settings.

30 September 2026: the newer Stubelius Ultimate H3 workflow replaces this for new installs (repo on GitHub). It renders 1 to 4 full seeds with sound and finishes only the winner. It registers its own node names, so the two install side by side and you do not have to remove anything. The rest of this post describes the Director V1.2 pack, which is still public.

The timeline, the chunking, Seed Hunt, two-stage sampling and the Refine node all come from MiniMaxH3-Director-V1.2 by Muse Collective (MIT licensed). That repo has since moved on to Director V1.4, which is worth a look in its own right. My fork adds a learned 2× latent upscale as the default upscale method, and it changes what Refine does with the seed you pick: finish the take first, then upscale and polish it with the audio locked.

What does the MiniMax H3 Director do?

The Director lets you scout cheap, pick the winner, then spend the real compute on one candidate. MiniMax H3 tops out at roughly 15 seconds per generation call, and a plain render only shows whether a seed was any good after you have paid for the whole render.

A seed hunt is a way to choose a take before you finish it: the same prompt renders on several seeds, you compare the candidates, and only the one you pick is finished. In this pack the candidates are low-resolution scouts, and the Refine node does the finish.

You write one script broken into CUTs on a timeline and drop in up to 9 character images, a location image, reference video or audio. The node compiles the per-chunk prompts and the <Picture N> reference numbering for you.

• Seed Hunt. Candidate 1 always runs. Candidates 2, 3 and 4 each have their own toggle, so you only pay for the scouts you want.
• Two-stage sampling. The first few steps run at a lower resolution, the latent is upscaled directly (no VAE round-trip), and the remaining steps finish at the higher resolution on the same noise schedule.
• Latent-only scouting. Each Seed Hunt pass stops after stage one. Only the candidate you pick pays for stage two.
• Refine node. Continues the chosen candidate's latent at higher resolution. It is a latent continuation, not a pixel-space re-sample.
• VAE re-encode carry. On multi-chunk timelines the previous chunk's real final frames are re-encoded and frozen as the next chunk's opening. Muse Collective's README reports the frame-to-frame grayscale difference at the chunk boundary as about 44 to 48 without it, and 3.21 (single-pass) or 4.61 (two-stage) with it, on their renders.

What does the Stubelius fork add?

It makes a learned 2× latent upscaler the default upscale method, and it changes how Refine finishes the seed you pick: the take is completed first, then upscaled and polished with the audio locked.

The stock V1.2 behaviour is still selectable for both the strategy and the audio. I added the lock after one dance clip of about 13 seconds with a character swap, where continuing the audio from a part-finished latent gave a final with different music than the scout I had picked. One clip, one machine.

The pack also paints its own nodes black and gold, with an on/off switch in the ComfyUI settings. Node class names are unchanged, so existing V1.2 workflows and saved timelines keep working.

How do I run a seed hunt and refine the winner?

1. Set the budget. 16:9 at 0.25 megapixels resolves to 672×384. The learned 2× upscale turns that into 1344×768, which I loosely call 720p. This is the setup from my FastH3 speed test.
2. Scout. Turn on two-stage sampling and latent-only scouting, then enable the candidates you want. With the 8-step Turbo LoRA I use euler / beta and put 3 of 8 steps, or 4 of 10, in the first pass. With the converted FastH3 LoRA it is 3 of 6.
3. Judge motion, not sound. A scout that stopped at 3 of 8 steps has muffled audio. For dialogue scenes I go to 20 total steps with 8 to 10 in the first pass, enough to hear whether the right words are being said. The fork raises the first-pass cap from 6 to 50 for this.
4. Pick. Wire the candidate_N_latent outputs and ref_images_used into Refine and click the candidate button. Refine does not run while the candidate is 0.
5. Refine. Keep the upscale method, strategy and audio defaults from the table. With sync off, seed, total steps and first-pass steps must match the Director by hand, or the schedule resumes at the wrong point.
6. Polish. I tested 1 to 16 polish steps. 4, 6 or 8 covers most clips and 8 is where I settle. For complex motion, my suggestion in the FastH3 video is to scout with the speed LoRA, feed Refine the model without it (Refine has its own model input) and give the polish 6 to 16 steps. The step counts still have to agree: for Refine to finish 17 of 20 steps, the Director has to be set to 20 total steps with 3 in the first pass. That is a suggestion, not a measured comparison.

The other way to use it: leave two-stage sampling off. Every candidate is then a full render at scout resolution, and Refine only upscales and polishes the one you pick.

Settings from my own renders on an RTX 5090 (32 GB), 96 GB RAM, Windows 11, as shown in the videos published 2026-08-25 and 2026-09-02. One machine, no render times measured for this post. The boundary figures are Muse Collective's.

MiniMax H3 Director requirements

• A recent ComfyUI with the stock MiniMax H3 nodes, plus pip install av.
• MiniMax H3 weights: the reference-to-video checkpoint on the model input and the first/last-frame checkpoint on model_fl2va, with the text encoder, video VAE and audio VAE. The example workflow is wired for the int8 files minimax_h3_ref2va_pruned_int8_convrot.safetensors and minimax_h3_fl2va_pruned_int8_convrot.safetensors.
• For the learned 2× method, both ComfyUI-MiniMaxH3_LatentUpscaler by Tr1dae and ComfyUI-H3-Latent-Upscaler-Mamad8.
• For VAE re-encode carry, ComfyUI-H3-Motion-Context-MultiRef. Leave the toggle off if you do not want the dependency.

Installing Stubelius Director

1. Remove the original Muse Director V1.2 pack and any standalone muse-minimax-refine install if you have them. The fork registers the same node class names, so it goes in instead of them.
2. Clone the repo into custom_nodes and install av in the Python environment ComfyUI runs in. There is no release or tag, the repo itself is the download.
3. Restart ComfyUI, load example_workflows/stubelius_example.json from the pack folder, and reselect your own model files in every loader, including the text encoder (the official file is qwen3vl_32b_minimax_h3_int8_convrot.safetensors) and the two LoRA loaders. The saved filenames are from my machine. The example also uses helper nodes from KJNodes, VideoHelperSuite, LayerStyle and iTools, plus a few bypassed attention and low-VRAM patches. ComfyUI Manager flags whichever are missing.

cd ComfyUI/custom_nodes
git clone https://github.com/stuubszzz/Stubelius-Director
pip install av

On Windows portable, replace the last line with this, run from the ComfyUI_windows_portable folder:

python_embeded\python.exe -m pip install av

Sources and files

• Stubelius Director on GitHub: the fork and its example workflow.
• MiniMaxH3-Director-V1.2 by Muse Collective: the upstream project.
• MiniMax H3 model card on Hugging Face.
• The learned latent upscaler: ComfyUI-MiniMaxH3_LatentUpscaler and ComfyUI-H3-Latent-Upscaler-Mamad8. Chunk carry: ComfyUI-H3-Motion-Context-MultiRef.
• The Director walkthrough video (17:48, published 25 August 2026).
• On this site: Stubelius Ultimate H3, the FastH3 vs Turbo LoRA speed test and the FastH3 LoRA converter.

Common questions