Eric_Krea2

Self-contained ComfyUI custom nodes for Krea 2 - Krea AI's open-weight, from-scratch image model (single-stream MMDiT, flow matching, Qwen3-VL conditioning). Includes text-to-image, progressive multi-stage high-res generation, a 2× upscale-decode trick, and natural-language prompt tooling.

No dependency on any other node pack.

Why Eric_Krea2 - key advantages

• Real diffusers pipeline, not a reimplementation. Runs the genuine Hugging Face Krea2Pipeline (single-stream MMDiT, flow matching, Qwen3-VL conditioning) loaded straight from weights - so you inherit upstream behaviour, fixes and the correct trained prompt templates, with no reverse-engineered sampling loop to drift out of sync.
• Easy, honest multi-stage high-res. Up to 3 progressive stages in one node, with per-stage samplers, schedules, guidance and re-noise windows, plus an on-node resolution-chain readout so you always see the real S1→S2→S3→decode sizes.
• First-class img2img. A VAE Encode node feeds an init_latent input; denoise strength is just the stage's re-noise step window - no separate float to guess.
• Reference-image style/content grounding (Vision Prompt). Ground conditioning in 1-3 reference images through Krea2's own Qwen3-VL vision path - a "prompt from a picture" effect (semantic style/content grounding, not pixel editing) with no training and none of the silently-discarded-reference pitfalls of the common community pattern. Composes freely with img2img for structure + content on separate channels.
• Presets everywhere. Named JSON presets per section (loader / LoRA / Ultra / sigmas) with a ★ Save button, a Merge Settings node, and Settings-from-Image for one-click reproduction of a saved image's recipe.
• LoRA with per-stage settings + presets. Apply / unload / diagnose plus a Multi-LoRA Stack - both with per-stage weights (S1/S2/S3), so a LoRA can steer composition harder than final detail (or vice-versa) within a single multi-stage run, and both with named-preset save/load (★ Save) for one-click recall.
• Reference-latent edit pathway. With an edit-trained LoRA loaded, a Reference Latents node feeds VAE-encoded reference images through the ai-toolkit "index_timestep_zero" method - real pixel/structure conditioning (distinct from Vision Prompt's semantic grounding), reimplemented against our diffusers transformer.
• Custom flow-matching samplers, no external solver. res_2m, res_2s, deis_3m, deis_4m re-implemented from the RES/DEIS papers, selectable per stage, with schedule + detail_bias control.
• Two high-res strategies for two checkpoints. Turbo → fast 4k via the 2× upscale-decode; Raw → controlled multi-stage re-denoise - plus optional downsample "quality-pass" VAE modes that are usually cleaner than the Wan 2.1 VAE at the same size.

What's New

Late July 2026 (cont.) - field-calibrated scoring, preset UX, er_sde.

• Field-calibrated metrics & captions - clip% flags at absolute 4%/6% thresholds, Tenengrad is the displayed/gated sharpness, splotch and noise are demoted to CSV-only, contact-sheet captions use stage-grouped shorthand with a compact wrapped metric line, and Auto Pick gained the most_typical objective (consensus render) plus a uniqueness consensus-outlier gate. Calibrated from two full 192-cell runs.
• Folder scoring chain - the new Eric Sweep Folder Scorer (in Eric-image-classification) grades a whole sweep with Blur V7 / Noise V4 / composition / exposure / UniPercept and writes a merged scores.csv that Auto Pick reads via best_external: sweep -> unload -> score -> pick -> promote in one queue.
• Sweep presets that show themselves - the Sweep Plan node joined the ★ preset system: selecting a preset writes its values into the panel, editing flips back to custom, and a preset_notes field (also on the Sigmas node) keeps a saved sentence about what each preset is for.
• er_sde sampler + simple scheduler - a ComfyUI-faithful ER-SDE Solver-3 port (verified step-identical): intrinsically stochastic, and the only 1-eval/step sampler that is schedule-proof (amplification 0.048 on EVERY schedule incl. linear_quadratic). eta is ignored; the noise TYPE shapes its churn (colored-noise er_sde is unique to this package). simple = uniform-in-sigma, an alias of linear.
• Swept-schedule precedence - swept schedule cells now disable a wired sigmas bundle for that stage, cell-locally: a swept axis is never silently inert.

Late July 2026 - parameter sweeps, hybrid samplers, inter-stage renorm.

• Parameter sweep system - wire an Eric Krea2 Sweep Plan into Ultra V2's new sweep input and one queue item runs a whole grid (or explicit combo list) of sampler / scheduler / steps / window / eta / noise / mu / cfg / megapixels settings against a fixed seed: per-cell PNGs with full embedded recipes, a labeled contact sheet, sweep_summary.csv, a JSON manifest, automatic S1-latent reuse for s2/s3-only cells, and one-click promotion of a winning cell to a preset. See Parameter sweeps.
• lcm_hybrid / lcm_hybrid2 samplers + hybrid_split - lcm full-churn entry (launders upscale damage) handing off to a trajectory-faithful tail (deis_3m / res_2m) at a selectable fraction of the window.
• upscale_renorm - repairs the latent variance each upscale hop drains (variance is contrast/saturation), stopping the progressive flattening of multi-hop runs. per_channel recommended.
• Sweep v2: LoRA, prompt & sigma-profile axes - bake a whole style-LoRA library off against the bare checkpoint (or layered on your stack), ladder one stack entry through strengths, cross everything with a prompt list and with saved sigma-shape presets - all in one queue item, all standalone- reproducible per cell.

July 2026 - multi-stage sampling, presets & img2img toolkit.

• Custom flow-matching samplers - res_2m, res_2s, deis_3m, deis_4m re-implemented from the RES/DEIS papers (no external solver import), selectable per stage. Recommended: res_2s + beta57 for the Stage-1 draft, deis_3m / deis_4m + bong_tangent for the refine passes.
• Shared schedule library + Sigmas node - linear, balanced, karras, beta57, beta, bong_tangent, exponential, with a per-stage detail_bias control driven from a dedicated Sigmas node.
• img2img - a VAE Encode node plus an init_latent input on the Multi-Stage node; denoise strength is set by the re-noise step window.
• Vision Prompt - image-grounded conditioning via Krea2's own Qwen3-VL vision path (no training, no VAE/reference-latent pathway needed). Auto-shares its megapixel budget across however many reference images are connected. See Vision Prompt.
• Resolution & latent helpers - a Resolution node (aspect+MP or image-derived size → width/height/blank latent) and a latent-space Latent Resize (bislerp, no VAE round-trip).
• Presets & settings - named JSON presets per section (loader / component loader / Apply LoRA / LoRA stack / Ultra / sigmas) with a ★ Save button, a Merge Settings node, and Settings from Image for one-click reproduction.
• LoRA tooling - apply / unload / diagnose plus a Multi-LoRA Stack, both with per-stage weights (S1/S2/S3) and named-preset save/load (★ Save).
• Reference Latents (edit LoRAs) - a Reference Latents node VAE-encodes 1-3 reference images into the ai-toolkit "index_timestep_zero" edit pathway, fed via a new optional ref_latents input on the Multi-Stage Ultra (res) node. Works only with an edit-trained LoRA loaded (e.g. the Krea 2 Style Reference LoRA on Turbo at guidance 0); the base model can't read reference tokens. See Reference Latents.
• Upscale VAE quality-pass modes - the trained spacepxl Wan 2× decoder can drive the S2→S3 jump and/or the final decode, each with a downsample variant that keeps its sharp detail but resamples down to your chosen size instead of forcing 4× area. The … with downsample modes are usually cleaner/sharper than the Wan 2.1 VAE at the same output size and avoid the resolution blow-up. An on-node resolution-chain readout shows the real S1→S2→S3→decode sizes and flags any field the VAE overrides. See Upscale VAE: modes & precedence.

Initial release (June 2026): Krea 2 Raw + Turbo support, multi-stage high-res, 2× upscale-decode, selectable attention backend, natural-language prompt builder + LLM Magic-Prompt expander.

Requirements

These nodes drive the genuine Hugging Face Krea2Pipeline directly (see key advantages); the only hard requirement is a diffusers/transformers build new enough to expose it.

• A diffusers build that includes Krea2Pipeline (merged after 0.39.0.dev0):

  python_embeded\python.exe -m pip install --upgrade --force-reinstall --no-deps git+https://github.com/huggingface/diffusers.git
  

  The version string stays 0.39.0.dev0, so --force-reinstall is required to pull the newer commit.

• A transformers new enough to provide Qwen3VLModel.

• Krea 2 weights in diffusers layout (e.g. H:\Training\Krea-2-Raw and H:\Training\Krea-2-Turbo).

• Optional, recommended on Blackwell: FlashAttention and/or SageAttention for the faster attention_backend paths.

• Optional: the spacepxl Wan 2× upscale VAE (auto-downloaded on first use).

Example workflow

A single, multi-purpose graph lives in workflows/. Drag example-workflow.png onto the ComfyUI canvas (the graph is embedded in the PNG metadata) to load the whole pipeline at once - loaders, txt2img, img2img, Vision Prompt, per-stage sampling, and the metadata-aware save. Flip parts on/off with group bypass (Ctrl+B) instead of juggling separate workflows. See workflows/README.md for the group-by-group breakdown.

Nodes

Core generation

Node	Does
Eric Krea2 Loader	Loads Krea2Pipeline (Raw or Turbo), applies attention_backend, caches in VRAM. Auto-detects is_distilled. Preset dropdown.
Eric Krea2 Generate	Text-to-image. Emits IMAGE + a chainable KREA2_LATENT. auto_settings picks 8/0 for Turbo, 28/4.5 for Raw.
Eric Krea2 Multi-Stage Ultra (res)	Up to 3-stage progressive high-res with the custom RES/DEIS samplers, per-stage schedules, img2img init_latent, an optional ref_latents edit input, and width/height overrides. Best on Raw.
Eric Krea2 Multi-Stage Ultra V2 (presets)	Preset-driven variant of the Ultra node - serialises every widget (incl. sigmas, width/height) into one reproducible recipe.

The loader group - the Component Loader (with loader_preset), the Upscale and Decode VAE loaders, and the growable Multi-LoRA Stack with per-stage strengths. Each carries its own ★ Save Preset button.

Sampling & scheduling

Node	Does
Eric Krea2 Sigmas	Per-stage schedule overrides (S1/S2/S3): curve, detail_bias, Beta α/β. Emits a KREA2_SIGMAS bundle the Ultra nodes fold in.

The Sigmas node: per-stage curve / detail_bias / Beta α-β overrides with a live sigma preview per stage (solid = steps that run, ring = re-noise level, ghost = full schedule).

Samplers (per stage, on the Ultra node): euler, res_2m, res_2s, deis_3m, abnorsett_3m, abnorsett_4m, lawson4_4s, etdrk4_4s, er_sde, rk6_7s, lcm, lcm_hybrid, lcm_hybrid2. Schedules: linear, balanced, karras, beta57, beta, bong_tangent, exponential, linear_quadratic, simple (= ComfyUI's uniform-in-sigma scheduler; alias of linear here). See Samplers & schedules.

Sweeping & characterization

• Eric Krea2 Sweep Plan - builds a KREA2_SWEEP plan (grid axes or JSON-lines combos, stage scoping, quick-screen mode, output folder, hard combo cap). Wire into Ultra V2's sweep input.
• Eric Krea2 Sweep → Preset - promotes any cell of a finished sweep's manifest into ultra_presets.json, tagged with the checkpoint name. See Parameter sweeps.

img2img, resolution & latents

Node	Does
Eric Krea2 VAE Encode	Encodes an IMAGE → KREA2_LATENT (the img2img primitive).
Eric Krea2 Reference Latents (Edit)	VAE-encodes 1-3 reference images → KREA2_REF_LATENTS for the Ultra (res) node's ref_latents input (ai-toolkit "index_timestep_zero" edit method). Needs an edit-trained LoRA to do anything; the base model ignores reference tokens. See Reference Latents.
Eric Krea2 Resolution	Size from aspect_ratio + megapixels or a source image → width/height/dims + a blank KREA2_LATENT (noise or zeros).
Eric Krea2 Latent Resize	Resize a KREA2_LATENT in latent space (bislerp, no VAE round-trip): scale / dimensions / megapixels.
Eric Krea2 Latent → ComfyUI LATENT	Bridge a KREA2_LATENT to a stock ComfyUI LATENT.

Decode

Node	Does
Eric Krea2 Upscale VAE Loader	Loads the spacepxl Wan 2× upscale decoder → UPSCALE_VAE. Optional downsample_to_1x + blur_sigma: decode at 2× then Lanczos-downsample back to native size - a supersampling-style quality pass instead of a literal resolution gain. Travels with the loaded VAE into every consumer (see Upscale VAE: modes & precedence).
Eric Krea2 Decode VAE Loader	Loads a plain decode VAE.
Eric Krea2 Upscale Decode (2×)	Decodes a KREA2_LATENT via the upscale VAE (no re-denoise). Resolution and any downsample/blur are whatever the loaded UPSCALE_VAE was configured with.
Eric Krea2 VAE Decode	Plain 1× decode of a KREA2_LATENT.

Presets, LoRA & utilities

Node	Does
Eric Krea2 Merge Settings	Merges section recipe strings into one KREA2_SETTINGS (dicts updated, lora lists concatenated).
Eric Krea2 Settings from Image	Reads an image's embedded generation settings back into a KREA2_SETTINGS recipe.
Eric Krea2 Component Loader	Loads pipeline components with a preset dropdown.
Eric Krea2 Apply LoRA / Unload LoRA / Diagnose LoRA	Apply, cleanly remove, and inspect LoRA adapters on the cached pipeline. Apply LoRA supports per-stage weights (per_stage_weights + weight_s1/weight_s2/weight_s3) so a LoRA's strength can differ across S1/S2/S3 in a multi-stage run, plus a preset dropdown (apply_lora_preset + ★ Save).
Eric Krea2 Multi-LoRA Stack	Stack several LoRAs in one growable node - each slot has per-stage weights (strength_Ns1/s2/s3 for S1/S2/S3) and an on/off toggle, plus a shared ephemeral switch and a preset dropdown (lora_preset + ★ Save). Unused rows auto-hide until needed.
Eric Krea2 Unload Models	Free VRAM on demand.
Eric Krea2 Save Latent (debug)	Save/inspect a packed latent for debugging.

Reproducibility: Merge Settings folds the loader + Ultra + LoRA + prompt recipes into one bundle that gets embedded in the saved PNG - readable back later via Settings from Image.

Prompting

Node	Does
Eric Krea2 Prompt	Assembles structured fields into a dense, comma-joined natural-language prompt; quotes text-to-render.
Eric Krea2 Magic Prompt	Expands a short prompt via a local LLM (LM Studio / Ollama / any OpenAI-compatible endpoint).
Eric Krea2 Vision Prompt	Grounds conditioning in 1-3 reference images via Krea2's own Qwen3-VL vision path, using Krea2's trained descriptor template (not the generic Qwen-Image-Edit template). Emits KREA2_CONDITIONING → Ultra's prompt_conditioning input. See Vision Prompt below.

Samplers & schedules

Each stage of the Multi-Stage Ultra node picks a sampler (the ODE solver) and a schedule (the sigma spacing) independently.

A full sampling group - the Sigmas node feeding Multi-Stage Ultra V2, with per-stage samplers/schedules, guidance, re-noise windows, and the on-node resolution-chain readout.

Samplers

Sampler	Order	Model calls / step	Best for
euler	1	1	Baseline / native parity (the comfy euler+simple twin). Honours early stop and eta (runs as a 1-stage RK).
res_2m	2 (multistep)	1	General use - sharper than Euler at the same cost.
res_2s	2 (single-step)	2	Low step counts / Stage-1 draft. Self-starting; ~2× slower.
deis_3m	3 (multistep)	1	Smooth refine passes.
deis_4m	4 (multistep)	1	Smoothest refine at higher step counts.
rk6_7s	~6 (7-stage RK)	7	Maximum solver accuracy (finetuner recipes; the Raw model). ~7x cost per step - overkill for Turbo daily use.
abnorsett_4m	4 (exp. multistep)	1	Recipe-name alias of deis_4m - identical update in this solver formulation.
lcm	ancestral	1	Post-upscale refine windows: jumps to x0 and fully re-noises every step, laundering upscale artifacts. Not for Stage 1.

Every sampler honours a noisy early-stop (end_step < steps), letting a stage hand a partially-denoised latent to the next, and supports the ancestral eta SDE path (lcm is inherently fully ancestral - see below). Since the 2026-07-22 shift-consistency fix, euler runs through the same solver path as every other sampler (as a 1-stage Runge-Kutta), so the re-noise level and the stepping always share one sigma space. The math is recreated from the RES (arXiv:2308.02157) and DEIS (arXiv:2204.13902) papers plus standard Butcher tableaus - no external solver code is imported.

Schedules: linear, balanced, karras, beta57, beta, bong_tangent, linear_quadratic (ComfyUI-core slow-linear-then-quadratic descent; the kreamania pass-1 schedule), exponential. The Sigmas node adds a detail_bias knob (biases sigma spacing toward fine detail vs. large structure) and Beta α/β shaping.

Recommended pairings (per the RES4LYF community):

• Stage 1 (draft): res_2s + beta57.
• Stage 2/3 (refine): deis_3m or deis_4m + bong_tangent.
• Post-upscale laundering (native-parity chains): lcm + linear with a deep window - see below.

Native parity note: linear + distilled_shift=fixed reproduces ComfyUI's euler/simple spacing exactly (same uniform grid, same exponential mu=1.15 shift) - that pairing IS the native baseline, not an approximation of it.

Choosing a sampler per stage: warmup & accuracy

Two independent properties decide which solver fits a stage. They often point in opposite directions, so it's worth understanding both rather than just copying the pairings above.

1. Multistep warmup (order build-up). Multistep solvers (res_2m, deis_3m, deis_4m) reach their rated order by fitting a polynomial through past steps, so they start low-order and ramp up:

Step in the run	deis_3m effective order
1st	1 (Euler-like)
2nd	2
3rd onward	3 (full)

Crucially, each stage restarts the solver - the history buffer is empty at the stage boundary and does not carry across the re-noise handoff. So the ramp is measured from the first step of that stage's run, not the global step index. A Stage-3 run of steps=14, start=7, end=14 is 7 sampling steps, of which the first ~2 are below full order (full 3rd order from its 3rd step ≈ global step 9). deis_4m ramps over ~3 steps and needs even more runway. Sub-order steps aren't "wrong" - they're just Euler/2nd-order accurate - but at low step counts the warmup eats most of the run and the higher order never pays off.

res_2s is self-starting (a self-contained predictor+corrector, 2 model calls per step) - full order from step 1, no warmup - which is why it wins when steps are scarce. Cost balances out because you use fewer of them: res_2s @ 4 steps = 8 calls ≈ deis_3m @ 7 steps = 7 calls, but cleaner at the low count.

2. Trajectory smoothness (from-noise vs from-clean). This is why Stage 1 uses a single-step solver even though it has plenty of steps to amortize warmup:

• Stage 1 starts from pure noise (σ≈max). The early high-σ steps are where the model's x₀ prediction is roughest and swings hardest step-to-step, and where global composition is decided. Multistep solvers extrapolate a polynomial through those past predictions, so rough/rapidly-changing history risks overshoot/ringing exactly where structure is set. res_2s doesn't rely on history, so it's robust on that rough start, and its corrector buys accuracy on the most consequential steps of the whole pipeline.
• Stages 2/3 start from an already-clean latent (low-mid σ, smooth trajectory). Here the multistep history is reliable, so deis_3m's cheap high-order extrapolation genuinely shines.

Putting it together:

Stage	Trajectory	Steps	Pick	Why
S1 draft	from noise	long	res_2s	robustness on the rough start > cheap order
S1 draft (cost-saving)	from noise	long	res_2m	multistep middle ground: 1 call/step, some early robustness given up
S2/S3 refine	from clean	long (≥~8-10)	deis_3m	smooth trajectory + cheap order; warmup amortized
S2/S3 refine	from clean	very long, smooth schedule	deis_4m	marginal extra accuracy once there's runway
S3 light refine / no upscale	from clean	few	res_2s	self-starting - no warmup waste when steps are scarce

Rules of thumb: from noise → self-starting (res_2s); from clean + many steps → multistep (deis_3m/4m); from clean + few steps → back to res_2s (no warmup to waste). deis_4m only over deis_3m on long, smooth, high-step runs; it's more prone to overshoot on short or noisy-early-stop stages.

Trajectory vs churn: where lcm fits

Every sampler answers the same question - "given where the latent is and how noisy it should be, where does it go next?" - and they split into two philosophies.

The ODE family (euler, res_2m, res_2s, deis_*, rk6_7s) treats denoising as following a trajectory. Each step nudges the current latent along the flow, so information accumulates: real structure, but also upscale ridges, interpolation error, and leftover mottling get carried forward, refined, and sharpened into the output. The members differ only in how accurately they follow the path (euler crudely, rk6_7s obsessively). Faithful is their virtue and their flaw: they preserve everything, including what you wish they would not.

lcm is the other philosophy. Each step asks the model for its best guess of the finished image (the x0 prediction), then throws the current latent away and rebuilds the next one as that guess plus fresh noise at the next sigma (the flow-matching mix (1 - sigma) * x0 + sigma * noise). No trajectory, no memory: whatever damage the latent carried - contour lines from a latent upscale, seam echo, mismatch residue - is discarded every step and replaced by the model's own clean prior plus new noise. That is why it launders artifacts that deterministic ODE samplers faithfully integrate. The price is symmetric: it also discards fine detail the trajectory was carrying, drifts more from the init, and shows larger seed-to-seed variety.

The choice rule: damaged starting latent you want repaired -> lcm. Precious starting latent you want preserved -> an ODE sampler. In between - trajectory with some laundering - is exactly what eta > 0 on the res/deis samplers is.

Concretely: post-upscale refine windows are lcm home turf (the latent just got stretched and is full of interpolation artifacts - the entire secret of the native euler -> lcm two-pass chains). Stage 1 is ODE territory: you are building structure from noise and want it followed faithfully, and Turbo is TDM-distilled, not LCM-distilled, so full-ancestral from pure noise reads rough and unstable. A same-resolution polish on an already-good image is a judgment call: shallow lcm freshens texture and kills residue; shallow deis/res preserves likeness.

What shapes lcm's churn (it consumes fresh noise every step, so it is the sampler most sensitive to what that noise is):

• Window depth (start_step/end_step): how much of the image gets rebuilt. Deeper start = more repair, more drift.
• Step count: number of churn events across the same sigma range - more steps = finer-grained laundering.
• Schedule curve + detail_bias (Sigmas node): where the re-noise ladder concentrates. Positive bias packs churn events at low sigma (texture polish); negative packs them high (structural repair).
• distilled_shift / mu: moves the whole ladder (higher mu = more time spent churning at high sigma = smoother, deeper repaint).
• noise_type and eta: lcm-family re-noise draws are ALWAYS plain seeded white - the model was trained on white noise at every sigma, and a FULL replacement with colored noise is out-of-distribution (it decodes as chromatic blotches over the image). noise_type shaping applies only to the fractional SDE churn of the res/deis/rk samplers at eta > 0. For colored-noise grain character, use deis_3m/res_2m with eta 0.5-1.0 and a noise_type - not lcm.
• Per-stage seed (seed_mode): lcm windows show more seed variety than the deterministic solvers - that is the churn, not a defect.

Recommended lcm refine baseline (the native-parity chain):

• S2: 12 steps, window 6 -> 12 (6 denoise steps), lcm + linear, distilled_shift=fixed, eta 0, white noise; upscale_to_stage2 ~1.2 (area), S1->S2 VAE upscale OFF (plain latent hop).
• S3: 12 steps, window 5 -> 12, otherwise identical; upscale_to_stage3 ~1.5.
• Artifacts surviving the window -> start deeper (5 or 4). Likeness drifting -> start shallower (7-8). Want extra texture -> detail_bias +0.2..+0.3.
• Keep lcm off Stage 1 (see above).

The lcm hybrids & hybrid_split

Pure lcm's weakness is that its final detail is bounded by the x0 prediction at the entry (highest-sigma) steps: the first full re-noise discards the incoming trajectory - including the previous stage's real detail - and later steps only polish that re-invention. The hybrids keep lcm's artifact laundering where it works (the entry steps, where upscale damage lives) and then develop detail trajectory-faithfully at low sigma, where detail is actually made:

• lcm_hybrid - lcm churn, then a deis_3m tail.
• lcm_hybrid2 - lcm churn, then a res_2m tail (added 2026-07-25; res_2m has been testing better than deis_3m as the detail-development half on several fine tunes - both tails cost the same per step).
• s1/s2/s3_hybrid_steps (Ultra widgets, default 0) - the handoff in EXACT lcm steps at the head of that stage's window. 0 = auto (half the window, ceil - the original behavior). At low step counts this is the honest control: a fraction only has window-1 real values, so small % changes were silent no-ops. Fewer lcm steps = more trajectory-faithful detail; more = more laundering. Clamped so both halves always run; ignored by every other sampler. Sweepable via the hybrid_steps axis or combos JSON ({"s2_hybrid_steps": 4}).
• eta/noise_type apply to the tail half only; the lcm half is inherently fully ancestral and always re-noises with plain seeded white (colored noise as a full replacement is out-of-distribution -> rainbow blotches).
• eta contract: honoured by res_2m/res_2s/deis_3m/abnorsett_3m/ abnorsett_4m/lawson4_4s/etdrk4_4s/rk6_7s and the hybrid tails; ignored by euler and lcm (euler is the deterministic baseline - enforced in the dispatch, and the Sweep Plan automatically drops cells that differ only by inert eta/noise on those samplers).

The Norsett & exponential-RK additions (2026-07-27): abnorsett_4m is no longer a deis alias - it is the genuine fixed-coefficient Norsett exponential Adams-Bashforth method (RES4LYF-faithful, verified against its phi tables), with abnorsett_3m as its 3rd-order sibling; the weights depend only on the current step size, so they stay BOUNDED on every schedule. deis_4m was removed: its exact variable-step weights blow up on strongly non-uniform ladders (measured 269x on linear_quadratic) and amplify model-prediction noise into garbage - if a saved workflow used it, pick abnorsett_4m (stable order 4, same 1 call/step) or deis_3m. lawson4_4s and etdrk4_4s are single-step exponential RK order 4 (4 model calls/step, no history): the most noise-robust solvers in the package, stable everywhere, strong candidates for refine windows. Note lawson is deliberately not phi-exact for constant forcing (classical Lawson quadrature) - a texture character difference from etdrk4, not a bug.

Sampler x schedule pairing guide (12 steps, measured 2026-07-28)

Numbers = median deviation of the final state when the model's per-step predictions disagree by 2% (the solver's amplification of prediction noise; lower = more stable). Stability is necessary, not sufficient - which stable pair looks BEST for a given fine tune is what the sweep decides.

sampler	best schedules	fine	avoid
euler, res_2s	any (0.017-0.029)	-	-
lawson4_4s, etdrk4_4s	any (0.009-0.022, noise-suppressing)	-	-
res_2m	exponential/beta/beta57/karras (0.020-0.022)	linear (0.053)	linear_quadratic (0.152)
deis_3m	exponential/beta57/beta/karras (0.022-0.025), OPT-DEIS12 ★ (karras +0.75 bias, 0.023)	bong_tangent/balanced (~0.03), linear (0.118)	linear_quadratic (0.834)
abnorsett_3m	beta57/beta (0.021), exponential/karras (0.022-0.025)	linear (0.060), linear_quadratic (0.115)	-
abnorsett_4m	beta57/beta (0.022), OPT-AB412 ★ (beta57 +0.5 bias)	exponential/karras (~0.03), linear_quadratic (0.178)	-
er_sde	ANY - 0.048 flat on every schedule incl. linear_quadratic (stochastic contraction; schedule-proof at 1 eval/step). Community recipe: + simple @ 8 steps	-	-
lcm_hybrid/2	beta57/beta/karras/exponential (0.023-0.028) + the EXP ★ family	bong_tangent (~0.026)	linear (0.055-0.116), linear_quadratic (~0.15)

Detail-bias windows (how far you can push detail_bias before conditioning degrades, per curve): deis_3m stays clean on exponential to +0.25, on beta57/beta from -0.75 to +0.5, and on karras it IMPROVES with positive bias (clean -0.25 to +0.75 - positive bias straightens the karras tail in t = -log sigma, which is why OPT-DEIS12 = karras +0.75 is both the most detail-holding and among the most stable deis_3m curves). abnorsett_4m: beta57/beta clean -0.75..+0.5; exponential to 0; karras never fully clean. Single-step order-4 samplers ignore conditioning entirely - schedule choice is pure aesthetics there. OPT-DEIS12 and OPT-AB412 ship as ★ sigma presets (S1-only, 12-step recipes).

Field-tested Stage-1 recipe (2026-07-26, found with the sweep system): 12 total S1 steps with either hybrid (lcm_hybrid / lcm_hybrid2) over an exponential-family custom sigma curve (authored in the Eric Krea2 Sigmas node and saved as ★ presets - e.g. the EXP1-EXP4 set) lands among the fastest runs while holding up across most fine tunes and curves. The handoff sweet spot is s1_hybrid_steps = 7 of 12 for most model/curve combinations. Treat it as a development control: 5-6 lcm steps hands off earlier and develops more fine detail; 8 (sometimes 9) launders longer for a cleaner, less-detailed look. The recipe re-derives itself per fine tune in one sweep: samplers lcm_hybrid, lcm_hybrid2 x hybrid_steps 5, 6, 7, 8 x your saved curves in sigma_profiles.

img2img

img2img (Part 1): a start image is VAE-encoded into the S1 init_latent. Denoise strength lives in the step window; the prompt still does the talking. Bypass the group for pure txt2img.

Load Image → Eric Krea2 VAE Encode → (init_latent) Multi-Stage Ultra
                     └→ Eric Krea2 Resolution (image) → width/height → Multi-Stage Ultra

Stage 1 re-noises the init_latent at s1_start_step and denoises the [s1_start_step, s1_end_step] window - so denoise strength is the step window, not a separate float. Feed width/height from the Resolution node (or turn on init_match_size) to size Stage 1 to the source image.

Vision Prompt (image-grounded conditioning)

Vision Prompt (Part 2): a reference image + a short instruction run through Krea2's own Qwen3-VL vision path → KREA2_CONDITIONING. Sets content/style; pairs with img2img for structure.

Load Image(s) -> Eric Krea2 Vision Prompt -> (prompt_conditioning) Multi-Stage Ultra

Pushes 1-3 reference images through Krea2's own text encoder's vision path (it's a Qwen3-VL VLM, not text-only), so the resulting conditioning is visually grounded by those images - a "prompt from a picture" effect - without training anything and without the pitfalls of the community pattern of reusing the core TextEncodeQwenImageEditPlus node for this: that node's VAE-encoded reference goes nowhere (the base Krea2 DiT has no reference-latent pathway - Krea2.extra_conds never reads reference_latents, so it's silently discarded; an edit-trained LoRA is what adds one, exposed separately via the Reference Latents node), and it falls back to Qwen3-VL's generic image-description template once an image is attached instead of the descriptor template Krea2 was actually conditioned with. This node has no VAE step at all (nothing to discard) and always uses Krea2's own prompt_template_encode_prefix/ _suffix, read straight off the loaded pipeline so it can't drift out of sync.

This is semantic grounding, not pixel editing. With no reference-latent pathway of its own it gives no structure/identity preservation from the image alone - for that, pair it with img2img (below): img2img supplies structure (what to start denoising from), Vision Prompt supplies content (what to draw toward). They're independent channels into the transformer and compose freely, including with different source images for each. (If you have an edit-trained LoRA, the Reference Latents node adds a third, pixel-level channel.)

Positive-conditioning only. Steering toward a reference makes sense; steering away from one is a much stranger ask, and Turbo (the primary target) mostly runs cfg=0 anyway - no negative pass to feed. When prompt_conditioning is connected, Ultra's own prompt field is entirely inert (not used, not logged) - put your text in the Vision Prompt node's own prompt field instead. cond_rebalance still applies to it, identically to a text-only encode.

Token budget - the one thing to know before your first run. Krea2 was trained with a fixed 512-token text budget (prefix + images + prompt, always padded/ truncated to exactly this length) - unlike Qwen-Image's dynamic per-batch padding, which is why Qwen-Image tolerates a much higher max_sequence_length more gracefully. One full-resolution (1 MP) reference image alone is ~988 tokens - nearly double the whole budget before your prompt or even the 34-token prefix. To keep this workable out of the box, the node auto-shares a ~0.40 MP budget across however many images you connect (1 image ≈ 0.40 MP, 2 ≈ 0.20 MP each, 3 ≈ 0.13 MP each) and raises a clear, specific error - with a suggested vision_megapixels value - rather than silently truncating into the image-token block (which corrupts position ids and crashes deep inside get_rope_index with a cryptic shape-mismatch instead). vision_megapixels is a ceiling on top of the auto-share, not a replacement for it - lower it to reserve more room for a long prompt.

Reference Latents (edit-LoRA image conditioning)

Load Image(s) -> Eric Krea2 Reference Latents -> (ref_latents) Multi-Stage Ultra (res)

A second, pixel-level way to condition on a reference image - complementary to Vision Prompt's semantic grounding. Each reference image is VAE-encoded and flow-packed exactly like a generation latent, then its tokens are appended to the image sequence and modulated at t = 0 (clean data) - the ai-toolkit "index_timestep_zero" edit method. The velocity prediction is sliced back to the live image tokens, so the references only inform the denoise, they aren't denoised themselves.

Requires an edit-trained LoRA. The base Krea2 model was never trained to read these tokens - this pathway only does something useful with an ai-toolkit krea2 edit LoRA (model_kwargs.edit: true) loaded, e.g. the Civitai Krea 2 Style Reference LoRA. Without one, the reference tokens are appended but effectively ignored (and you just pay their compute cost - ~2048 tokens per 1 MP ref, per denoise step).

Recommended wiring (matches the Style Reference LoRA's training setup):

• the reference image(s) → Reference Latents (max_ref_megapixels 1.0) → ref_latents;
• the same image(s) → Vision Prompt (vision_megapixels ≈ 0.15) → prompt_conditioning;
• the edit LoRA in the Multi-LoRA Stack at strength 1.0;
• Turbo checkpoint at guidance 0.

CFG caveat. The transformer-forward wrapper can't tell a positive pass from a negative one, so with guidance enabled the references condition both passes and partially cancel in the CFG delta. Keep it on Turbo at g = 0 (which is what the published edit LoRAs target anyway). This is an independent diffusers-side reimplementation of the published mechanism (mechanism credit: ostris / ai-toolkit), not a port.

Two high-res strategies

Krea 2's two checkpoints suit two different paths:

Turbo → fast 4k (no re-denoise). Turbo is distilled (8 steps, guidance 0) and resists partial re-denoise, but the 2× decode sidesteps that entirely:

Loader (Krea-2-Turbo) → Generate (2048², auto) → [Upscale VAE Loader] → Upscale Decode 2× → 4096²

Raw → controlled high-res (multi-stage). Raw keeps the full-CFG, resolution-aware trajectory that partial re-denoise needs:

Loader (Krea-2-Raw) → Multi-Stage Ultra (1024² → 2× → 2×) → 4k image  (+ optional Upscale Decode 2× → 8k-class)

Upscale VAE: modes & precedence

On the Multi-Stage Ultra node, upscale_vae_mode (requires upscale_vae connected) governs the S2→S3 jump and the final decode. Each transition can be a plain 2× VAE step (real resolution gain, 4× area) or a downsample variant that keeps the upscale decoder's sharp/GAN-trained detail but resamples down to your chosen size:

Mode	S2→S3	Final image
disabled	bislerp latent resize	decode_vae (or the base Qwen VAE if none connected)
s2-s3	upscale VAE 2× (4× area; ignores upscale_to_stage3)	decode_vae / base
s2-s3 with downsample	upscale VAE 2× → downsample to upscale_to_stage3	decode_vae / base
final decode	bislerp latent resize	upscale VAE 2×
final decode with downsample	bislerp latent resize	upscale VAE 2× → downsample to native
both	upscale VAE 2× (4× area)	upscale VAE 2×
both with downsample	upscale VAE 2× → downsample	upscale VAE 2× → downsample to native
both with final decode downsample	upscale VAE 2× (4× area)	upscale VAE 2× → downsample to native

Recommended: prefer the … with downsample variants. In practice the upscale VAE decoded at 2× then resampled down is cleaner and sharper than the Wan 2.1 VAE at the same output size - you get its detail without the literal 4× area blow-up (and without the re-encode softening compounding across stages). The plain s2-s3 / both modes force 4× area and ignore upscale_to_stage3, which is the usual cause of a run ballooning to 20 MP+; the downsample variants respect your numeric factor instead.

The old inter_stage / final_decode values still load (aliased to s2-s3 / final decode) so existing graphs keep working.

S1→S2 has its own switch. s1_s2_upscale_vae (a separate boolean) routes the first jump through the upscale VAE and forces 2× (4× area), overriding upscale_to_stage2. It's deliberately not in the dropdown - using the VAE that early is a specialist move (the re-encode softening gets refined away by S2/S3). Combining it with a both … mode is what cascades to enormous final sizes - watch the on-node resolution chain readout, which shows the real S1→S2→S3→decode sizes and flags every field the VAE is overriding.

decode_vae is ignored outright for the final image whenever the mode does a VAE final decode (final decode* or both*) - not blended, not overridden, simply not passed to that call at all. It still governs the stage preview images (preview_stages=True → stage1_image/stage2_image) regardless of what the final image uses, since previews always go through standard_decode(..., decode_vae=decode_vae) independent of upscale_vae_mode. So: want the upscale VAE for your final image but a specific grain/texture VAE for previews? Keep both connected - they don't conflict. Want the upscale VAE and don't care about previews? decode_vae can stay disconnected with no effect either way.

Two ways to get the downsample quality pass on the final decode. The mode's … final decode downsample variants request it per-run; the Upscale VAE Loader's own downsample_to_1x toggle bakes it into the loaded VAE for every consumer (including the standalone Upscale Decode node). Either enables the same thing - decode at 2× then Lanczos-downsample back to native, a supersampling-style pass rather than a literal resolution gain. blur_sigma=0 is a good default (Lanczos already anti-aliases); raise it only as a taste knob. Inter-stage (S2→S3) downsampling reads the mode flags, not the loader boolean.

Inter-stage renorm (upscale_renorm)

Latent interpolation is a lowpass: every upscale hop shrinks latent variance, and decoded variance is contrast/saturation - so multi-hop runs compound a little drain per hop into progressive flattening and desaturation. upscale_renorm repairs the statistics right after each hop:

• per_channel (recommended) - re-match each latent channel's mean/std to the pre-hop latent; strongest color + contrast hold.
• global - overall mean/std only.
• off - previous behavior.

A telemetry line prints latent std pre-hop / post-hop / post-renorm in every mode, so the drain (and the repair) is measurable per run.

Turbo guidance & the negative prompt

Turbo is distilled for guidance 0, so most wrappers give you no CFG - and therefore no negative prompt - on the Turbo checkpoint. Multi-Stage Ultra re-enables it. The turbo_guidance dropdown decides where classifier-free guidance (and the negative pass it needs) is allowed on a distilled model:

turbo_guidance	S1	S2	S3
off (default)	g = 0	g = 0	g = 0
s1_only	uses s1_cfg	forced g = 0	forced g = 0
all_stages	s1_cfg	s2_cfg	s3_cfg

• Guidance convention is Krea's g, where standard CFG = 1 + g (g=0 → CFG 1.0, g=0.2 → CFG 1.2). Turbo was distilled for g=0, so keep it low (~0.1-0.3); the node warns above g=1.5 (Raw-level, over-saturates Turbo).
• The negative prompt is only active on a stage whose g > 0. Under off it is inert.
• Each guided stage runs a second (uncond) pass, so it is ~2× slower for that stage - which is why s1_only exists: put guidance + negatives on the composition, then let S2/S3 refine fast and single-pass (it force-zeros s2_cfg/s3_cfg for you - you don't set them yourself).

Using a real negative prompt on a distilled/Turbo checkpoint at all is unusual - most Turbo pipelines simply can't feed one.

Parameter sweeps

A fine tune's preferred sampler, scheduler, step count, mu and cfg tolerance are all proxies for one variable - how far its training eroded the turbo distillation. The sweep system turns that from folklore into measurement: characterize a model in one queue item, keep the evidence, promote the winners to presets.

Wiring: Eric Krea2 Sweep Plan → Ultra V2's sweep input (last socket). The Ultra panel is the base recipe; each cell overrides only its swept keys. All existing machinery (LoRA stack, cond rebalance, ref latents, telemetry, renorm) runs untouched per cell.

Grid mode: fill any of the axis fields - samplers, schedulers (pair_lock zips them into fixed pairs), steps, windows (5-12 → start/end step), etas, noise_types, cfgs, shift_modes/mus, hybrid_steps, megapixels - blank = not swept (panel value used). The schedulers field takes built-in schedules AND saved sigma-shape ★ preset names mixed freely (each entry resolves as a schedule first, then as a sigmas preset applied as that cell's full profile; unknown names are skipped with a console warning, never an abort), and comes pre-populated with everything available - delete what you don't want. Full cross product, hard-refused over max_combos with an axis-size breakdown. Cells that differ only by inert knobs (eta/noise on euler/lcm) are deduped automatically.

Combos mode: one JSON object per line in combos_json, or a file via combos_file (JSON array, {"combos": [...]}, or JSON-lines) - keys are the same widget keys as presets and PNG recipes, so combos are copy-pasteable from any stamped image. Sweep campaigns become versionable files.

Workflow intent: quick_screen forces S1-only at screen_megapixels for cheap wide grids - perfect Stage 1 first, then sweep stage_scope=s2/s3 refinement on the short list. For s2/s3-only sweeps the post-S1 latent is computed once and reused across cells (s1_reused in the manifest; automatically disabled per cell for anything that changes Stage 1, and globally under seed_mode=same_all_stages).

Outputs (to output/sweeps/<timestamp>_<finetune>/, or output_folder):

• cell_NNN_<values>.png - every cell at full res with the complete resolved recipe (ultra + loader + lora sections) embedded in a krea2_settings chunk - each file is standalone-reproducible.
• contact_sheet.png - downscaled overview (tile_px tiles), captions show only the diffs vs base, green line = per-cell generation time + scores.
• sweep_summary.csv - one row per cell: swept columns, gen_time_s, rounded scores - sortable in any spreadsheet.
• sweep_manifest.json - full resolved recipes, timings, metrics, errors.

Scores (optional, CPU, milliseconds - failure detectors, not beauty judges): Laplacian + Tenengrad sharpness, wavelet noise sigma, flat-region chroma variance, clip fraction. All land in the CSV/manifest; sort_by pre-sorts the sheet; scores never hide a cell - the eye stays the judge.

Field calibration (two full 192-cell characterization runs, 2026-07-29): clip% is the best bad-image predictor - above 3-4% suspect, above 6% almost always bad (the sheet flags C4.2%! / C7.1%!! at exactly those absolute thresholds, and Auto Pick's gates use them). sharp_ten (Tenengrad) proved more trustworthy than Laplacian - it is the sharpness shown on the sheet and gated by Auto Pick - though neither is immune to one strong edge dominating; subject/tiled sharpness via the external scores.csv route is the real answer there. noise sigma and splotch showed no quality discrimination in the field - they remain CSV columns but gate nothing and no longer appear on the sheet.

Sheet captions are stage-grouped shorthand - one line per swept stage (s1: 2.5mp res_2m+beta57 h7 e0.3), ★profile / seed / prompt on a trailing line - plus a compact metric line: T88s S11.3k C0.5% N1.0 U159 (T time, S sharp_ten/1000, C clip% with the !/!! flags, N noise, U uniqueness).

Uniqueness (model-free, automatic): every cell gets a composition-uniqueness score - its mean distance from the other cells' 64x64 luma thumbnails, grouped per (prompt, S1 megapixels). READ THE DIRECTION BY EXPERIMENT TYPE: in a fixed-seed SETTINGS sweep, high uniqueness means "deviates from the consensus" and broken cells deviate hardest - the LOW end is the consensus render and the high end is an outlier list; in a SEED sweep, divergence is the point and high = more compositional variety. Auto Pick has an objective for each direction.

Promotion: Eric Krea2 Sweep → Preset reads a manifest cell into ultra_presets.json (swept keys only, or the full recipe), auto-tagged with the checkpoint name and an objective note - per-fine-tune preset libraries by construction.

LoRA, prompt & sigma-profile axes (sweep v2):

• LoRA bake-off (lora_mode=bakeoff) - one LoRA per line in lora_files (loras-folder names or full paths) x lora_strengths (one value drives all three stage weights). Default: each swept LoRA runs ALONE, so every style is measured against the bare checkpoint on equal footing; keep_panel_stack layers it on top of your declared stack instead. include_baseline adds the reference cell (no-LoRA, or the panel stack alone when layering). Sweep-injected entries are ephemeral - fused per cell, cleaned per cell, nothing persists.
• Strength ladder (lora_mode=strength_ladder) - keeps the panel-declared stack and steps only the lora_target entry (1-based index, or a name substring) through lora_strengths.
• Prompt axis - one prompt per line in prompts; each prompt cell re-encodes (conditioning cleared automatically, ~seconds/cell). Prompts expand as the SLOWEST axis, so the contact sheet and CSV read in prompt-major blocks - metric comparisons are only meaningful within a block.
• Sigma-profile axis - sigma_profiles takes saved ★ preset NAMES from the Eric Krea2 Sigmas node (validated at plan time); each cell rebuilds the full bundle from that preset, overriding any wired sigmas node for that cell.
• Trigger words (lora_triggers, default append) - each bake-off cell merges its swept LoRA''s trigger words (from the stack node''s cached trigger database) into that cell''s prompt, so trigger-dependent styles are measured fully activated. Only sweep-injected entries contribute; baseline and ladder cells are untouched; a changed prompt re-encodes automatically; the effective prompt + triggers land in the cell''s metadata.

All v2 axes cross with every classic axis, in grid mode AND on top of explicit combos, under the same cap and dedupe rules. LoRA/prompt/profile cells always run a full Stage 1 (S1-latent reuse correctly sits out). Each cell PNG records the ACTUAL stack, bundle, and prompt that cell ran - not the panel's - so every file stays a complete standalone recipe.

Failed cells never kill a sweep (red tile + manifest error), and interrupts finalize the files on disk before stopping the queue item.

Auto Pick: Eric Krea2 Sweep Auto Pick closes the loop from sweep to preset: manifest in, cell_index + a human-readable report out. Objectives: fastest_acceptable (fastest cell passing the field-calibrated gates: clip% ABSOLUTE - reject above 6%, flag 4-6% as suspect-but-passing; sharp_ten relative to the sweep median or an eye-picked reference_cell with tolerance slack; and a uniqueness consensus-outlier gate - cells far above the reference are rejected as deviants, with 2x tolerance so style variation passes), most_unique (highest composition-uniqueness - the SEED sweep objective; recomputed from cell PNGs for older manifests), most_typical (LOWEST uniqueness - the consensus render, the right pick in settings sweeps where high uniqueness flags broken outliers), best_metric (any built-in column), and best_external (any column of a scores.csv in the sweep folder, joined by filename - blank metric = first numeric column). Wire cell_index into Sweep -> Preset (convert its widget to an input) and one queue runs sweep -> pick -> promote. The picker proposes and explains its choice with runners-up; promotion only happens because you queued the preset node - metrics never silently write your preset library.

Folder scoring chain: the Eric Sweep Folder Scorer node (in the Eric-image-classification package) consumes the manifest path and grades every cell with the analyzer suite - Blur V7, Noise V4, composition, exposure, UniPercept (with a device picker for the second GPU) - and writes/merges scores.csv in the sweep folder, one column per numeric output (comp.composition_score, blur7.variance, ...). Merging is by filename, so multiple grading passes stack columns instead of clobbering. The full hands-off chain is: Ultra V2 sweep_manifest -> Krea2 Unload (frees the generator's VRAM; its wildcard passthrough keeps the ordering) -> Sweep Folder Scorer -> Auto Pick (best_external) -> Sweep -> Preset: one queue from characterization to a machine-proposed, human-ratified preset.

Sweep presets, the toggle & notes: the Sweep Plan node carries an enabled switch (off = the wired node is inert and normal generation runs) and a sweep_preset dropdown backed by sweep_presets.json. Selecting a preset WRITES its values into the panel - you always see exactly what will run - and editing any field flips the dropdown back to custom; the ★ Save Preset button saves the panel under a new name. Headless/API runs apply the named preset as the sole source. Both the Sweep Plan and Sigmas nodes carry a preset_notes field saved with each ★ preset - one sentence on what the preset is FOR - written into the panel on select and printed by headless runs, so preset libraries stay self-documenting.

Swept schedules vs a wired sigmas bundle: a cell that explicitly sweeps a stage's schedule disables the wired bundle for that stage, cell-locally - a swept axis is never silently inert (the bundle previously overrode swept schedules, which produced identical cells and only a warning). Unswept stages keep the bundle; sigma_profiles cells replace it entirely; each cell's PNG chunk records what actually applied.

Notes

• Raw vs Turbo: Raw is the undistilled base - train LoRAs on Raw, run on Turbo. Raw is the right choice for multi-stage re-denoise; Turbo for the fast decode path.
• Shared VAE: Krea 2 uses AutoencoderKLQwenImage (16-channel, f8), identical to Qwen-Image and Wan2.1 - which is why the spacepxl 2× decoder is a drop-in.
• Prompting: Krea 2 wants natural language (not JSON/tags). Long, dense visual/material/camera descriptions work best; quote words to render as text. For best expander fidelity, download Krea's expansion.txt and point the Magic Prompt node's system_prompt_path at it.

Credits & licenses

• Krea 2 by Krea AI - weights under the Krea 2 Community License. https://github.com/krea-ai/krea-2
• Upscale VAE: spacepxl/Wan2.1-VAE-upscale2x (Apache-2.0). https://huggingface.co/spacepxl/Wan2.1-VAE-upscale2x
• Samplers: the RES and DEIS solvers are independent re-implementations of the published algorithms - RES (arXiv:2308.02157) and DEIS (arXiv:2204.13902) - specialised to rectified flow. Sampler/schedule choices were informed by the RES4LYF community; no RES4LYF or k-diffusion code is imported.
• Vision Prompt: informed by ethanfel/ComfyUI-Krea2TextEncoder, which first identified that Krea2's Qwen3-VL text encoder can be vision-grounded and that the community pattern of reusing TextEncodeQwenImageEditPlus for this wastes a silently-discarded reference latent and uses the wrong prompt template. This is an independent implementation built directly against the installed diffusers/transformers source, not a port of that node's code.
• Reference Latents (edit): the "index_timestep_zero" reference method is credited to ostris / ai-toolkit (the Krea2 edit-LoRA training recipe) and ostris/ComfyUI-Krea2-Ostris-Edit for the ComfyUI-core implementation. This is an independent diffusers-side reimplementation verified line-by-line against the installed transformer_krea2.py, not a port.
• Nodes: Eric Hiss (GitHub: EricRollei).

These nodes are an independent implementation; no code is copied from Krea or spacepxl repos.