Stubelius Director — MiniMax H3 Seed Hunt + Learned 2× Refine
A complete hunt → pick → refine pipeline for MiniMax H3, built on the Stubelius Director node pack — my fork of Muse Collective's excellent Muse Minimax Director V1.2, rebuilt around a trained 2× latent upscaler, a take-preserving audio lock, and a redesigned two-stage architecture that fixes the problems we measured in the original.
Node pack (GitHub): https://github.com/stuubszzz/Stubelius-Director
What it does
Write your script as CUTs on a visual timeline, drop in character reference images / video / audio, and scout multiple seed candidates cheaply. Preview the candidates, press one button on the Refine dashboard, queue again — only your pick gets the expensive high-resolution finish. Seed, steps, split point, sampler, scheduler, and the compiled prompt all travel embedded inside each candidate latent, so the Refine auto-syncs to the exact candidate you picked. Nothing to match by hand.
Why the upscaler was replaced
The original Refine upscales the mid-schedule latent with nearest-exact interpolation — its own docs cap the stable range at ~1.3–1.5× and warn of artifacts beyond. Interpolation invents no detail. Stubelius swaps that step for the trained H3 clean-latent 2× upscaler (Mamad8's model, via Tr1dae's integration): a neural network trained specifically to double H3 video latents, making a clean 2.0× the standard operating point instead of the danger zone.
Why the two-stage pipeline was restructured
We A/B-tested the original V1.2 two-stage against full single-pass hunts and isolated its core flaw: it upscales and continues from a half-baked mid-schedule latent. Consequences we measured: candidate previews that don't match outputs, motion timing drifting off the music, and audio being audibly regenerated — the take you auditioned never survived. Stubelius fixes the sequencing: complete the candidate's own trajectory first, then upscale the clean result, then polish — the upscaler receives what it was trained on, and audio finishes through the full schedule before being frozen.
The three modes
⚡ Fast Hunt (two-stage, fixed) — Two-Stage ON + Latent-Only Scouting ON, first-pass 3–5 steps. Candidates cost only those steps. The Refine's complete then polish (stubelius) strategy then: (1) finishes your pick's remaining schedule at scout resolution — the exact trajectory the preview estimated, audio completing to full quality, (2) learned-2× upscale of the clean take, (3) tail polish with the audio lock. Roughly 3× cheaper per hunt cycle than full hunts. Trade-off: previews are rough estimates — audition composition and motion, not final detail or audio.
🎯 Trustworthy Hunt (complete candidates) — Two-Stage OFF, full steps (e.g. 20). Every candidate is a complete generation: what you see and hear is real. The Refine auto-detects complete candidates and runs the polish path directly: learned 2× + a refine_denoise tail — with the exact audio you auditioned frozen into the final. Use this when the take (especially audio) must be auditioned before committing.
🔧 Stock — the original V1.2 mid-schedule continuation, still selectable (continue mid-schedule (stock)), for comparison or multi-chunk bundles (which always use stock).
The Audio Lock
The original Refine regenerated audio every time — a side effect of continuing from the raw half-denoised audio intermediate. Stubelius' audio_mode: keep candidate audio (locked) freezes the finished audio with a zero noise-mask on the audio stream: pass 2 re-samples video only, and your final's soundtrack is exactly the take that came out of the hunt/completion. Switch to continue schedule (stock) when you want audio re-rendered against the upscaled video.
Refine dashboard controls
Candidate 1–4 — one-button pick from the hunt
sync_from_director(on) — pulls seed/steps/split/sampler/scheduler/prompt from the candidate itself; the widgets below it become fallbackstwo_stage_strategy—complete then polish (stubelius)vs stock continuationrefine_denoise— how much the 2× polish may change the take: 0.3–0.35 maximally faithful, 0.4 default, 0.5+ cleaner but freerpolish_steps— how carefully it polishes: 0 = auto-slice; 12–20 = a dedicated schedule over the same noise range (more convergence, identical faithfulness — recommended for fast/complex motion)audio_mode— the lock, see aboveUpscale method —
learned model (gold, 2x)(factor slider ignored; always exactly 2×); interpolation methods remain as dependency-free fallbacks
Timing tips (avoid off-beat video)
H3 generates frame counts only on a 17k+5 grid. A 13s request silently becomes 13.67s (328 frames) while a 13s reference clip trims down to 12.96s (311) — that mismatch alone drifts your video off the music, in the first pass. Pick durations on the grid (12.9s → exactly 311 frames) and trim reference audio to match. And remember: H3 generates audio guided by your reference — a stylistic reproduction, never a sample-accurate copy. For beat-perfect music videos, mux your original track over the final.
Required custom nodes
PackWhyInstallStubelius-DirectorDirector + Refinegit clone into custom_nodesComfyUI-MiniMaxH3_LatentUpscaler (Tr1dae)Learned 2× integrationManagerComfyUI-H3-Latent-Upscaler-Mamad8Upscaler architecture + checkpoint (auto-downloads)ManagerKJNodesGet/Set wiring + previewsManagerVideoHelperSuiteVideo outputManagerComfyUI-LayerStylePurgeVRAM (optional)Manager
Both upscaler packs are required (Tr1dae depends on Mamad8 as a sibling). Needs recent ComfyUI core with native H3 support and pip install av. Models: H3 ref2va checkpoint (+ fl2va for First/Last Frame mode), matching CLIP, video VAE, audio VAE — from the official MiniMax H3 repo under its license.
Update: 24.8.2026:
Major fix: if the Refine silently did nothing (queue finishes in 0.01s, no output) — that was un-run candidates blocking the node when fewer than 4 candidates were hunted. Candidate inputs are now lazy: only your picked candidate is evaluated, so all 4 wires can stay connected with any number of candidates ticked. Also fixed a crash in complete-then-polish, polish_steps validation errors on older saves (now self-healing, default 16), and speaker-chip / drag-highlight feedback.
Quick start
Load the included workflow. Drop character refs, write your CUTs, set an on-grid duration (12.9s).
Pick your mode: fast hunt (Two-Stage ✓ + Latent-Only ✓, first-pass 4, steps 20) or trustworthy hunt (Two-Stage ✗, steps 20).
Queue → review candidates → press
1–4on the ⭐ Stubelius Refine → queue again.Console confirms the pipeline:
complete-then-polish: finished remaining N steps at 1x→[polish] dedicated schedule→effective 2.000x/2.000x→audio lock: candidate audio frozen.
Ships with a full black & neon-gold graph theme — every node, wire, and dashboard.
Credits
Muse Collective — the original Muse Minimax Director V1.2 (MIT): the timeline UI, chunking, seed hunt, and continuity engineering are their work.
Mamad8 — trained the H3 clean-latent 2× upscaler · Tr1dae — the ComfyUI integration this fork calls.
Powered by MiniMax H3 — open-weights model, used under the MiniMax Community License.
Description
What it does
Write your script as CUTs on a visual timeline, drop in character reference images / video / audio, and scout up to 4 seed candidates at low resolution for the price of a few Stage-1 steps each. Preview all four, press one button on the Refine dashboard, queue again — only your pick gets the expensive high-resolution second pass, finished with a learned 2× latent upscaler and decoded with audio intact.
Why the second pass was replaced
The original Refine continues the candidate's sigma schedule after upscaling the latent with nearest-exact interpolation — and its own docs cap the stable range at ~1.3–1.5×, warning of line/texture artifacts beyond that. Interpolation invents no detail; it stretches what's there and lets the remaining denoise steps clean up.
Stubelius swaps that single step for the trained H3 clean-latent upscaler (Mamad8's model, via Tr1dae's integration): a neural network trained specifically to 2× H3's video latents. Same schedule-continuation architecture as the original — nothing else about the pipeline changed — but the upscale itself now adds plausible detail instead of interpolating, and a clean 2.0× becomes the stable operating point instead of the danger zone. Sharper faces, cleaner line work, fewer texture artifacts at higher output resolution.
The fork also adds auto-sync: the Director embeds each candidate's exact Stage-1 settings (seed, steps, split point, sampler, scheduler, compiled prompt) inside the candidate latent itself, and the Refine node reads them automatically. No more manually matching seed/steps between the two nodes — the #1 way to silently ruin a refine pass.