MiniMax H3 Progressive Mixed-Grid Continuum

Continuum-style H3 continuation is how you make long, high-resolution video: every new chunk re-samples over the full target grid while keeping an exact copy of the previous tail. That's brutally expensive - you pay 2K transformer cost for the whole chunk just to extend the story by a little. The tempting cheat is to generate the continuation small and upscale it, but anyone who's tried that with exact-prefix continuation knows the boundary flashes and drift that follow. MiniMax H3 Progressive Mixed-Grid Continuum is the version that actually works: it does the early suffix work on a real lower-resolution grid, then hands off through a learned 3D latent upscale and finishes with a fresh full-grid pass. It's the recommended accelerated Continuum path in this pack, Experimental tag and all.

How the mechanism dodges the traps

The trick that separates this from naive "upscale the small continuation": the authoritative target-grid prefix is never resized. It stays on the target grid for H3 conditioning, bit-exact, so the model always knows exactly what it's continuing from. Only the generated suffix is produced at low resolution - real H3 sampling on a smaller grid, not a sparse subset of hidden rows pretending to be cheap. Then:

1. an exact handoff probe completes the low-grid stage;
2. the learned 3D latent upscaler lifts the clean suffix to target geometry;
3. the exact target prefix is restored bit-exactly;
4. a fresh target-grid refinement stage finishes the job.

If you use VDN, it switches to VDN's external-sequence API 2 (mixed_grid_low_suffix) for the mixed stage and returns to normal execution for the final grid.

The other piece of the puzzle is the suffix_dc_bridge, enabled by default - leave it on. At the handoff the learned upscaler produces a complete target-grid clean sequence whose prefix is about to be discarded. The bridge measures the per-channel DC difference between that learned prefix boundary and the authoritative exact prefix, then applies one constant offset to the first generated suffix token only. The protected prefix stays bit-exact; there's no crossfade and no extra transformer evaluation. In the author's matched decoded-media tests it cut the exact-boundary DC RMS from ~0.208 to ~0.093, matching the upscaler's native boundary - it killed the flash.

The inputs a beginner actually sets

This node patches your model and slots into a Continuum workflow. The defaults are sane - most of the guidance weights are research controls you can leave alone:

• model - your H3 model, trajectory - the shared H3_FLOW_TRAJECTORY handle from a MiniMax H3 Flow Trajectory node (one per execution; don't reuse across runs).
• source_mode / source_scale - how small the private early grid is. source_scale is a linear width/height scale, not an area fraction: 0.84 means roughly 84% of each dimension (~70% of the area). Lower it to save more early work.
• handoff_coordinate (0.35) - where in the schedule you switch grids. guidance_mode - keep it at direction; that's the conservative recommendation, and the fancier modes are explicitly research controls.
• handoff_transfer - locked to learned_3d here, which is the whole point of the node.
• learned_upscaler - an H3_LATENT_UPSCALER provider from the companion MiniMax H3 Latent Upscaler pack. The slot is optional in the schema; the path functionally requires it, so install the sibling pack.

Outputs are model (wire into your Continuum/KSampler stage) and metrics (H3_FLOW_METRICS) for the pack's diagnostic nodes - useful when you're tuning handoff position and want to see the resolved geometry.

Installing it

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/MiniMax-H3-Flow-Aligned-Regenerate.git
git clone https://github.com/xmarre/Comfyui_Minimax_h3_latent_Upscaler.git   # required sibling

Restart ComfyUI, or search both titles in ComfyUI Manager. The core pack has no extra Python deps and pulls no weights - it's all training-free patching. The learned upscaler is where the actual learned model lives; check that pack's README for its checkpoint. You also need H3 itself running locally (33B, ~42.5GB, under a community license whose local-weights path excludes the US/EU/UK/Korea).

Where people get burned

• Forgetting the companion upscaler. Without the provider connected, the learned 3D transfer has nothing to run - this node isn't a drop-in on the generic progressive node's bicubic path.
• Expecting a miracle on VRAM. The low-grid suffix genuinely cuts the early cost, but the final target-grid refinement is full price. This is a speedup on long Continuum runs, not a free lunch.
• VDN version mismatch. The VDN mixed stage needs external-sequence API 2 support in your VDN install; an older build silently misbehaves. Keep the documented patch order (DiffAid → Untwisting RoPE → Spectrum → Progressive → Continuum) when you stack those.

The author validated this on a real RTX Pro 6000 workflow with VDN API 2, Spectrum + SA-PECE, and multiple Continuum boundaries. If you want accelerated exact-prefix continuation without giving up the learned upscale, this is the node in the pack you'll actually reach for.