Multi-Pass Refiner

The Multi-Pass Refiner (class CascadeRefiner) has a great idea behind it: refine in stages like render passes - coarse pass first, then refinement, then detail - each with its own seed, all inside one node. It's exactly the kind of thinking you'd expect from an author who's a VFX lighting TD. The problem is that as shipped, the node runs three "stages" that return your latent completely unchanged, then hands you a log saying it did something. The idea is real; the implementation is a stub.

The concept is genuinely good

Multi-pass refinement is a real, well-established ComfyUI pattern. The classic version is the two-pass "hires fix": a cheap low-step pass to establish composition, then a second pass at higher resolution (or with img2img denoise) to add detail. The pack's README frames this as Nemotron-style cascade refinement, and the author splits it into coarse → refine → detail, each stage seeded separately (seed, seed+1, seed+2) so you get diverse passes within a deterministic envelope. Conceptually, that's sound - render artists do exactly this.

What the code actually does

Honest walkthrough from the source: the node takes latent, model, positive, negative, and seed, plus three optional step counts - stage_1_steps (default 5), stage_2_steps (default 10), stage_3_steps (default 5). For each stage it reseeds torch, calls _run_stage… and _run_stage is a placeholder that returns the latent untouched. So the latent output is byte-identical to your input. What you do get is the stage_log string - a JSON with your seed, the three stage names, step counts, total steps, and a claim of "batch_size=1 per stage" - which is accurate as a description of intent, not of anything that happened to pixels.

In other words: don't build a workflow on this expecting refinement. Your "refined" image is your starting image, and the only output that carries information is the log.

Inputs and outputs worth knowing

The input surface is all familiar: model / positive / negative / latent plus seed, and the three stage_N_steps knobs. Note there's no cfg, no sampler_name, and no denoise - so even once a real sampler gets wired in, you'll have very little control per stage. Outputs are latent (into VAE decode) and stage_log (a STRING you can preview or save as provenance).

What to use instead, today

If you want actual coarse-to-detail refinement, build it yourself with what's already in ComfyUI: a KSampler at low steps for the coarse pass, then a second KSampler (img2img) with the same seed, a denoise around 0.5, and a higher resolution - or chain it through a hires-fix / upscale node. It's a handful of nodes you'll find in a hundred shared workflows, and it actually samples. This one's worth revisiting when the author replaces the placeholder with a real sampler loop - the stage structure and per-stage seeding are a sensible skeleton.

Install

Same pack, same one-time install: ComfyUI Manager (search comfyui-deterministic-nodes) or

cd ComfyUI/custom_nodes
git clone https://github.com/joe002/comfyui-deterministic-nodes

then restart ComfyUI. No models, no heavy dependencies - just torch>=2.0, which you already run. Nodes live under JI/Reproducible.

Bottom line

The Multi-Pass Refiner is a well-designed placeholder. The three-stage philosophy is worth stealing; the node itself isn't ready to be in a production workflow. Wire it up if you want to watch the stage log, but keep your KSampler chain.