16 October 2026Black Forest Labs · InferenceCurated

FLUX 3 Image Klein: what lies behind “5.6B parameters” and “8 GB”

Summary

With FLUX 3 Image Klein, Black Forest Labs has released an open image model with 5.6 billion parameters that generates images, edits them with up to ten reference images and places image elements via bounding boxes. According to the vendor, it runs with INT8 on graphics cards with as little as 8 GB and beats larger open models in internal comparisons. This post explains the technology and shows what the mandatory separate prompt upsampler, the memory figures and the first community experiences mean for running it on your own hardware.

What was released

Black Forest Labs (BFL) released FLUX 3 Image Klein on 15 October 2026. A single model handles text-to-image, image editing and generation from up to ten reference images, generates natively up to 4K and can place elements precisely or confine edits to an area via bounding boxes. It is the second open release of the FLUX 3 family, after the robotics model FLUX 3 Action.

There are two variants: a base model for fine-tuning with 50 steps and classifier-free guidance (CFG 3.5), and a distilled model with 16 steps and no guidance, about six times faster according to the README. In addition there are FP8, INT8 and NVFP4 builds developed with NVIDIA. Day-one support was available in ComfyUI, Diffusers, TensorRT-LLM, SGLang and vLLM; LoRA training works with Diffusers, Ostris’s AI Toolkit and NVIDIA NeMo AutoModel.

FLUX 3 itself is a multimodal model that learns jointly from images, video and audio. BFL’s reasoning: images contribute spatial detail, video motion and physics, audio information about events. Together the signals are meant to produce images that feel grounded in the real world.

New: image layout via bounding boxes

A JSON list of regions can be appended to the prompt. Each region has an ID, a description and a rectangle; in Diffusers on a scale from 0 to 1000, in the reference code from 0 to 1, each from the top left. Because the scale is normalised, the same box works at any image size.

For edits, each region states where its content is in the reference image and where it should end up in the result. A region with two identical boxes stays where it is. This makes it possible, for example, to move a figure within the image while explicitly pinning the background and other objects. Via the API, BFL provides pixel restoration for this, which preserves unedited regions exactly.

It does not work without the prompt upsampler

The reference repository warns repeatedly: never use the model without the prompt upsampler. This upsampler is a separate vision-language model with 9 billion parameters, fine-tuned from Qwen3.5-9B and licensed under Apache 2.0. It turns a short request into a detailed image description; in the README example, one line becomes a 214-word text. FLUX 3 Image Klein was trained on exactly such descriptions; according to BFL, a prompt entered as typed gives noticeably weaker results.

The upsampler is on by default in the CLI, demo and Python API, and in Diffusers it runs on every request. If the upsampler and the image model do not fit on the GPU together, the README recommends running the upsampler on its own first and then passing its description to the image model with --no-pup.

What “5.6 billion” and “8 GB” mean

The parameter count applies only to the image generator; BFL explicitly does not count text encoders, nor the upsampler. The generator weights take 11.2 GB in BF16 and 5.6 GB in FP8. According to the README, downloading the fast model with upsampler comes to 52 GB, everything together to 107 GB.

The 8 GB applies to the INT8 files in ComfyUI on GeForce RTX cards such as the RTX 3070. BFL’s reference code has no INT8 path; FP8 requires Ada, Hopper or Blackwell, NVFP4 requires Blackwell. On a B200, BFL measured peak GPU memory of 25 to 31 GB with the reference code at 1024 × 1024 pixels and without the upsampler.

For speed, BFL cites NVIDIA measurements: with the distilled model and INT8, a one-megapixel image takes about 4 seconds in ComfyUI on an RTX 5090 and under 9 seconds on an RTX 4070. On an H200 the distilled model needs about 3 seconds, the base model about 12. On a GB300 in NVFP4 it is under 0.6 seconds; a LoRA adds about 5 percent.

Benchmarks: internal ratings

According to BFL’s internal evaluations, FLUX 3 Image Klein ranks ahead of larger open models such as Qwen-Image 2.1 (7 billion parameters) and Krea 2 (12.9 billion) in text-to-image, multi-reference and editing, and even ahead of the closed models Ideogram V4.5 and FLUX.2 [pro]. Compared with its predecessor FLUX.2 [klein] 9B, it gains 91 Elo points in text-to-image and 70 in editing, with 38 percent fewer parameters.

For latency, BFL compares times via its own API. FLUX 3 Image Klein was measured on BFL’s servers, the other models from the client, including polling and network time; BFL notes this itself.

First experiences from the community

In the Hacker News discussion of 16 October, opinions were mixed. Several users reported weak depictions of people with distorted faces and wrong finger proportions, in some cases using the stock ComfyUI template. One user pointed out that weaker results are to be expected without the prompt upsampler; the tester in question, however, had used the BFL API. The suspicion that filtering nudity out of the training data is the cause is unproven.

The editing functions, which one user called “really solid”, and the price were rated positively: via the API, an image at 1K resolution costs from 0.009 US dollars.

Licence and safeguards

The weights are under the FLUX Kommunity License. It allows free commercial use for individuals and companies with annual revenue under 5 million US dollars, as well as research and non-commercial use; larger companies need a self-hosting licence or the API. The code in the GitHub repository is under Apache 2.0; the weights on Hugging Face can only be downloaded after accepting the terms.

According to BFL, harmful content was filtered from the training data and the models were attacked internally and by the external partner Cinder. In the reference code, safety checks are off by default; with --safety it checks prompts, reference images and outputs for copyrighted characters, brands, public figures and nudity. Generated images carry EXIF tags such as “Software: AI generated”.

Ideas

One model handles image generation, editing and multiple references.
Bounding boxes in the prompt define where each element appears.
A prompt upsampler with 9 billion parameters is mandatory.
Parameter counts of image models usually exclude text encoders and upsamplers.
The distilled model needs 16 instead of 50 steps.
INT8 in ComfyUI brings the model to graphics cards with 8 GB.

Insights

Small image models shift work into auxiliary models: the generator shrinks, but without the larger upsampler quality collapses. For operation, the whole chain counts, not the number in the title.
The hardware figure depends on the tool: 8 GB applies to the INT8 files in ComfyUI, not to the vendor’s reference code.
Vendor benchmarks and first practical reports can be far apart; your own tests with typical subjects remain necessary.

Facts

The image generator has 5.6 billion parameters and takes 11.2 GB in BF16 and 5.6 GB in FP8.
Up to ten reference images can be combined in one edit.
The prompt upsampler is based on Qwen3.5-9B and licensed under Apache 2.0.
Downloading the fast model with upsampler comes to 52 GB, all parts to 107 GB.
Free commercial use applies up to 5 million US dollars in annual revenue.

References

Critique

The headline “5.6 billion parameters, runs with 8 GB” leaves out the mandatory components: text encoders and an upsampler with 9 billion parameters come on top, the download is 52 GB, and the reference code needs 25 to 31 GB of GPU memory on a B200.
The quality comparisons are based on BFL’s internal Elo ratings, and latency was measured for BFL’s own model on its own servers, for the competition from the client. Independent comparisons are still missing.

Remarks

The model name “Klein” is German for “small”; BFL already used it for the predecessor FLUX.2 [klein].
The installation in the README uses Python 3.12 and PyTorch packages for CUDA 13.0; BFL tested it on a B200.

Recommendations

For graphics cards with little memory, from 8 GB, use the INT8 files from the flux-3-image-klein-comfy repository in ComfyUI.
If GPU memory is tight, run the upsampler separately and pass the description with --no-pup rather than simply leaving it out.
Before switching from FLUX.2 [klein], compare your own test subjects, especially people and hands.
For publicly reachable services, enable --safety and check the licence’s revenue threshold.

Read the announcement

Search the Web Archive