FLUX 3 Image Klein Locally: ComfyUI Setup, 8 GB VRAM, Files and Licence

FLUX 3 Image Klein is the open-weight member of Black Forest Labs' FLUX 3 family: a 5.6B image model for text-to-image, editing and up to 10 reference images, released on 15 October 2026. It runs locally in ComfyUI 0.41.0 or later, and its 5.83 GB INT8 build works on 8 GB NVIDIA cards. Free commercial use is limited to organisations under US$5M in annual revenue; the larger FLUX 3 models are API or licence only.

Black Forest Labs (BFL) announced FLUX 3 on 23 July 2026 as a multimodal foundation model for images, video, audio and robot actions, with no downloadable weights at launch. Its first open release was FLUX 3 Action in September, and Klein followed on 15 October with day-one support in ComfyUI and in the development branch of Diffusers. On 13 November BFL’s ComfyUI repository was among the ten trending models on Hugging Face. ComfyUI’s documentation calls the model FLUX.3 [klein], so expect both spellings in search results and file names.

This guide covers the release, files, licence, ComfyUI setup, VRAM tiers, editing and the API, all checked against BFL’s model cards, licence text and repositories on 13 November 2026. Speed figures are BFL’s own and labelled as such; memory estimates of ours are marked as estimates. To compare Klein with Z-Image-Turbo, FLUX.2 [klein] and Qwen-Image, use our image-model guide sorted by GPU, Mac and licence. For moving pictures, see our MiniMax H3 ComfyUI walkthrough.

What FLUX 3 Image Klein is, and which FLUX 3 models stay closed

Klein is one model doing three jobs. It takes a prompt and up to 10 reference images and returns one image, so text-to-image, instruction editing and multi-reference composition all run through the same weights. The prompt can also carry bounding boxes that place elements or confine an edit. The 5.6B label counts the image transformer only; the text encoder is a separate Qwen3-VL-4B-Instruct model.

BFL ships two checkpoints:

BFL’s GitHub README lists CFG 4 for the base model while the model cards say 3.5; ComfyUI’s templates use 3.5. The README says the distilled model is about six times faster than the base.

The rest of the family is not downloadable:

• FLUX 3 Image is the full image model. BFL sells it through its API and under a commercial weights licence for companies that run it on their own infrastructure. It has no open release.
• FLUX 3 Video generates clips of up to 20 seconds with native audio. The July launch opened early access, and it is now priced per second on BFL’s API.
• FLUX 3 Max appears in BFL’s model menu, but its page returned an error on 13 November and the pricing page shows no price for it.
• FLUX 3 Action is an open-weight 7B world action model for robot control, published on Hugging Face on 22 September 2026 under the same licence as Klein.
• FLUX 3 Dev is the open multimodal backbone the launch post promised. It had no date, licence or repository on 13 November.

FLUX 3 Klein vs FLUX.2 klein

Searchers often compare Klein with January’s FLUX.2 [klein] models, which BFL still sells. FLUX.2 [klein] 4B carries Apache 2.0, and FLUX.2 [klein] 9B is under BFL’s non-commercial licence. FLUX 3 Image Klein sits between them on parameters and on licence. In BFL’s internal evaluations it scores 91 Elo above FLUX.2 [klein] 9B for text-to-image and 70 above it for editing, with 38% fewer parameters. Those are vendor results, not independent tests. Anyone who needs unrestricted commercial rights without paying BFL is still better served by the 4B Apache model.

FLUX 3 Image Klein files and sizes on Hugging Face

BFL publishes four repositories. The two model repositories and the ComfyUI repository are gated, so you sign in and accept the licence before downloading; the prompt upsampler repository is open.

Most local users only need the ComfyUI repository. Its file sizes, from the Hugging Face listing:

The original model repositories add an FP8 build of 6.27 GB under variants/fp8r. NVFP4 needs a Blackwell GPU, and FP8 needs Ada, Hopper or Blackwell, which is why BFL points owners of RTX 30-series cards to INT8. BFL’s GitHub README puts the distilled model plus upsampler at 52 GB in its own format and the full set of both checkpoints at 107 GB.

Community builds arrived within days. Unsloth’s GGUF files of the distilled transformer run from 2.62 GB for UD-Q2_K_XL to 6.09 GB for Q8_0, and leejet’s GGUF set for stable-diffusion.cpp starts at 2.28 GB for Q2_K. Unsloth recommends UD-Q4_K_XL at 3.93 GB and publishes LPIPS and SSIM scores against the BF16 model for every file. It also quantised the prompt upsampler, with Q4_K_M at 5.63 GB.

FLUX 3 Klein licence: the US$5M line and what it leaves out

Klein’s weights ship under the FLUX Kommunity License v1.0, a new licence that also covers FLUX 3 Action. The full text sits behind the Hugging Face gate; we read the copy that Unsloth redistributes with its builds, as the licence requires, and checked it against the summary on BFL’s model card. It is not an open-source licence:

• Non-commercial use covers personal research and hobby projects, charities, and testing, evaluation or research by for-profit companies in a non-production environment. Use that earns revenue, reaches end users or trains models for commercial use is excluded.
• Qualifying Users are individuals or entities whose gross annualised revenue, together with affiliates, is under US$5,000,000. They may use outputs commercially and run the model in production solely to generate those outputs.
• Conditions on that commercial use. Qualifying Users must run content filters or review outputs for unlawful or infringing material before distributing them, and must label outputs as AI-generated where applicable law requires. Our explainer on Article 50 of the EU AI Act covers the European disclosure duty.
• Prohibited uses include military purposes, surveillance and related research, biometric processing, unlawful or abusive content, and violating publicity or digital-replica rights. Neither the model nor its outputs may be used to improve another model that does a similar job.
• Derivatives such as LoRAs and fine-tunes inherit the terms. BFL’s card adds that the commercial exception is not blanket permission for commercial fine-tuning or distribution.
• Termination. BFL may end the licence at any time on notice, and it ends automatically on breach. Delaware law governs.

The text encoder, the prompt upsampler and BFL’s reference code are Apache 2.0. Outputs belong to you, with BFL claiming no ownership.

For organisations over the threshold, BFL’s self-hosted licences are the route. Its pricing page lists Builder, covering FLUX 3 Image Klein and FLUX.2 [klein] for 10,000 images a month; Platform and Professional at 100,000 images a month with FLUX.2 [dev] added; and Enterprise and Synthetic Data tiers on request. All include fine-tuning and LoRA rights, and none shows a price. Our open-weight licence review checklist lists what counsel will ask, and nothing here is legal advice.

How to run FLUX 3 Image Klein in ComfyUI

1. Update ComfyUI. Native support arrived in 0.41.0 on 15 October 2026, which also added the ReferenceMultiLatent node the edit templates use. Version 0.45.0 was current on 13 November.

2. Accept the licence. Sign in to Hugging Face, open black-forest-labs/flux-3-image-klein-comfy and accept the agreement; downloads fail until you do.

3. Open a template. In Template Library, search for FLUX 3 Image Klein. There are four: Text to Image and Image Edit with the base checkpoint, and Distilled versions of each.

4. Fetch the files. The pop-up can download them, or place them by hand on an offline machine. The official templates load the INT8 checkpoints and the W4A8 upsampler:

   ComfyUI/models/
   ├── diffusion_models/flux3-image-klein-int8-convrot.safetensors
   ├── diffusion_models/flux3-image-klein-base-int8-convrot.safetensors
   ├── text_encoders/qwen3vl_4b_int8_convrot.safetensors
   ├── text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors
   └── vae/flux2-vae.safetensors

   BFL’s own card gives a one-line download that drops a single checkpoint into place: hf download black-forest-labs/flux-3-image-klein-comfy followed by the file names and --local-dir ComfyUI/models. The text encoder loads through CLIPLoader with type flux3.

5. Keep the upsampler on. Every template has an enable_prompt_upsampler switch, on by default. BFL trained Klein on long scene captions, and its documentation says short prompts sent as typed give generic output. Switch it off only when you paste a full caption written elsewhere.

6. Set the canvas. Text-to-image templates use ResolutionSelector, square by default. Edit templates take their size from Empty Flux 2 Latent, 1024 × 1024 in the template, and resize each reference to about one megapixel.

7. Choose steps and guidance. The distilled checkpoint runs 4 to 16 steps, 16 by default, with CFG fixed at 1. The base runs 50 steps with CFG 3.5 for text-to-image and 1 for editing. Images land in ComfyUI/output/.

ComfyUI’s guide recommends the BF16 transformer and BF16 upsampler on cards with more than 24 GB, because they follow long prompts more closely.

Klein also runs outside ComfyUI:

• Diffusers. Version 0.42.0, released on 23 October 2026, added Klein as a ModularPipeline that runs the upsampler on every request. Its documentation puts all components at about 39 GB in BF16, or about 20 GB without the upsampler, and offers automatic CPU offloading for smaller GPUs.
• BFL reference code. The GitHub repository runs BF16, FP8 and NVFP4 with a CLI, a Python API and a Gradio demo with a drawing tab for boxes. It has no INT8 path, and BFL tested it on a B200.
• Servers. BFL lists SGLang Diffusion, a vLLM recipe and a TensorRT-LLM feature branch with BF16, FP8 and NVFP4 support. Our comparison of NIM, vLLM and Ollama covers those serving stacks for language models.
• GGUF. Unsloth’s files load in Diffusers through its GGUF quantisation config and in Unsloth Desktop; leejet’s files target stable-diffusion.cpp.

FLUX 3 Klein VRAM requirements: 8 GB to 24 GB and Mac

Three models share the memory budget: the 5.6B transformer, the 4B text encoder and the 9B upsampler. ComfyUI loads them in sequence and moves idle ones to system RAM, so the transformer and the canvas size usually decide the card, while the total set decides how much system memory you need. For one checkpoint, the INT8 template files add up to about 17.7 GB. The upsampler is an ordinary language model, so our VRAM calculator sizes it like any other 9B LLM.

The reference figures need care. BFL measured 31 GB in BF16 on a B200 at 1024 × 1024, and its upsampler reserves 35% of the GPU by default, about 28 GB on an 80 GB card. Those are numbers from code that keeps everything resident, not a floor for consumer cards. For 8 to 12 GB cards we would plan on at least 32 GB of system RAM; that is our estimate, not a published requirement. Another option on small cards is to run the upsampler elsewhere: BFL’s README shows generating the caption first and passing it with --no-pup, and Unsloth’s GGUF build lets llama.cpp produce it on the CPU or another machine.

Mac. BFL publishes no Apple silicon build. The mflux project converted Klein to MLX on 19 October 2026, with an 8-bit package of 9.9 GB and a BF16 package of 18.5 GB run through mflux-generate-flux3. Draw Things publishes its own quantised builds of 5.74 GB and 3.43 GB. By file size, a 16 GB Mac suits the 8-bit route and a 24 GB Mac or larger the BF16 one; that is our estimate. Our Mac guide for local models covers memory bandwidth and model sizes, and our guide to choosing a GPU for local AI covers NVIDIA cards.

Image editing, multi-reference and bounding boxes

Editing works by caption, not by mask. You pass the source image as a reference and describe the finished picture with the change folded in; the upsampler turns a short instruction such as “make it blue” into that full caption. In ComfyUI, references connect in order to Set Reference Multi Latent and are addressed in the prompt as <ref_image_0>, <ref_image_1> and so on, up to 10.

How references are sized depends on the tool. In Diffusers, a single reference keeps its size unless it exceeds four megapixels, so an edit comes back at the input’s resolution; with several references, each is fitted under one megapixel and the first one sets the output size. ComfyUI’s templates resize every reference to about one megapixel, which its guide calls a cost dial: larger references keep more detail and cost more time.

Bounding boxes go into the caption as a JSON list after the text, each box written as top, left, bottom and right on a 0 to 1000 grid and tagged with an id the caption mentions. BFL’s reference CLI accepts the same idea as a boxes.json file using fractions from 0 to 1. For edits, a box can name where an element sits in a reference and where it should go, and a null target removes it. BFL is clear about the limits: boxes guide placement and scale but are not hard masks, elements can spill past them, small requested items may not appear, and edits can change content outside the region you meant.

Other limits from the model card: rendered text can be inaccurate or distorted, the upsampler writes only English though it accepts requests in other languages, and the upsampler itself does not refuse requests. BFL’s reference code has optional safety checks that are off by default and tags saved images with EXIF fields marking them as AI-generated. ComfyUI adds a Create Bounding Boxes node for planning regional edits.

For training, BFL points to Ostris’ AI Toolkit and NVIDIA NeMo AutoModel recipes, and recommends the base checkpoint for LoRAs and fine-tunes. Under the licence those are Derivatives, so commercial training needs care even for Qualifying Users.

How fast is FLUX 3 Klein locally?

BFL has published timings for a 1-megapixel, 1024 × 1024 text-to-image run, one image per run. These are vendor figures:

On BFL’s API, median latency at one megapixel, including queueing, was 4.54 seconds for text-to-image and 7.18 seconds for editing. BFL’s charts do not say whether the upsampler’s time is included, and on a card that must swap it in and out of VRAM it adds load time on top. We have not run our own benchmarks. For the DGX Spark and similar desktop systems, see our side-by-side look at three compact AI desktops, and for estimating throughput of the upsampler or other LLMs, the tokens-per-second calculator.

FLUX 3 Klein local vs the BFL API: pricing and trade-offs

BFL’s price list on 13 November 2026, per image:

The hosted Klein model includes prompt upsampling and pixel restoration. At $0.009 per 1K image, 100,000 images a month cost about $900 in API fees, so for most teams the hardware question matters less than the licence question.

• Local keeps prompts, reference photos and outputs on your machines, works offline and allows LoRAs within the licence. It needs a capable GPU and, for organisations at or above US$5M in revenue, a paid self-hosted licence for any production use.
• API has published per-image prices, needs no hardware and is open to companies of any size. Every prompt and reference image goes to BFL, which matters when references are product photos before launch or images of identifiable people.

The distilled checkpoint is the model behind the Klein endpoint, so quality differences between local and hosted runs come mainly from build precision and the hosted extras rather than from a different model.

How VDF AI fits

VDF AI has no image generation features. It does not run, host, bundle or connect to FLUX 3 Image Klein, ComfyUI or any other image model, and nothing in it sends prompts to them.

What it covers is the language-model side of private AI. VDF AI is an on-premises and private-cloud platform for governed AI agents, multi-agent workflows in VDF AI Networks and private RAG over company documents, with role-based access control on every plan and audit logs of what each user and agent did. Klein’s licence asks Qualifying Users for content checks and records of what they publish; teams that face the same questions for text assistants can see how VDF AI supports those controls.

VDF AI Router registers Ollama and custom on-premises model endpoints, including OpenAI-compatible servers, beside the cloud models your policy approves, prefers the local ones when they are available, and has an air-gap mode. Production self-hosting runs on Linux, with macOS for evaluation only, as our infrastructure requirements explain, and the local LLM overview covers the wider picture.