ComfyUI AI Influencer Workflow: The Full Persona Graph

A ComfyUI AI influencer workflow is one graph with four blocks in a fixed order: a base block that loads the model family, an identity stack that makes the render your persona, a face detailer that repairs small faces, and an upscale block that finishes the image. When you switch between SDXL, Z-Image and FLUX.2 klein, only the base block is rebuilt; the other three keep their shape and copy the base block's sampler settings.

Node names, files and default values checked October 2026 against ComfyUI's official workflow templates, its docs for LoRA, upscaling, subgraphs, FLUX.2 klein and Z-Image Turbo, the Impact Pack (version 8.28.3) and Impact Subpack repositories, and the model cards for Z-Image, Z-Image Turbo and FLUX.2 klein 4B.

This page is the assembly sheet: how the blocks connect and what changes per checkpoint family. It sits under our AI image generation for influencers guide, which covers the tools and the workflow around ComfyUI. If the app itself is new to you, read what ComfyUI is first, and for the reference-image methods in detail (IP-Adapter, PuLID, FLUX.2 references) use the ComfyUI consistent character workflow build sheet rather than this one.

What you will have at the end

One saved workflow that turns a scene prompt into a finished, upscaled image of the same fictional person, built from four subgraph blocks you can reuse across model families. You will also know which settings to copy from the base block into the detailer and the upscaler, which is where most persona graphs go wrong.

Need the installs? Our ComfyUI-Manager guide covers custom nodes, and the character LoRA dataset guide covers the training images.

The ComfyUI AI influencer graph at a glance

The identity stack is drawn as its own block, but physically it plugs into the base block: the LoRA node sits between the model loader and the sampler. What matters is that the detailer and the upscaler take their model from after the LoRA, not straight from the loader.

Step 1: build the base block for your checkpoint family

Do not wire the base block from memory. Open Workflow, then Browse Workflow Templates, load the official template for your family and render it once. ComfyUI checks for missing model files and offers the downloads. The table lists what each template contains, read from the template files themselves.

• Checkpoint versus diffusion-model families. SDXL loads from one checkpoint file. Z-Image and FLUX.2 klein load the diffusion model, text encoder and VAE through three separate nodes. That one difference decides which LoRA node you use in step 2.
• Zeroed negatives. The Turbo and distilled templates feed the sampler a zeroed negative (ConditioningZeroOut) at cfg 1. Keep it that way; a written negative prompt belongs to the base variants.
• Expected result. The template renders its sample prompt with no red nodes. Fix that before adding anything.

Which ComfyUI realistic AI influencer model to build on

Build on a base that takes a character LoRA and is licensed for what you plan to do with the images. The Z-Image and FLUX.2 klein 4B model cards both state Apache 2.0, and Black Forest Labs describes klein 4B as open weights available for commercial use. ComfyUI's template notes describe Z-Image as having exceptional photorealistic quality and being ideal for fine-tuning. For Z-Image, use the two variants for different jobs:

SDXL stays relevant because of its ecosystem: years of LoRAs, ControlNets and reference adapters were built for it. The cost is that every fine-tune has its own license. For the wider comparison, including the non-commercial FLUX variants this page leaves out, see best ComfyUI models.

Step 2: add the identity stack

The identity stack is a character LoRA first, with a reference image or pose control on top where the family supports it. The LoRA does the heavy lifting because it travels with the model into every later block.

SDXL (checkpoint family)
Load Checkpoint
  -> Load LoRA  [character LoRA | strength_model | strength_clip]
  -> CLIP Text Encode (positive: trigger word + character line + scene) / (negative)
  -> KSampler

Z-Image and FLUX.2 klein (diffusion-model families)
Load Diffusion Model
  -> LoraLoaderModelOnly  [character LoRA | strength_model]
  -> ModelSamplingAuraFlow -> KSampler            (Z-Image)
  -> CFGGuider -> SamplerCustomAdvanced           (FLUX.2 klein)

FLUX.2 klein reference input (official image-edit template)
Load Image [hero] -> ImageScaleToTotalPixels [1 megapixel] -> VAE Encode
  -> ReferenceLatent (positive) + ReferenceLatent (negative) -> CFGGuider
second reference: repeat the chain and connect it after the first

• Two LoRA nodes. ComfyUI's LoRA tutorial uses Load LoRA, which takes and returns both model and CLIP and exposes strength_model and strength_clip. The official templates for diffusion-model families use LoraLoaderModelOnly straight after the model loader. LoRA files go in ComfyUI/models/loras.
• Templates arrive as subgraphs. The Z-Image and klein templates are a single subgraph node plus Save Image. Open the subgraph with its edit button, or unpack it, to insert the LoRA node.
• Reference on klein. The image-edit template scales the reference to one megapixel, encodes it and passes it through ReferenceLatent on both conditionings. A second reference repeats the chain.
• Expected result. With a fixed seed, switching the LoRA on moves the face toward your hero image and nothing else in the scene changes much.

Our LoRA training guide covers the training run, and the ControlNet guide covers pose control on SDXL.

Step 3: add the face detailer

In a full-body shot the face covers too few pixels for any identity method to hold. A detailer finds the face, enlarges the crop, re-renders it and pastes it back. Impact Pack's FaceDetailer does this in one node; its detector, UltralyticsDetectorProvider, has lived in the separate Impact Subpack since Impact Pack 8.0.

VAE Decode (base image)
  + UltralyticsDetectorProvider  [face bbox model | Impact Subpack]  -> bbox_detector
  -> FaceDetailer
       model: taken AFTER the LoRA node | clip | vae
       positive: trigger word + character line | negative: same as base block
       node defaults: guide_size 512 | max_size 1024 | denoise 0.5 | feather 5
                      bbox_threshold 0.5 | bbox_crop_factor 3.0 | steps 20 | cfg 8.0
       steps, cfg, sampler_name, scheduler: change to your base block's values
  -> image

• Detector model. The Subpack README points to Bingsu's adetailer repository, which lists face models such as face_yolov8m.pt under Apache 2.0. The README also warns that loading model files can execute code, so download detection models only from sources you trust.
• guide_size. Per Impact Pack's detailer reference, a face smaller than guide_size is enlarged to it before re-rendering. Raise it when wide shots still look soft.
• Expected result. In a full-body image the face sharpens and still matches the hero. In a close-up there is little visible change.

Two notes on alternatives. ComfyUI core now ships MediaPipe face detection nodes (template: Face Detection: MediaPipe) that output a face mask without custom nodes; they detect, and the re-render is yours to wire. And the klein templates sample through a separate Flux2Scheduler node, which has no like-for-like setting inside FaceDetailer, so compare detailer output against the hero before you rely on it with klein.

Step 4: add the upscale block

Upscale with a model, then refine at low denoise. ComfyUI's official Image Upscale: Z-Image-Turbo 2K template does exactly that with core nodes: a 4x model upscale, a 0.5 downscale for a net 2x, then a short sampler pass.

FaceDetailer image
  -> ImageScaleToTotalPixels  [1 megapixel]
  -> Load Upscale Model [RealESRGAN_x4plus] + Upscale Image (using Model)     4x
  -> ImageScaleBy  [lanczos | 0.5]                                            net 2x
  -> VAE Encode
  -> KSampler  [model: taken AFTER the LoRA node | denoise 0.15 to 0.35]
  -> VAE Decode -> Save Image

• Denoise. The template's own note puts 0.15 to 0.25 as staying close to the input and 0.25 to 0.35 as adding more detail, and warns that values above 0.35 may introduce artifacts. Its sampler runs 5 steps at cfg 1 and denoise 0.33 on Z-Image Turbo.
• Identity. The refine pass re-renders the whole image, face included. Feed it the LoRA-patched model and a prompt that carries the character line.
• Expected result. A 2x image with finer skin and fabric texture and the same face. If the face moved, lower the denoise before touching anything else.

ComfyUI persona workflow: what to swap per checkpoint family

With the four blocks in place, changing family means replacing the base block and adjusting these rows. Everything else stays wired.

To make the swap a drag-and-drop, turn each block into a subgraph. ComfyUI's subgraph docs give the minimum versions: frontend 1.24.3 for subgraphs, ComfyUI 0.3.66 for the parameters panel and frontend 1.27.7 for publishing to the node library.

ComfyUI Instagram model workflow: running a posting batch

A posting batch is the same graph run many times with one thing changing: the scene part of the prompt. Fix everything else.

1. Set the latent to the shape you post in, at about one megapixel (the templates default to 1024 x 1024).
2. Keep the trigger word and character line identical in the base prompt and the detailer prompt. Our AI influencer prompt pack has 100 scene lines built for this.
3. Fix the seed while you test a new scene, then randomise it to collect options.
4. Draft at base resolution with the detailer and upscale blocks bypassed. Enable them only for the frames you keep.
5. Review each final against the hero at full size before it is scheduled.

That graph is a production tool, and running it well takes more than wiring. The AI Influencers program covers the surrounding skills: its Flux and SDXL setup lesson installs ComfyUI and the model templates, and the lessons on LoRA training for consistent faces and ControlNet for body consistency build the identity stack used here.

Troubleshooting: find the block that broke the face

• Red nodes after an update. Custom node packs lag ComfyUI releases, and Impact Pack lists minimum ComfyUI versions in its README. Our ComfyUI workflow library guide covers missing nodes and models.
• Burnt, over-contrasted face from the detailer. The detailer is still on cfg 8.0 while the base runs at cfg 1.
• A drift none of this explains. Work through the causes in our AI face consistency guide, one variable at a time.

ComfyUI AI influencer workflow: FAQ