FLUX 3 Klein Image Creator V1.1.2 Handbook

SoulCraft · Image Creator · FLUX 3 Klein. Make a picture from a few plain words, or change one you already have, on FLUX 3 Image Klein (Black Forest Labs, 2026-10-13). For a RunPod pod running ComfyUI on an NVIDIA B200, else a B300. Three links open it: App (the SoulCraft app), ComfyUI (the workflow) and Terminal. SFW only, with no switch: four safety checks run on every picture, and nothing turns them off.

file	role	goes on the pod
`SoulCraft Image Creator (FLUX 3 Klein).json`	the workflow; opens in App Mode	yes
`image-creator-flux-3-klein-script.sh`	the thin installer on ComfyUI Base: 1 pack, the safety and app packs, 7 model rows, the app, the links	yes
`models.py`	the model library: every file name, once; the installer’s MODELS rows are generated from it	yes
`klein3_install.py`	writes `NO-PHOTO.png`, the picture an empty photo field holds	yes
`ComfyUI-Content-Gate/`	the safety checks (vendored node pack, Generate-AI, MIT)	yes
`ComfyUI-App-Front/`	serves the app from ComfyUI itself (vendored node pack 1.7.0, Generate-AI, MIT)	yes
`app/`	the app: the page, its manifest, `bindings.json` and the exported API prompt `prompts/klein.api.json`, its font	yes, into ComfyUI’s user folder
`suite.py` + `pytest.ini`	the acceptance suite, 8 tiers, run by `... test`	yes
`image-creator-flux-3-klein-handbook.md`	this	yes
`image-creator-flux-3-klein-runpod.zip`	the pod files, bundled by ComfyUI Base’s `_build/package.py`	uploaded, then extracted
`_build/build_workflow.py`, `graph.py`, `appmode.py`	generate the workflow and its App Mode form: the JSON is an artefact	no
`_build/export_app.py`	writes `app/bindings.json` and `app/prompts/klein.api.json` from the workflow, through the real frontend	no
`_build/templates/`, `object_info.json`	Comfy-Org’s two distilled templates, BFL’s upsampler prompts, the cached node schemas	no

0. Read this first

What it does

The same fields in the App and in the workflow’s App Mode form, and two results:

field	what it is
Prompt	what you want, in plain words
Photo 1 to Photo 10	optional; any photo turns the run into an edit, and the first one sets the shape on Auto
Shape	`auto` (the first photo’s shape, square without one), `1:1`, `4:5`, `3:4`, `2:3`, `9:16`, `16:9`, `3:2`, `4:3`, `5:4`
Size	`1k`, `2k` or `4k`: about 1, 4 or 16 megapixels
Layout boxes	optional; boxes you draw in the App’s Layout view, each with what goes there (a JSON list in ComfyUI)
Seed	same seed, same picture; empty in the App means a new one each time
Upscale	off by default; on makes the picture larger and sharper (slower)

The results: 💾 Picture, saved in output/Klein3/ and named by the date, and ✍️ Full prompt, the long prompt the model actually read (the App shows it behind the info icon).

① Create. No photo: your words go to BFL’s prompt upsampler with the canvas shape, the upsampler writes a full prompt of about 200 words, and FLUX 3 Klein draws it at the Shape and Size you chose.
② Edit. One to ten photos: the upsampler looks at the photos in order and writes an edit instruction; the model takes every photo as a reference. Shape and Size hold here too (Auto follows Photo 1).
Layout. With boxes, the upsampler gets BFL’s layout prompts and places each box’s words where you drew it. The box words are checked with your prompt, as one text.
Upscale. SeedVR2 7B, after the picture is made. Off, its models never load.
🛡 The four checks (§3): your words, your photos, the full prompt, the picture. A stop says which check, what it found and what to change.

There is no mode field and no quality tier: the photos and the boxes decide the flow, and the engine runs BFL’s own settings.

Quick start

# from the Mac: upload, extract, --check, run, poll, fetch the logs (podctl, ComfyUI Base)
uv run "$COMFY_BASE/_build/pod/podctl.py" install <pod> --base --pkg "image-creator-flux-3-klein"

# by hand on the pod
cd /workspace/packages
python3 -m zipfile -e "comfyui-base-runpod.zip" . && bash "comfyui-base/comfyui-base-script.sh"   # step one, once per pod
mkdir -p image-creator-flux-3-klein && python3 -m zipfile -e "image-creator-flux-3-klein-runpod.zip" image-creator-flux-3-klein

bash "image-creator-flux-3-klein/image-creator-flux-3-klein-script.sh" --check          # look first, changes nothing
HF_TOKEN=hf_... bash "image-creator-flux-3-klein/image-creator-flux-3-klein-script.sh"   # install

Then open the App link (§1): type, add photos if you like, Create. Or open the ComfyUI link, hard-refresh the browser, Workflows, SoulCraft Image Creator (FLUX 3 Klein).json: it opens in App Mode; type a prompt, press Run.

Requires ComfyUI Base 3.14.0 or newer (the per-pod key on the links), ComfyUI 0.41.0 or newer (FLUX 3 Klein is native there: Comfy-Org/ComfyUI#17064) and NVIDIA driver 580 or newer. All three are hard gates: the run stops before anything downloads.

1. Deploy on RunPod

GPU. An NVIDIA B200 (180 GB) first, else a B300 (288 GB): the script’s GPU_PREFER="B200 B300". Any other GPU is a warning at install, never a stop. The engine is nvfp4 (FP4, native on these Blackwell cards), the text encoder bf16 and the upsampler int8: about 24 GB of weights together, so a B200 holds them all with room to spare.

VRAM. 21 GB minimum (estimated, ComfyUI swapping models between stages), 37 GB comfortable (everything resident); the nvfp4 engine needs a Blackwell GPU (BFL’s model card).

The token and the gate. Three files (the engine, the upsampler and the VAE) come from black-forest-labs/flux-3-image-klein-comfy, which is gated (approved at once):

Sign in to Hugging Face with the account your token belongs to.
Open https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy and accept the FLUX Kommunity License (§5).
Make a read token and run the script with HF_TOKEN=hf_... in front (or let it ask; it is kept in the base’s state/tokens.env, mode 600, and never asked again).

Before any download the script asks the Hub, once, whether the token can read that repository. Without a token, or with a token whose account has not accepted the licence, it stops and names the page above. The token is handed to curl on its standard input, never on a command line.

Downloads: about 50 GB on a fresh pod. A pod that already ran Krea 2 Image Creator or the Video Replacer reuses their text encoder, SeedVR2 and safety model (same rows, same places), and downloads only the three gated files (about 15 GB).

What the install also does: writes NO-PHOTO.png into ComfyUI’s input/, mirrors the safety pack and App Front into custom_nodes/, copies app/ to ComfyUI/user/default/apps/flux-3-klein/ and names port 8190 App, adds --disable-dynamic-vram to ComfyUI’s arguments (the upsampler generates on a text-encoder model, and Krea 2 measured dynamic VRAM stalling exactly that at token 20 with the GPU idle), and proves that transformers carries Qwen3-VL, which the safety checks load. bash "image-creator-flux-3-klein-script.sh" app copies app/ again (live on the next page load, no restart).

The three links

link	address	opens
App	`https://<pod>-8190.proxy.runpod.net/`	the SoulCraft app: Describe or Layout, photos, Shape, Size, Create
ComfyUI	`https://<pod>-8188.proxy.runpod.net/`	ComfyUI; the workflow opens in App Mode, the graph is one click away
Terminal	`https://<pod>-8888.proxy.runpod.net/lab`	JupyterLab with a terminal on the pod

The key. Every link but the terminal’s is locked with the pod’s own key (ComfyUI Base 3.14.0). Open App and ComfyUI once with ?token=<key> at the end: the pod swaps the key for a cookie in that browser and drops it from the address bar, and from then on the plain links (and RunPod’s Connect tab) open in that browser without it. Without the key or the cookie a link answers 401. The Terminal link takes Jupyter’s own token (/lab?token=<token>).

At the end of the install the script prints the three links by name. The copy in the install log carries no key (the log is a file on the pod’s volume); the links with the keys are printed on the terminal only, and podctl status <pod> shows them again. An App link with its key opens the app for anyone: share it like a password.

2. Models

Every file name lives once, in models.py; the loaders in the workflow and the script’s MODELS rows are generated from it, and the suite fails if either drifts. Every Hub row is pinned to a commit.

file	where (`ComfyUI/models/`)	size	licence	from
`flux3_image_klein_sd_nvfp4.safetensors`	`diffusion_models/Flux.3/`	5.28 GB	FLUX Kommunity License	BFL’s ComfyUI repackage (gated)
`qwen3vl_4b_bf16.safetensors`	`text_encoders/Krea2/Qwen3VL/`	8.88 GB	Apache-2.0	Comfy-Org/Qwen3-VL (Krea 2’s row)
`qwen3.5_9b_flux3_prompt_upsampler_int8_convrot.safetensors`	`text_encoders/Qwen/`	9.75 GB	Apache-2.0	BFL’s ComfyUI repackage (gated)
`flux2-vae.safetensors`	`vae/Flux.2/`	0.34 GB	Apache-2.0	BFL’s ComfyUI repackage (gated)
`seedvr2_ema_7b_fp16.safetensors`	`SEEDVR2/`	16.48 GB	Apache-2.0	numz/SeedVR2_comfyUI (Krea 2’s row)
`ema_vae_fp16.safetensors`	`SEEDVR2/`	0.50 GB	Apache-2.0	numz/SeedVR2_comfyUI (Krea 2’s row)
`Qwen3-VL-4B-Instruct/` (snapshot)	`LLM/Qwen-VL/`	8.89 GB	Apache-2.0	Qwen/Qwen3-VL-4B-Instruct (the Video Replacer’s row)

The engine is the step-distilled Klein, the checkpoint behind BFL’s API: 16 steps, euler / simple, CFG 1 (the flow map reads its target time from the sigma schedule). It ships as nvfp4, native FP4 on Blackwell (sm 10.0 and newer), with the bf16 file (11.10 GB) kept as the fallback: one switch in models.py (ENGINE), then a rebuild. Not shipped, on purpose: Klein Base (50 steps, for LoRA training), its unsuffixed copy, and the int8 engine.
The text encoder is Krea 2’s own row. BFL’s copy has the same name and 24 more bytes; the base allows one place per file name across every package, so both packages load the one file (CLIPLoader type flux3).
The prompt upsampler is mandatory: BFL says the model must not run without it, because Klein is trained on its captions. Core’s TextGenerate runs it (CLIPLoader type flux3) with BFL’s settings: at most 3584 new tokens, presence penalty 1.5 for ① Create and 0 for ② Edit, BFL’s own system prompts (with their layout versions when there are boxes), and the run’s seed. It does not refuse anything, which is why the words and the caption are both checked.
Packs: one, ComfyUI-SeedVR2_VideoUpscaler (numz, Apache-2.0) at Krea 2’s tested commit, for the optional upscale. Everything else is core ComfyUI. The safety pack and App Front are vendored. The base brings its shared packs.

3. The safety checks (always on)

SoulCraft is SFW only, with no switch: no nudity, no sexual content, no brutal gore or violence (realistic blood is fine), and no field, toggle, flag or model row that turns any of these on. Children may appear in ordinary contexts. The checks are also what the FLUX licence asks for (§5).

The workflow carries ComfyUI-Content-Gate 1.7.0 (vendored, Generate-AI, MIT), the same pack the MiniMax H3 Video Replacer ships: one folder name and one set of class names on a pod, so the two packages carry one version and the base keeps the newest. One model, Qwen3-VL-4B-Instruct, answers yes or no questions (a fact left unclear is asked once more, constrained to yes or no); the checks sit on the data path, chained, and run on every run:

check	looks at	sits between
1 · your words	the prompt as typed, with the Layout box words	the Prompt and Layout fields and the upsampler
2 · your photos	each photo field, one check per field (ten)	the photo and everything that uses it
3 · the full prompt	the caption the upsampler wrote	the upsampler and the encoder (and the Full prompt preview)
4 · the picture	the finished picture, upscaled or not	the decoder and the save

Fails closed. A question the model does not answer with a clear yes or no stops the run as “unsure”.
A stop raises from the check that found it: nothing downstream runs, nothing is saved, and the message says which check, what it found where, and what to change. The App reads the same stop and marks the field to change.
An empty photo field (the 64 px NO-PHOTO.png placeholder, or any picture of 64 px or less on both sides) is passed without a question and reported as “no photo”. The workflow never uses a picture that small.
No check has a widget, none sits in a branch that may be skipped, and no App Mode field reaches one. The suite proves all of this over every path of the graph (§4).

4. The build and the suite

The workflow is generated by _build/build_workflow.py from Comfy-Org’s two distilled FLUX 3 Klein templates (workflow_templates v0.11.86), BFL’s upsampler system prompts, the cached node schemas and models.py; appmode.py writes the App Mode form, and export_app.py exports the app’s API prompt and bindings through the real frontend. Edit the builder and rebuild, never the JSON.

suite.py (8 tiers, bash "image-creator-flux-3-klein-script.sh" test [tier]):

tier	what it proves
unit	the JSON is well-formed and carries the version
graph	every safety check on every path (live, chained, never routed around, no form field), BFL’s settings, core wiring
contract	the script, its rows, `models.py`, the loaders, both vendored packs, the app (its port, relative paths, App Front’s validators, the stop tag) and the sibling packages agree
install	the installer on a throwaway tree: every file lands, the packs, the app, the no-photo picture, the links with no key in the log, `--check` changes nothing
comfyui	every node type is core ComfyUI or a pack this package (or the base) installs
server	a live ComfyUI: the node classes, CLIPLoader type `flux3`, the checks offer no setting, the version floor
runpod	pod only: every file at its exact size, the packs, the app, the loaders’ files in the server’s dropdowns
gpu	pod only: CUDA, and Qwen3-VL in the base’s venv

The safety rules are path rules: every text path into the upsampler’s prompt passes the words check, every path into the encoder the caption check, every photo path into the model a photo check, every decoded picture the result check before it is saved. A check that is present but routed around fails as surely as a missing one. A number made from a field (Shape and Size become the canvas’s sides) carries no words, so the words rule stops there; the Prompt and the Layout boxes must reach the upsampler as words, and only through the check. The pack’s own unit tests (ComfyUI-Content-Gate/tests/) run from the repository through the contract tier.

5. Licence

What the licence says, in plain words. The licence text on the gated page is what counts; read it there before you accept it.

The model. The engine is under the FLUX Kommunity License v1.0 (Black Forest Labs). Whoever accepts it on Hugging Face and downloads the weights with their own token is the licensee. SoulCraft ships no weights: this package is the workflow, the app and their installer.
Selling or publishing the pictures is free only for a Qualifying User: you and your affiliates together under US$5 million gross annual revenue, at any time. Above that you need a commercial licence from BFL (bfl.ai/licensing). BFL claims no ownership of the pictures. This package is for Qualifying Users and for holders of a BFL commercial licence.
Content filters are a condition of the licence. It requires filters (or a person reviewing every picture before it is shown or shared) against unlawful, unsafe or infringing content. The four checks (§3) are how this package meets that, which is one more reason they have no switch.
Say it is AI-generated where the law requires it, when you publish or share a picture.
No training on the pictures. They must not be used to train or improve any other AI model. FLUX 3 Klein pictures never go to a LoRA trainer, the Krea 2 Character Creator, or any other model’s training. A model trained on them counts as a derivative of FLUX 3 Klein, which the licence allows for non-commercial use only. Use the pictures as they are.
Real people. No one’s likeness without their consent (rights of publicity, digital replicas). The licence also rules out child sexual abuse material, intimate images without consent, anything unlawful, defamatory or abusive, and military, surveillance or biometric use.
BFL may end the licence at any time on notice; then the model is no longer yours to use. The licensee also answers to BFL for claims that come from their use, including a missing content filter.
The other parts are Apache-2.0: the text encoder (Qwen3-VL-4B), the prompt upsampler, the FLUX.2 VAE, SeedVR2 and the safety model (Qwen3-VL-4B-Instruct).
FLUX is named only to say what the package runs on (“for FLUX 3 Klein”); no BFL logo is used.

6. Record

V1.1.2 (2026-10-17)

GPU_MIN_GB for the site’s catalog. GPU_MIN_GB="21", estimated: the smallest card the default flow runs on, for the site’s catalog. It is the heaviest stage’s weights at the precision the loader picks, plus ComfyUI’s own memory_required activations and its 1.2 GiB inference reserve, with ComfyUI swapping models between stages; the script’s comment holds the arithmetic. Comfortable: 37 GB. A measured peak replaces the estimate at the next free GPU smoke. No graph change but the version stamp.

V1.1.1 (2026-10-17)

ComfyUI-Content-Gate 1.7.0, one pack with the Video Replacer’s. The two copies had split at 1.2.0 under the same folder and class names: this package’s 1.3.x added the prompt and caption checks for a still, the Replacer’s 1.3.0 to 1.6.0 added the re-ask of an unclear fact, the GPU picture path, the fingerprint and the describer. On a pod with both, the base keeps the newest copy, so the Replacer’s 1.5.0 replaced this package’s and the prompt and caption checks vanished (the workspace’s integration run found it on the shared testbed). 1.7.0 is the Replacer’s 1.6.0 with this package’s still checks on top: every class of both, nothing removed, the still chain unchanged.
The suite’s “no check offers a setting” rule now reads a link the way ComfyUI does: a type with no widget, or any primitive declared forceInput (the describer’s seed is an INT socket, never a widget).

V1.1.0 (2026-10-16)

The SoulCraft app, built in parallel sessions on V1.0.0.

The App link: ComfyUI-App-Front 1.7.0 (vendored) serves the app from ComfyUI; port 8190 is named App on RunPod’s Connect tab, beside ComfyUI and Terminal. The links are locked with the pod’s key (?token= once, then a cookie; ComfyUI Base 3.14.0), and the install log carries no key.
The app: Describe and Layout views, up to ten photos, Shape and Size chips, a live preview while it renders, the full prompt behind the info icon, Download, Use as photo, Again; the stops say what to change.
The graph: ten photos, Shape and Size in Create and Edit, the Layout flow (BFL’s bounding-box prompts), one seed for the sampler and both upsamplers, and the exporter that writes the app’s prompt and bindings.
The engine is nvfp4 on Blackwell, with bf16 as the fallback row.
The licence section is read from the full FLUX Kommunity License text.

V1.0.0 (2026-10-16)

The first version, built in parallel sessions from Comfy-Org’s FLUX 3 Klein templates (ComfyUI 0.41.0, 2026-10-15), to replace FLUX.2 Klein 9B, whose licence is non-commercial.

① Create and ② Edit (1 to 4 photos, Photo 1 sets the size), BFL’s upsampler always on, the optional SeedVR2 upscale, the full prompt shown; seven App Mode fields.
ComfyUI-Content-Gate 1.3.1: the prompt and caption checks for a still, and an empty photo field passed as “no photo” without a model call.
The text encoder is Krea 2’s row, and Flux 2 Dev 3.1.2 no longer supersedes flux2-vae.safetensors: one place per file name across the packages.
Every Hub row is pinned to a commit (models.py PIN; ComfyUI Base 3.12.0 or newer honours the pins), so a repo that later moves or renames a file cannot break an install. The gated repo’s commit comes from its public API metadata.

What is NOT tested yet

No picture has been made on a GPU through this graph, and no pod has run the install. Owed: a real render (① Create, ② Edit, Layout, the four checks on real inputs, the seconds per stage, nvfp4 against bf16), then the App on a pod. HANDOFF.md lists it.