Y7 Krea 2 Three-Stage Sampler

Krea 2's two checkpoints split the job cleanly. Raw is CFG-guided and undistilled - 52 steps, cfg around 3.5, and the only one of the pair that will actually listen to a negative prompt. Turbo is distilled down to 8 steps at cfg 1, which means the negative isn't doing anything at all. Guidance-distilled models don't have a negative branch to steer with; that's the trade you made for the speed.

Which creates a specific annoyance. The useful, varied part of a generation happens at the noisy end, where you want Raw and your negative prompt. The finishing happens at the clean end, where Turbo's refinement is cheap and good - and where you'd also like a negative again, because that's when you notice you didn't want freckles, or a purple cast. Y7 Krea 2 Three-Stage Sampler is the Two-Stage Sampler with a third pass bolted on the end that reuses all of stage 1's settings: same model, steps, cfg, sampler, scheduler.

What the extra stage actually is

Stage 1 runs from the top of its schedule to handoff_percent. Stage 2 runs from there to stage3_handoff_percent. Stage 3 then picks up and finishes, using stage 1's model and stage 1's settings.

The mechanism is neater than "run it again at the end". stage3_handoff_percent is read off stage 1's own schedule - the same 52-step curve - so stage 3 isn't a fresh sampler start, it's literally the tail of that curve, cut at a second index. Stage 2 is the sandwich filling: its schedule is trimmed at both ends to the steps nearest the two boundary sigmas, with those exact sigmas forced in as its first and last entries. And stage 3 runs with fresh noise disabled, because by then the noise has already been added at the handoff and there's nothing to re-roll.

One asymmetry worth knowing: the resize from final_width / final_height happens at the first handoff, once. Stage 2 and stage 3 continue at the new size.

Inputs that differ from the two-stage version

Everything from the Two-Stage Sampler is here - stage1_model, stage2_model, positive, negative, latent_image, seed, handoff_percent, the two stages' steps/cfg/sampler/scheduler, final_width / final_height, upscale_method, and the optional stage2_positive_optional / stage2_negative_optional. The additions:

• stage3_handoff_percent (default 83.33, must be ≥ handoff_percent). The point where stage 2 stops and stage 3 takes over. At the defaults, stage 1 does the first 12% of the curve, stage 2 the middle ~71%, and stage 3 the last ~17%.
• Stages 1 and 3 always use positive / negative. The stage2_*_optional inputs only affect the middle stage - which is fine, because a cfg-1 middle stage isn't reading its negative anyway.

Output is a single latent. Decode it.

Two shortcuts are baked in and both are useful: stage3_handoff_percent at 100 gives you exactly the Two-Stage Sampler, and setting it equal to handoff_percent skips stage 2 entirely - stage 1 settings run either side of one handoff, which is a completely different look (raw at both ends, nothing fast in between) and worth one test run just to hear the difference.

Should you use this one?

Honestly, start with the Two-Stage Sampler. This node is the fiddliest thing in the pack, the author's own README opens with "probably only useful to me", and three stages is three things to get wrong. Reach for it when you have a specific complaint the two-stage version can't answer: your images come out technically finished but flat and slightly plasticky because the whole clean half was cfg-1, or you want a negative prompt still steering the fine detail pass, or you specifically want a Raw-class model doing the last steps instead of a distilled one. Those are real differences, not imagined ones.

The cost is what you'd expect. Stage 3 runs at stage 1's cfg, which at cfg 4 means two model passes per step. The last 17% of the schedule is where the finest detail is made, so it's the most expensive 17% you could choose - expect the run to take noticeably longer than two-stage at the same step counts.

Install

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/yushan777/ComfyUI-Y7Nodes
pip install -r ComfyUI-Y7Nodes/requirements.txt

Or ComfyUI Manager → search Y7 → Install → restart. The pack's color-matcher and opencv-python-headless dependencies are for the colour-matching nodes, not this one. It's built on ComfyUI's newer V3 node API, so it won't appear on a ComfyUI old enough to predate comfy_api.latest.

Where people get burned

The handoffs collapse into each other. If both percentages round to the same sigma, the node raises "stage3_handoff_percent must produce a later denoising sigma than handoff_percent". Move the two values further apart - they have to land on genuinely different steps of stage 1's curve.

Shift mismatch again. The same trap as the two-stage node: Raw and Turbo don't load with compatible sampling settings, so the boundary sigma can land outside stage 2's schedule entirely. Put Y7 Krea 2 Raw Sampling Shift on the stage-1 chain, and give stage 2 something compatible.

handoff_percent 0 is a different animal. With stage 1 skipped, stage 2 runs from the very top of its own schedule up to the stage-3 boundary and stage 3 finishes - Turbo doing the noisy part, Raw cleaning up. That's the mirror image of what this node is for, and it's a real experiment (the Turbo LoRA path at 1.0 does something similar by accident), just don't expect the bookending behaviour you set the node up for. If you want to isolate what the third stage contributes, set stage3_handoff_percent to 100 - identical to the two-stage node - then to 83, and compare the same seed.