ComfyUI 5-Phase SDXL + Refiner Workflow

Ultimate Multi-Stage Image Generation with SDXL Refiner Integration

Author: DarthRidonkulous
Version: 1.0
Release Date: December 2025
Status: Production Ready

🌟 Overview

The 5-Phase SDXL + Refiner workflow is a layered image construction system that builds images through five sequential transformation phases, each serving a specific function in the creative pipeline. Rather than simple refinement passes, each phase contributes distinct elements - form, correction, style evolution, and final polish - allowing you to combine model strengths and LoRA effects in ways impossible with single-pass generation.

You don't have to use all 5 phases. The workflow includes complete bypass control - disable any phase to match your needs. Some images only need 2 phases to achieve the desired style and quality; others benefit from the full pipeline. Start with fewer phases and add more only if needed.

What Makes This Workflow Special

Five Functional Phases - Each phase serves a specific purpose: foundation, correction, style evolution, final layering, and refiner polish
Use Only What You Need - Bypass any phase; some images need 2 phases, others need all 5
Sequential Model Layering - Use different checkpoints per phase as "macro LoRAs" for broad stylistic control
Controlled LoRA Distribution - Instead of fighting 12+ LoRAs in one pass, distribute 2-3 LoRAs across phases for precise control
Per-Phase LoRA Control - Manage trigger words and LoRA effects independently across all phases
Strategic Detailers - Each phase's detailer targets different elements based on what needs fixing at that stage
True Refiner Support - Phase 5 uses actual SDXL Refiner models for final coherence
Complete Bypass Control - Disable any phase or feature group for testing or production

🔑 Key Features

Phase 5 SDXL Refiner Integration

Unlike standard multi-phase workflows that just re-run base models, Phase 5 is specifically designed for SDXL Refiner models:

Uses KSampler (Advanced) with proper refiner step configuration
Accepts Phase 4 output and applies final refinement pass
Separate checkpoint loader for dedicated refiner model (e.g., sd_xl_refiner_1.0.safetensors)
Configurable "start at step" control for refiner transition point
Produces the final polished output

Multi-Phase Architecture

Phase 1: Foundation (The Sketch)

Establishes shape, form, poses, basic lighting
Use minimal LoRAs - just enough to get your base structure
Choose a model strong in composition (anime models excel at dynamic poses)
Default denoise = 0.8

Phase 2: Correction & Detail

May fix Phase 1 issues: hands, disconnected elements, anatomical problems
Adds detail and enhances lighting
Higher denoise (0.4 to 0.6) gives this phase authority to make corrections
Select LoRAs based on what Phase 1 needs
Independent LoRA triggers

Phase 3: Style Evolution

Shifts aesthetic direction while preserving established structure
Can introduce different model aesthetics
Lower denoise (0.25) preserves the corrected foundation
Independent LoRA triggers

Phase 4: Final Base Layer

Last opportunity for style and detail influence before refiner
Subtle adjustments building on all previous phases
Default denoise = 0.25
Independent LoRA triggers

Phase 5: SDXL Refiner

Final coherence and polish
Face and hair often need attention here (common casualties of multi-phase transformation)
Dedicated refiner model for cleanup
Separate upscale and save options

LoRA Management System

The core philosophy: Generating a good image with 12+ LoRAs active simultaneously is difficult. Generating a great image with 2-3 carefully chosen LoRAs is much easier. This workflow lets you distribute your LoRAs across phases for precise control.

Each phase has its own complete LoRA control:

LoRA Loader (LoraManager) - Visual LoRA selection per phase
TriggerWord Toggle - Enable/disable individual trigger words
Carryover TriggerWord Toggle - Control trigger inheritance
Join String Multi - Combine selected triggers
Wildcard Prompt from String - Inject triggers into prompts

This means you can:

Use minimal LoRAs in Phase 1 to establish clean form
Add corrective/detail LoRAs in Phase 2 based on what Phase 1 produced
Layer style LoRAs in Phases 3-4 for progressive aesthetic shifts
Prevent trigger cross-contamination between phases

Comprehensive Save System

Every processing stage can save independently:

Phase 1-4: Image Save, Upscale Save, Detailer Save
Phase 5 Refiner: Refiner Save with Metadata, Refiner Upscale Save
All saves include full metadata embedding (A1111 format for CivitAI)

Memory Management

Strategic VRAM optimization for stable operation:

Model Unload between major phases
Cache clearing nodes
FaceDetailer bypass capability per phase
Upscale bypass for VRAM-constrained systems

📦 Installation

Required Custom Nodes

Install these via ComfyUI Manager or manually:

ComfyUI-Impact-Pack

ComfyUI-LoRA-Manager

ComfyUI-Easy-Use

rgthree's ComfyUI Nodes

pysssss Custom Scripts

WAS Node Suite

ComfyUI-KJNodes

Custom Nodes (Included with Workflow)

This workflow requires 4 custom Python nodes. Save these files to your ComfyUI/custom_nodes/ folder:

1. SDXL Image Settings Controller (4 Phase)

File: sdxl_image_settings_controller_4phase.py

Centralized control for all workflow settings:

Resolution presets (organized by aspect ratio)
Seed control (fixed/increment/decrement/randomize)
Per-phase KSampler settings (steps, CFG, sampler, scheduler, denoise)
Batch size control
Empty latent generation

2. Multi-Phase Prompt Manager (4 Phase) V2

File: multi_phase_prompt_manager_4phase_v2.py

Advanced prompt management with:

Phase 1 as base prompt for inheritance
Per-phase mode control: Use Base, Use Previous, Unique, Append to Base, Append to Previous
Positive AND negative prompt management per phase
LoRA trigger injection (at beginning of prompt)
Automatic duplicate trigger removal
Metadata output for debugging

3. Integer Input Switch

File: integer_input_switch.py

Simple utility for routing integer values:

4-input selector
Used for step routing to refiner

4. VAE Selector

File: vae_selector.py

This node gives you the ability to switch from the baked VAE in the Checkpoint model to an external VAE easily. You can change this for every model in phases 1 - 4.

Installation Steps

Download the workflow JSON file
Install custom node packs via ComfyUI Manager:
- Open ComfyUI Manager
- Install Missing Custom Nodes
- Restart ComfyUI
Install included Python nodes:

   Copy all .py files to: ComfyUI/custom_nodes/

Restart ComfyUI completely (not just browser refresh)
Load the workflow:
- Drag JSON onto ComfyUI canvas, or
- Use Load button and select the JSON file
Verify all nodes loaded (no red "missing node" errors)

🚀 Quick Start Guide

Step 1: Configure Global Settings

Find the SDXL Image Settings Controller (4 Phase) node in the CENTER of the workflow. The workflow is arranged so that the most adjusted settings and the output is in the center of the workflow for easy/quick adjustments as you are tweaking settings to get the desired output. All of the nodes are grouped so that you are able to move groups around without affecting functionality if you don't like the way I have everything arranged.

Settings:

subdirectory Your project folder name. This will change the subdirectory of all the save nodes in the workflow to ComfrUI/<Subdirectory>

resolution_preset

seed You can input your starting seed. This changes the seed in all of the KSamplers in phases 1 - 4.

seed_control fixed, randomize, decrement, increment

control_after_generate Seed control: fixed, randomize, decrement, increment

batch_size Uses the same prompt and changes seed according to your control after generate settings and does not unload or reload models for the duration of the batch.

Step 2: Choose Your Phases and Configure Settings

First, decide how many phases you need:

You don't have to use all 5 phases. Some images achieve the desired style and quality with just 1-2 phases; others benefit from the full pipeline. Start with fewer phases and add more only if you're not getting the results you want.

Use the Fast Bypass node to enable/disable Phase 2, Phase 3, Phase 4, and Phase 5 Refiner
Disable Model Loader Groups for Phases you are bypassing. If you don't, they will load into VRAM when you start the generation.
Set the Phase Steps to Refiner selector to match the last enabled phase (this routes the correct step count to the refiner if using Phase 5)

Phase Settings in the SDXL Image Settings Controller:

Start with the default settings, then adjust to get desired results. Samplers and schedulers can behave unexpectedly in Phase 3 and Phase 4 - you may need to try different combinations that aren't the "recommended" ones for your model.

LCM sampler with karras scheduler works reliably (~90%) in any phase with any model and is a good fallback if you're getting strange results.

Step 3: Load Your Models

Configure checkpoint loaders based on their function in the pipeline:

Key concept: Each model acts like a broad-effect "macro LoRA" - you're layering model strengths sequentially to achieve effects impossible in single-pass generation. An anime model in Phase 1 for pose → semi-realistic in Phase 2→ realistic model in Phase 3-4 for detail.

Step 4: Configure Phase 5 Refiner

Find the Phase 5 SDXL Refiner group:

Choose you refiner model for final detail and refinement. You can use SDXL refiner models that are made for that specific purpose or you can use any other checkpoint model for the final touches. Often, using the same checkpoint as you used in Phase 4 will give you the desired results, but sometimes using a semi-real model for refinement after using realistic model in Phase 4 can sharpen up the image in a more desired way.

The Steps field is automatically populated from the Phase Steps to Refiner node, which pulls the step count from whichever phase you selected in the phase selector.

Refiner Start at Step: This should be set to the Steps value minus 5 to 10. For example, if your selected phase has 25 steps, set Start at Step to 15-20. Lower values = more refiner influence, higher values = less refiner influence.

Step 5: Set Your Prompts

Find the Multi-Phase Prompt Manager (4 Phase) V2 node:

Enter your main prompt in phase_1_positive_prompt
Enter negative prompt in phase_1_negative_prompt
Configure Phase 2-4 modes (default: "Append to Base" works well)
Add phase-specific custom text or embeddings in the appropriate prompt nodes for each phase.

Step 6: Configure LoRAs

For each phase you want LoRAs:

Open the LoRA Loader (LoraManager) for that phase
Select your LoRAs
Use TriggerWord Toggle to enable/disable specific triggers
Check ShowText nodes to verify trigger combinations

Step 7: Enable/Disable Features

Find the Fast Bypass node (rgthree Fast Groups Bypasser) to enable or disable:

Phases and Model Loaders
Detailers (per phase)
Image Save, Detailer Save and Upscale Saves (per Phase)

Remember: You don't need all phases for every image. Disable phases you don't need - this speeds up generation and sometimes fewer phases produce better results for your specific style/model combination.

Step 8: Run the Workflow

Click Queue Prompt
Watch progress through each phase
Check ShowText nodes for debugging
Final outputs appear in your configured subdirectory

💡 Tips for Best Results

Model Selection Strategy

Start simple: Enable Phase 1 first, get the basic result you want, then enable Phase 2 and mess with settings and LoRAs to get the results you want, then Phase 3, then Phase 4, Then refine. You can save only the Detailer Image or Upscale image or no images and just rely on the image previews in the center-left of the workflow.

Functional Approach (when using multiple phases):

Phase 1: Model with strong composition/poses and loras that define basic shape and lighting.
Phase 2: Model with good corrective ability and detail. Start working on lighting here.
Phases 3-4: Models that move toward your target aesthetic
Phase 5: SDXL Refiner for final coherence

Example - Anime Pose to Realistic Result:

Phase 1: Anime model (great action poses)
Phase 2-3: Transition models
Phase 4: Realistic model
Phase 5: Refiner for cleanup
Result: Dynamic pose you couldn't get from realistic model alone, with realistic final style

Same Model Throughout:

Use when you want the model's native aesthetic
Still benefits from the multi-phase LoRA distribution
Each phase still serves its function (foundation → correction → detail → polish)
Remember that the workflows in ComfyUI are embedded in the images and videos. If you want to see how I have created one of my images, you can download the image and drag it onto the canvas of ComfyUI and it will populate the workflow with my settings and prompts.

Denoise Considerations

The workflow defaults use decreasing denoise values across phases (0.8 → 0.4 → 0.25 → 0.25):

Phase 1 (0.8): High denoise for initial generation from the latent
Phase 2 (0.4): Higher denoise gives this phase authority to fix issues from Phase 1
Phases 3-4 (0.25): Lower denoise preserves the corrected foundation while allowing style evolution

Phase 2's higher denoise is intentional - it needs room to fix hands, reconnect elements, and make corrections when using the same checkpoint models for Phase 1 and 2. It also will enable a large change in styles if you are using different models. Sometimes you may want .45 to .55 for this.

LoRA Distribution Strategy

The key insight: Don't load all LoRAs in Phase 1. Distribute them based on phase function:

Phase 1: Minimal LoRAs - just what you need for basic form/pose
Phase 2: Add LoRAs for correction and detail, chosen based on what Phase 1 produced
Phases 3-4: Layer in style LoRAs for aesthetic direction
Keep each phase to 2-3 active LoRAs for controllable results

This gives you the effect of 12+ LoRAs in the final image, but with the control of only managing a few at a time.

Phase 5 Refiner Settings

The refiner steps are automatically pulled from your selected phase via the Phase Steps to Refiner node. Set Start at Step to your step count minus 5-10 (e.g., if 25 steps, use 15-20 for start). The refiner model is loaded via the Phase 5 Checkpoint Loader - use an SDXL Refiner model (e.g., sd_xl_refiner_1.0.safetensors) or a compatible checkpoint.

🔧 Troubleshooting

Missing Nodes Error

Symptom: Red nodes after loading workflow

Solution:

Install missing node packs via ComfyUI Manager
Verify all 4 custom Python files are in custom_nodes/ folder
Restart ComfyUI completely (not just browser refresh)
Check console for Python import errors

Out of VRAM

Symptom: Workflow crashes mid-generation

Solution:

Reduce batch_size to 1
Disable FaceDetailer phases (bypass the groups)
Disable upscale saves
Use smaller resolution preset
Enable only 2-3 phases instead of all 5
Ensure Model Unload nodes are active (not bypassed)

Phase 5 Refiner Not Working

Symptom: Refiner phase produces unexpected results

Solution:

Verify Phase 5 Checkpoint is an actual SDXL Refiner model
Check "Refiner Start at Step" value
Verify image routing from Phase 4 to Phase 5
Ensure KSampler (Advanced) is configured correctly

Images Not Saving

Symptom: Workflow completes but no outputs

Solution:

Check subdirectory setting in Settings Controller
Verify Save Image nodes aren't bypassed
Check folder permissions in ComfyUI output directory
Review console for file write errors

Prompt Issues

Symptom: Output doesn't match prompt expectations

Solution:

Check ShowText nodes to see actual prompts per phase
Verify Phase 2-4 modes are set correctly
Review TriggerWord Toggle settings
Check for duplicate or conflicting triggers

📋 System Requirements

Minimum Requirements

GPU: NVIDIA with 10GB+ VRAM (RTX 3080 or equivalent)
RAM: 16GB+ system memory
Storage: SSD recommended
ComfyUI: Latest version

Recommended Requirements

GPU: NVIDIA with 12GB+ VRAM (RTX 4080/4090)
RAM: 32GB+ system memory
Storage: NVMe SSD
ComfyUI Manager: For easy custom node installation

Optimal Requirements

GPU: 24GB VRAM (RTX 4090)
RAM: 64GB+ system memory
Features: Can run all phases with FaceDetailer and upscaling enabled

🔄 Version Information

Current Version: 1.0
Release Date: December 2025
Compatibility: ComfyUI 2025+ builds

Features in V1.0

5-phase architecture with dedicated SDXL Refiner integration
Per-phase model loading (5 separate checkpoints)
Complete LoRA management per phase
FaceDetailer integration for all phases
Comprehensive save system with metadata
Strategic memory management
Full bypass control

📄 License & Credits

Workflow Design: DarthRidonkulous
Custom Nodes: Developed in collaboration with Claude (Anthropic)
Testing: Production testing with SDXL/Pony/Illustrious/NoobAI model families

Usage Terms

Free to use and modify for personal and commercial projects
Credit appreciated but not required
Share your results on CivitAI!
Custom nodes may be used in other workflows

Support the Creator

If you find this workflow valuable:

⭐ Leave a review on CivitAI
🖼️ Share your generated images
💬 Help other users in comments
☕ Consider supporting future development

📞 Support & Community

Questions? Check troubleshooting section first, then:

Review ShowText nodes for debugging info
Search comments for similar issues
Post detailed question with workflow screenshots

Found a bug? Report with:

Workflow version number
ComfyUI version
Error messages from console
Steps to reproduce

🎉 Thank you for using the 5-Phase SDXL + Refiner workflow!

This workflow enables layered image construction - combining model strengths and distributing LoRA effects across phases to achieve results impossible with single-pass generation.

Happy generating! 🚀

Workflow Version: 1.0 | Documentation Version: 1.0 | Last Updated: December 2025

Files with SHA256: f6716c0d8a2a5309c7729edf5a7d807ef49a1b72e8e54b84e5b0987a6bc508fa