Replace the age-portrait audit sheet with a rendered three-frame hero: a
custom "golden-hour light" slider grading the same coastal photograph from
cool overcast (-3) through the untouched prompt (0) to warm golden hour
(+6), on one prompt and seed with the composition held. More photographic
and clearer than the old hero, and it doubles as a custom-poles example.
Documentation asset only - docs/ is excluded from registry packages.
The node documentation index promised a page for every registered node,
but the two Concept Slider nodes had none. Add their reference pages
(inputs, outputs, dial band, study reuse) in the same house format as
the V9/V10 node pages, and list them in the node index and the docs
landing page. Documentation only - docs/ is excluded from registry
packages, so the installed package is unchanged.
The README now presents the package as two instruments - reference
conditioning (the V9/V10 guide cards) and Concept Sliders - with a
dedicated "What Concept Sliders Add" section parallel to "What V10
Adds", a Repository Structure section showing the three product
packages side by side, and slider entries in the goal table, the
workflow-thinking section, the documentation table, and the
development checks. The docs landing page gains the slider guide and
the recipe visual guide in its paths, core guides, and demo assets.
One figure per recipe - reference image, prompt-alone baseline, and
with-card result side by side - for all twelve built-in quick recipes
and all twenty bundled pack recipes, each rendered at its documented
starting strength on a real reference under identical settings. The
figures carry honest usage notes (color-safe strengths for pose and
framing, single-mass references for big shapes, full-bleed artwork for
the style family). Linked from the documentation index and the V10
user guide.
Two new nodes: a Concept Slider Card names an attribute (with optional
custom pole sentences) and a Concept Slider Stack derives the
more-vs-less axis from Krea 2's own text encoder at encode time.
-6..+6 dial, up to 8 sliders, a slider report output, and a study
cache; a slider at 0 is skipped entirely and a cardless stack matches
CLIP Text Encode exactly. Ships with the complete guide, the ten-slider
render audit sheets, a showcase workflow with a with-vs-without
comparison branch, contract tests, and a maintainer smoke test.
Fifteen new bundled recipes, all render-validated under the stack's
default smart per-card timing: a ten-recipe designer artwork pack
(poster style, soft media, pattern energy, era print look, paper and
canvas, metallic accents, ornament borders, stained glass, and the
style-timing pair) and a five-recipe edit-and-composite pack (scene
light, monochrome look, atmosphere, background only, carry the subject
over). Recipe Kit README gains the smart-timing tuning rule (early is
the structure-phase volume; motif-scale borrows need early ~0.85), the
Builder reserves the new labels, and the docs list the full bundled
roster. V9 untouched.
Removes every stale claim left from the pre-retune era. The Recipe Builder's intent bases now mirror the shipped bundles (they still emitted palette-wash style/lighting/material and the even shapes table); intents whose built-in table differs from the role default always write layers, the style and lighting intents carry their shipped focus texts as defaults, and the reserved-label list includes the two newer starter recipes - all builder outputs re-verified through the real recipe loader. The remaining 0.2.1-era demo images (timing and direction journeys, material demo, showcases, gallery sheet) are re-rendered through the live nodes. README strength guidance moves to the render-calibrated bands; the V10 card page documents the four V10-only recipe overrides instead of claiming V9-identical behavior; user guides, testing checklist, docs index, and the Recipe Kit README are synced (five starter recipes, built-in focuses, strong-blur taming pattern).
The style, lighting, and big-shapes demo images (plus the gallery sheet) now show what the current tuning actually produces - the lighting demo in particular changes from a brown recolor of the sphere to a real scene-wide mood cast. Rendered through the deployed nodes with the bundled example assets, same prompts and seeds as before.
Render-audited every V10 recipe on fresh public-domain and self-generated references. Three fixes ship: copy lighting and mood moves from palette wash (which flattened dramatic skies into flat location tones) to strong blur with a de-place focus, so storm mood lands at 0.65 and full drama by 0.9; copy big shapes only gets a structure-only layer table (structure x1.3, appearance x0.25) because the even table let the gray shape-wash study drain the result to monochrome; borrow photo finish was near-silent at its documented strengths and moves to shape 0.8 with finish x1.2 and cap 0.65, landing the photographic grade from ~0.55. borrow drawing medium keeps its deliberately quiet values with an honest description - every louder variant imported the drawing's subject (render-proven ceiling). All changes V10-only; V9 untouched.
The style recipe's strong-blur prep is its structure-safety guarantee, but the encoder was also studying the blur itself - on soft-medium references renders came out pervasively soft. The built-in style bundle now ships a focus that de-selects softness and scene layout; prep and pulls are unchanged. A/B render-verified across five references, two strengths, three seeds, single-card and in the two-card method. Crisper prep alternatives re-opened source-scene takeover and were rejected.
The shipped V9 demos predated both the appearance-recipe retune and the
bilinear palette wash, so the guide undersold what a current install
produces. All nine demos (and the README's front-page gallery) are
re-rendered through the live V9 nodes on their original seeds via the new
docs/recipe-lab/regenerate_v9_demos.py, which drives each render from its
shipped sidecar workflow so the drag-in values are exactly what rendered.
Two demos changed values, render-compared on identical seeds: the
manual-tuning card now keeps 'Shape copied' alive (0.8) under the palette
wash instead of leaning on the inert 'Overall style reach', and the style
demo runs at 0.50 where the borrowed palette lands on a crisp subject
(0.65 softened it). Guide prose and the stale 'demos predate the retune'
note are updated to match.
The registry validator's security lint flags E702 (multiple statements per
line) as a warning today and an error soon; expand them now so future
publishes stay clean. Pure reformatting - no behavior change.
The nearest->bilinear wash fix (5f61727) changes what palette-wash recipes
render, so every wash-affected demo is re-rendered through the live V10
nodes on the same seeds: the palette sphere is now a smooth gradient, the
toward-lamp an organic rose/sage piece, the final-only timing lamp a clean
two-tone split. Guide prose that described the old mosaic aesthetic is
reworded to describe the new renders, the V10 paper's treatment row and the
V9 paper's wash pseudocode now document the bilinear upsample (with a note
on why nearest was wrong), and the focus-validation reference images join
the recipe-lab refs.
Full V10 documentation audit pass:
- README: What V10 Adds now covers focus, the auto-loaded starter recipes,
and the Recipe Builder; workflow table lists the new example.
- New example workflow krea-v10-starter-recipe-workflow.json: cinematic
color grade (from the shipped starter pack) grading the scene from the
bundled style reference - configuration render-validated on the live node.
- V10 user guide: 'Focus: recipes that study one aspect' section with the
render-verified select/de-select evidence and limits; What V10 Adds rows;
focus troubleshooting entry (MD + HTML, incl. the What-V10-Adds grid).
- V10 documentation index refreshed: Recipe Kit + Builder + standalone tech
reference in Start Here, the full twenty-demo journey list (away render
and balance pair included - no more 'pending' notes), starter-recipe
workflow, maintainer touchpoints incl. the builder and recipe-lab.
- Stack encoder node page: deep-dive points at the standalone V10 technical
reference; report bullet mentions the focus line.
- Testing guide: V10 smoke checklist covers starter recipes, focus report
lines, and the Builder; demo-renders section describes the current
twenty-journey set and its regenerator script.
All 7 example workflows parse; 57/57 tests; doc links verified.
custom_recipes/README.md is now the Recipe Kit hub: Builder, auto-loaded
starter pack, template, schema + focus guide, and technical reference in one
index, with a dedicated focus section carrying the render-verified guidance
(selection works, de-selection is powerful, broad moods ride the image).
docs/krea-v10-technical-paper.md rewritten as a self-contained reference
covering every V10-exposed feature with no V9-paper dependency: both nodes'
full widget surfaces, the conditioning math (12 taps, mute-and-diff,
per-band compose, inert pooled channel), the strength model, the exact
image-prep pipeline, the prompt machinery incl. the multilingual guard and
focus lines, the complete retuned recipe tables, custom recipes + starter
pack + Builder, the study cache, both feedback outputs, V9 interop, frozen
surfaces, verification methodology, and a worked example.
Guides, node page, and CHANGELOG updated for focus + starter pack.
57/57 tests; doc links verified.
web/recipe-builder.html - single-page, dependency-free, ships with the pack
and is served by ComfyUI at /extensions/<pack folder>/recipe-builder.html.
Twelve artist-worded jobs map onto the render-validated recipe bundles; a
Whisper/Clear/Bold loudness scales the tuning inside its calibrated band;
optional fine-tuning exposes subject policy, the structure/finish emphasis
dials (same math as the card's manual layer dials), and a strength ceiling.
Each job states honestly what it cannot do; output previews YAML/JSON with
download/copy, install steps, the two-minute render check, and live
reserved-name rejection.
Verified: all 41 intent x loudness x fine-tune outputs (x2 formats) from the
shipped logic block validate through the real kg_krea_v10 recipe loader;
label guards reject built-in collisions; a builder-generated 'Bold style'
recipe was dropped onto the render box and rendered through the live node
(clear palette borrow, subject kept). 51/51 tests pass.
Re-render the full V10 demo set through the real V10 nodes with the retuned
recipes: a new twelve-recipe gallery (labeled contact sheet; the appearance
demos share one prompt/seed for direct comparison) plus the journeys,
including the two that waited on a V10 render box - the away-direction step
and a balance off/gentle showcase pair. Every PNG embeds the exact V10
workflow that rendered it (new maintainer script
docs/recipe-lab/generate_guide_demos.py).
Rewrite the recipe-authoring docs around the render-verified control model:
treatment decides WHAT can transfer, shape is the volume knob (with
calibrated anchor bands), layers is second-order fine-tuning (landing math +
validated worked example), global is inert on Krea 2 - plus a two-minute
render-validation protocol. Retune the shipped template (it was itself a
dead recipe at shape 0.3), fix the V9/V10 technical papers' tables and
worked example, the node pages, and the V9 guide's manual-dial advice
(raising Overall style reach does nothing on Krea 2) and strength bands.
51/51 tests pass; template validates through the real loader; all
guide-referenced demo files verified present with embedded workflows.
A reusable loop for iterating recipe settings against the real Krea 2 model:
- tweak_test.py: render engine - given a recipe (built-in label or a full
tweak bundle) + reference + prompt + strength + seed, renders on the ComfyUI
box and prints {name,image,metrics}. Pure mechanical work.
- recipe-tweak-test.workflow.js: orchestration - cheap Haiku agents render each
variant in parallel, then a Fable agent reads the images and scores each
against the recipe's stated intent, names the best, and recommends a change.
(cheapest tier does the manual work; the judge determines success.)
Demonstrated end-to-end: the judge correctly found that the style and palette
recipes barely transfer anything at their default strengths (a plain white
bowl even at 0.9), and that the model-aligned layer table made no visible
difference - confirming the layers are second-order and the real levers are
strength/treatment/shape. README documents the loop. Maintainer tooling under
docs/ (excluded from registry packs).
Researched how Krea 2's 12-layer text conditioning is designed, from
authoritative sources, so the tables can be improved against the real design:
- Krea 2 Technical Report: the 12 taps are a learned "shallow attention layer
that aggregates hidden features across layers" for "coarse-to-fine text
representations," explicitly inspired by UniFusion.
- UniFusion (the method): Layerwise Attention Pooling over "every third layer"
(matches hidden_states[2,5,8,...,35]); empirically favors EARLY-TO-MIDDLE
layers, with the penultimate contributing LEAST.
- This is misaligned with the shipped tables, which spike the deep taps:
the table's biggest spike (tap 8/layer 26) is only the model's #5, it
suppresses tap 4/layer 14 (the model's #3 and a UniFusion-favored layer),
and over-weights tap 11/layer 35 (penultimate, ranked nearly last). The
model's own learned projector (Stage 0) corroborates.
README section 3.5 adds the sourced design basis and three improvement
directions (track the learned weighting, differentiate recipes along the
coarse-to-fine axis, and add per-tap magnitude normalization so early-layer
gains actually bite). Full research + per-tap comparison in local_records.
Ran a render-based derivation for the style role on the model: held the real
style settings fixed, varied only the 12 layers across seven candidates,
rendered and scored look-transfer minus subject-leak.
- The shipped STYLE table scored best (objective 0.106); the shallow-tap table
was worst - render evidence supports spiking the effective deep taps.
- But differences were small and every output was nearly the same bowl: at
realistic style settings the layer table is a second-order knob. The primary
look-vs-subject control is strength and the shape/global split.
Bottom line committed to the README: the reliable way to set the layers is
render-based measurement (conditioning analysis alone misleads); applying it
shows the shipped tables are directionally right and, for the style role,
near-optimal. The durable deliverable is the render harness, which can
re-derive or verify the layers for any future checkpoint. Full result + images
in local_records.
Ran the decisive test on the model: isolate specific taps (shape=1, global=0),
render, measure. Result flipped the conditioning-level read:
- Mechanism confirmed live (feature width 30720 = 12x2560, split engages).
- Clean-stimuli Stage 1 does show proportional selectivity (shallow taps lean
palette, middle lean texture) - but render validation shows it is
practically irrelevant: the deep taps' large magnitude dominates the pixel
effect. Spiking taps 7/8/10 reproduced the reference entirely; spiking the
shallow taps did nothing.
- So the shipped tables spiking 7/8/10 target the effective (high-leverage)
taps, which the model's projector also emphasizes; the effective taps move
palette+texture+subject together and do not cleanly separate.
The load-bearing lesson for reliable derivation: conditioning-level analysis
misleads because magnitude and the nonlinear diffusion path dominate - the
layers can only be derived reliably from renders. README Stage 1/2 updated;
full arc + validation images in local_records.
Installed V10 + the probe node on the render box, generated a controlled
reference set, and ran the encode-only selectivity harness on the real Krea 2
model. First actual measurement of the 12 text-layer taps:
- Mechanism confirmed live: probe reports feature width 30720 (= 12 x 2560),
divisible by 12, so the tap split engages on the model (no fallback). Tap
magnitude rises with depth.
- No strong per-tap specialization: after removing the depth-magnitude
confound, every tap carries essentially the same attribute mix (palette
0.20 / structure 0.33 / texture 0.35 / lighting 0.12; cross-tap std-dev
~0.01). Taps differ by overall magnitude (depth), not by which attribute
they encode - only a faint depth gradient in the design direction, far too
weak to justify the tables' 5x spikes. The "tap 8 = palette" premise is not
supported.
Caveats recorded honestly (seq-mean signature, weak palette axis from a
near-neutral base, single scene). README Stage 1 updated with the result;
raw signatures + full write-up in local_records. Also fixes the probe graph
generator to supply the V10 card's full widget set (API validation).
Replaces "borrow a template + eyeball renders" with a staged pipeline for
setting the 12 layer-gain values, cheapest/most-targeted first:
- Stage 0 (done, local): extract_model_prior.py reads Krea 2's own learned
per-tap weighting (txtfusion.projector [1,12]) from the checkpoint;
compare_to_model_prior.py scores each shipped table against it. Finding:
the model leans hardest on taps 7>9>4>10>8 but the tables spike 8>10>7
(rank-corr only +0.58..+0.64) - the borrowed template does not track how
the model uses the taps. model_prior.json records the values.
- Stage 1 (harness ready, no render): probe_node/ is a tiny ComfyUI node
that saves per-tap conditioning signatures; probe_selectivity.py does a
variance decomposition (eta^2) of each tap against palette/structure/
texture/lighting over a controlled reference set; generate_probe_graphs.py
builds the encode-only graphs. The selectivity math passes a synthetic
self-test (recovers an injected tap->attribute map exactly). Running it for
real needs V10 + the probe node installed on a box, plus controlled image
sets - it renders nothing (text-encoder passes only).
- Stages 2-3 (documented, need a V10 box): metric-scored render validation,
then black-box optimization of the 12-gain vector against a stated
objective, held-out validated.
README section 4 rewritten as the methodology. All scripts run/validate
locally; tooling stays under docs/ (excluded from registry packs).
Traced the real provenance (Kevin's Codex dev sessions) and verified the
mechanism against the Krea 2 model on the render box. Two earlier claims
(07d2f0b) were wrong and are now fixed across the docs:
1. Mechanism: the 12 "deepstack chunks" are the 12 TEXT-encoder layer taps
Krea 2 conditions on (comfy/text_encoders/krea2.py: hidden_states
[2,5,8,...,35], (B,12,seq,2560) flattened to 30720), NOT the 3 vision
deepstack taps (qwen3vl.py deepstack_visual_indexes=[5,11,17]) the name
implies. 30720 % 12 == 0, so the node's split lands on the taps and the
per-layer gains do apply (no fallback) - confirmed from the model weights
(txtfusion.projector [1,12], layerwise blocks at 2560).
2. Provenance: the 12 values were NOT derived by a per-chunk sweep. They
were adopted from the third-party ComfyUI-ConditioningKrea2Rebalance node
(DEFAULT_WEIGHTS spike 8>10>7, matching STYLE_LAYER_PULL) plus the
shallow=structure/deep=appearance principle; only the scalar shape (0.45
->0.35) and cap (->0.9) were empirically tuned. The four role tables are
scalings of one template, so their agreement is design self-consistency,
not independent measurement - the "convergent evidence" framing is
withdrawn.
docs/deepstack-layers/ rewritten to separate verified mechanism, traced
provenance, and the still-unrun single-tap sweep. Corrections propagated to
the V9 technical paper (5.2 + architecture note + glossary), the V10 guide
and companion, custom_recipes/README, the V10 node doc, and CHANGELOG. Full
evidence chain preserved in local_records (gitignored).
SaveImage prefix now targets output/claude-generations/krea-deepstack-sweep/
on the render box, per Kevin's instruction that generated images go to a
dedicated folder and nothing else is opened. The tool only downloads back
the images it just generated.
New docs/deepstack-layers/ is the authoritative, reproducible account of
the 12 layers values, at three separated confidence levels:
1. Structure (verified from code): the values are gains on 12 equal
deepstack chunks - features from 12 successive Qwen3-VL encoder-depth
bands. Shown in kg_krea_v9/clip_hooks.py (the deepstack feature list)
and conditioning.py (the 12-way width split).
2. Semantics (convergent evidence): analyze_tables.py reads the live
tables and shows the four independently-tuned appearance tables
(style/palette/material/lighting) agree chunk-for-chunk - 0-4 carry
structure (monotonic depth ramp, all suppress), 5-6 transition, 7/8/10
carry appearance (all spike, chunk 8 strongest, then 10, then 7). Four
tables tuned for four different jobs converging is the measurement
encoded as data, not an assertion.
3. Precise response curve (fresh measurement): generate_sweep.py is a
turnkey single-chunk-spike sweep (the paper's section 16.4 method),
emitting each spike as a V10 custom recipe validated against the real
node code. Dry-run works anywhere; rendering needs the V10 nodes on a
ComfyUI box (single-chunk tables are not V9-expressible), so the
measured-verdict table is staged pending a V10-equipped render box.
SCORING.md defines the rubric.
Cross-linked from technical paper 5.2, the recipe guide, and
custom_recipes/README. Tooling lives under docs/ (excluded from registry
packs by .comfyignore). sweep_out/ is gitignored.
custom_recipes/README.md gains a full "Deriving The layers Array"
section: the 12-chunk map from the V9 empirical sweeps (0-4 structure,
5-6 transition, finish response at 8 > 10 > 7), the five built-in
family tables verbatim as starting points, the landing math
(clamp(strength x shape x gain, +/-6) on the token channel, with the
shape trade-off and the global/pooled independence spelled out), a
four-step derivation procedure, a copy-paste helper using the same
scaling as the card's manual Structure/Finish dials, and a worked
example. Both V10 user guides teach the condensed version and link the
full section; the technical paper's section 16.4 sweep methodology is
cross-referenced for re-deriving tables on new checkpoints.
Ten ComfyUI-rendered demos under docs/assets/krea-v10/demos/: the four
new recipes (with a prompt-only before/after pair for the deliberately
gentle palette recipe), the per-card timing pair (early layout only vs
final details only - same card, same seed, two very different
pictures), the direction journey (prompt-only baseline vs style pulled
toward, the contribution an away card negates), and the six-card full
showcase. recipe-gallery.png contact sheet and guide-demo-manifest.json
(model, prompt, seed, strengths, lesson per demo) included.
Every result PNG embeds the matching V10 workflow for drag-in
inspection. Renders were produced on the LAN Krea 2 ComfyUI through
mathematically identical V9 graphs (built-in recipes where shared,
manual mode with dial values equal to the V10 bundles elsewhere), as
recorded in the manifest's engine_note; the away-direction and
balance-comparison renders require V10 on the render box and are
tracked as pending in the manifest and testing guide.
Both V10 guides now show every step of each journey - input images,
recipe and settings, exact prompt, and result - with a shared
house-settings table, and the V9 Markdown guide gained demo prompt and
seed rows on all nine recipe cards. Landing pages, the V10 index,
README, and CHANGELOG link the new gallery.
Schema-validated YAML/JSON files become first-class "Use image for"
choices, loaded from custom_recipes/ in the pack and from
<ComfyUI user dir>/krea_reference/recipes/ (survives pack updates).
INPUT_TYPES re-scans per call, so node-definition refresh picks up new
files without a restart.
Validation (kg_krea_v10/custom_recipes.py) is strict about keys - an
unknown key rejects the recipe so typos cannot become silent no-ops -
and forgiving about omissions: only label and role are required, with
every other field defaulting from the role's tuning tables. Reserved
labels cover both the purpose labels and the internal recipe keys, so
custom labels cannot shadow built-ins in either direction. Invalid
files are skipped with logged reasons and the node always loads; a
saved workflow whose recipe file was removed falls back to balanced
with a once-per-label warning instead of silently reading manual rows.
Custom recipes compose with direction, timing, and the guard clamp;
packets carry custom_recipe and custom_recipe_source. Ships with
custom_recipes/README.md plus a disabled template, a full teaching
section in both V10 user guides, node-doc and technical-companion
coverage, and nine new contract tests (51 total).
Example workflows (generated from the real V10 INPUT_TYPES so widget
order and combo values cannot drift from the node contract):
- krea-v10-full-showcase-workflow.json: six cards including the new
palette, environment, and framing recipes, per-card timing, gentle
balance, and the report/prepared-references previews wired.
- krea-v10-counter-example-workflow.json: toward content anchor plus an
away style counter-example.
- krea-v10-reference-stack-workflow.json: compact starter mirroring the
V9 starter graph.
Documentation mirroring the V9 set:
- docs/krea-v10-user-guide.md and .html (visual guide, same styling as
the V9 HTML guide).
- docs/krea-v10-technical-paper.md: companion paper for the V10
mechanics (direction math, timing rewrite, balance budget, study
cache correctness, feedback outputs, packet cross-compatibility,
verification map, limitations, extension points).
- docs/krea-v10-documentation-index.md and V10 rows across the docs
landing page, node index, workflow README, and root README.
- docs/testing.md: V10 smoke checklist and the demo-render release step
(V10 demo PNGs land under docs/assets/krea-v10/demos/ at release).
New kg_krea_v10 package with KG Krea 2 Image Guide Card V10 and
KG Krea 2 Reference Stack Encoder V10. V9 is untouched; packets stay
V9-compatible and the two versions cross-connect via the shared
KG_KREA_REFERENCE link type.
Card: quick recipes for the four previously manual-only roles (palette,
environment, framing, mood board), guide direction (counter-example
guidance via negative delta targets with symmetric layer clamping),
per-card timing, and manual structure/finish layer dials.
Stack: balance budget for hot multi-card stacks, content-keyed study
cache that makes strength/timing tweaks compose-only, a plain-language
stack report output, and a prepared-reference contact sheet output.
The full guard's prompt rewriter gains an ES/FR/DE/PT/IT starter
vocabulary.
Web extension covers the V10 nodes; tests/test_krea_v10.py pins the
V10 label surface, packet compatibility, direction/timing/balance
math, cache behavior, and the multilingual guard.
Krea 2 V9 reference-conditioning nodes: guide cards assign each
reference image a role (identity, style, lighting, composition,
text/logo safe, and more) and the stack encoder builds Krea
conditioning with per-card strength, per-layer gains, and guarded
prompt handling. Includes the kg_krea_v9 package, web extension,
example workflows and assets, contract tests, and full documentation
with the technical paper.
Prior development history is summarized in CHANGELOG.md (0.1.0-0.1.5).
Kevin Gilper