CMK Hybrid SDXL → ZIT Bridge -Pipe-

The hybrid path is the most interesting idea in CMK Flow and the one most likely to be misunderstood. You don't run two models and pick a winner. You let SDXL do most of the work, stop it early, and hand the unfinished image to Z-Image Turbo for the last stretch - because Z-Image is fast, and SDXL is the one that knows your LoRAs.

Why anyone would do this

Two things are true at once in 2026. Z-Image Turbo is a 6B flow-matching model that produces excellent images in 8 steps at CFG 1, on hardware that used to struggle with Flux. But it's distilled, and the complaint that stuck was seed diversity: the same prompt across seeds produced near-identical images. SDXL's ecosystem, meanwhile, is mature in exactly the ways Z-Image's isn't - LoRAs, ControlNet, InstantID, fine-tunes for every taste.

Hybrid takes both. SDXL establishes composition with all its tooling, and Z-Image does a fast finish pass to clean it up. The pack exposes the split point as a percentage: hybrid_sdxl_handoff defaults to 90, meaning SDXL runs the first 90% of the schedule and ZIT picks up the rest. hybrid_zit_denoise defaults to 0.20 - the ZIT pass is deliberately light, a finisher rather than a re-render.

What this node does

It decides whether the ZIT branch gets its own source image or the SDXL handoff, and it cleans up after itself.

PROCESS ZIT is required - that's the cheap signal everything else hangs off, and it carries the hybrid_mode flag. Then:

• Not hybrid: you get back IMAGE SOURCE, LOG SOURCE and VISUAL SOURCE - the ordinary ZIT path, untouched. Note the lazy behaviour here: IMAGE SOURCE is only demanded when the process also reports a boolean-inpaint mode. A plain text-to-image ZIT run never pulls an image it doesn't need.
• Hybrid: it takes the SAMPLED SDXL pipe and pulls image_1st_pass off it - the clean x0 that the SDXL sampler boundary already decoded. If that image is missing, you get a specific error rather than a silent empty handoff.

A detail worth understanding, because it explains why the hybrid workflow is structured the way it is: Z-Image Turbo reuses the Flux 1 VAE, not SDXL's. So the handoff here is at image level - SDXL's x0 is decoded, and Z-Image encodes it in its own VAE - not a latent-to-latent pass. Sharing a latent space is what makes a refiner chain cheap, and these two don't share one.

The cleanup, which is the real reason it exists

After the handoff, if the process says unload_models_after_use, this node drops the SDXL phase models and clears the SDXL sampled boundary cache, reporting the counts in its log. In hybrid-inpaint mode it also releases the completed SDXL patcher's patch tensors - Fooocus-style spatial patches and all the attachment dictionaries - before garbage collecting.

That's the difference between hybrid working on a 12GB card and hybrid being a curiosity, and it's reported in a log block you can read:

MODE            : SDXL -> ZIT
SDXL HANDOFF    : 90%
BRIDGE          : SDXL x0 decode -> ZIT VAE encode
SDXL MODEL      : <unload status>
SDXL CACHE      : CLEARED (n)
ZIT DENOISE     : 0.20

Outputs are IMAGE, LOG and VISUAL - the chosen source image, the combined log including the SDXL side, and the visual chain, which is how the Visualizer can show both halves of the hybrid as one run.

When you'd touch it

You mostly wouldn't. It sits inside the pack's hybrid reference workflows. It matters when you're building your own hybrid graph and wondering why the SDXL model is still resident after the handoff, or when you want the ZIT branch to accept either source and you're deciding where the switch belongs.

unload_models_after_use lives on the process, not on this node, so if the SDXL model sticks around, that's the flag to look at.

Install

Manager: search CMK Flow, install, restart. Manual, from your ComfyUI root:

git clone https://github.com/CMKFlow/cmk_nodes.git custom_nodes/cmk_nodes
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py
python3 custom_nodes/cmk_nodes/scripts/check_cmk_resources.py --models-root "/path/to/ComfyUI-Shared"

For a hybrid run you need both sides present: an SDXL checkpoint plus its LoRAs and adapters, and the Z-Image Turbo weights, which are multi-gigabyte, so the resource script confirms each file separately. Weights are never part of the Python package.

Where people get burned

Both models resident. If you're near your VRAM ceiling, hybrid can be worse than either single path unless unloading is on. Check the log block.

Expecting latent handoff. It isn't one - the VAEs differ. Don't plan on the trick that works when two models share a VAE.

Weak SDXL base, disappointed result. The ZIT pass at 20% denoise can clean texture; it can't fix a composition you didn't like. Fix the first 90% before blaming the finish.