FLUX 3 Image Klein Is Out: 5.6B Parameters, 8 GB of VRAM, and a $5M Line in the Licence

Black Forest Labs published FLUX 3 Image Klein on 15 October 2026: a 5.6B-parameter open-weights image model that also runs as a metered endpoint called flux-3-image-klein/ on the company's own API, starting at $0.009 per 1K image. It sits under the larger FLUX 3 Image and inherits that model's headline surface — native 4K output, up to ten reference images, and bounding boxes for placing or editing elements — at roughly a fifth of the 1K price and a fraction of the footprint. Those are the launch claims, and they are checkable against the weights, the licence and the pricing table. What is not yet checkable is the one claim that decides most purchases: that a 5.6B model outranks larger open-weights competitors on quality.

Every quality number in the release comes from inside Black Forest Labs. Nobody outside the company has published a benchmark, and the public leaderboards do not carry an entry for Klein yet. That is normal for a model a day old, and it is worth naming up front, because the rest of this piece is unusually concrete — file sizes, per-image rates, licence thresholds — and the quality question sits apart from all of it.

What was actually released on 15 October

The announcement is titled FLUX 3 Image Klein: open weights, 5.6B parameters and it enumerates a complete release rather than a single checkpoint drop:

• Two checkpoints. Klein Base is undistilled bfloat16, runs 50 steps at guidance 3.5, and is the one meant for fine-tuning, LoRA training and research. Klein distilled is bfloat16 at 16 steps with no guidance, and is the checkpoint behind the BFL API.

• Three quantisation formats. FP8 and NVFP4 builds ship alongside the BF16 transformer in the main repository, with an INT8 build developed with NVIDIA support. The ComfyUI repackaging carries INT8 versions of both the transformer and the text encoder.

• One model for three jobs. Text-to-image, single-reference editing and multi-reference composition run through the same weights. Reference images anchor content rather than locking structure, and the model accepts up to ten of them.

• Bounding boxes on a 0–1000 grid. Each element gets a box and a description, written as [top, left, bottom, right]/, and the box can either place a new element or confine an edit to a region. BFL is explicit in the model card that boxes guide placement and scale rather than constraining pixels to a hard mask — small requested elements may not appear at all, and an element can extend past its box.

• Day-one runtime support in ComfyUI, Hugging Face Diffusers, TensorRT-LLM, SGLang Diffusion and vLLM-Omni, plus LoRA training through Ostris's AI Toolkit and recipes in NVIDIA NeMo AutoModel. The model was trained on NVIDIA GB200 NVL72.

The repositories went up before the announcement — the base and distilled repos were created on 13 October, the ComfyUI and prompt-upsampler repos on 14 October — with the launch post, the API endpoint and the pricing page all following on the 15th. img src="2.png" alt="Headless-browser capture of the Hugging Face repository page for black-forest-labs/flux-3-image-klein, showing the licence-acceptance gate, the flux-kommunity-license badge, the model size given as 6B params with BF16 tensor type, 3,241 downloads last month, 219 likes, and the model tree listing adapters and fine-tunes, captured in English on 16 October 2026." />

The 8 GB claim, and who measured it

"Runs on a single consumer GPU" is the sentence that will get quoted most, and BFL does give it a number: with the INT8 build, Klein runs on GeForce RTX GPUs with as little as 8 GB of VRAM through ComfyUI or Diffusers. The generator weights themselves are 11.2 GB in BF16 and 5.6 GB in FP8, per the blog post.

The speed figures come from NVIDIA, not from Black Forest Labs, and they are specific about the setup: the step-distilled model with the INT8 build produces a 1 MP image in about 4 seconds on an RTX 5090 and under 9 seconds on an RTX 4070, measured in ComfyUI. On a GB300 running NVFP4, the same distilled model lands under 0.6 seconds. Serving a LoRA adds roughly 5% to generation time.

One structural caveat sits in the latency chart BFL published alongside the numbers, and the post discloses it itself: Klein was timed on BFL's own servers, while the compared models — Qwen-Image 2.1, FLUX.2 [pro], Ideogram V4.5 and Krea 2 — were timed from the client, which includes polling and network time. The RTX figures are NVIDIA's ComfyUI measurements. Neither set is an independent benchmark of quality.

Where the quality claim stands, honestly

BFL's position is that Klein "ranks first in text-to-image, multi-reference generation and image editing, ahead of larger open weights models" in its internal evaluations, and that it rates above the closed models in its comparison. Against its own previous small model, FLUX.2 [klein] 9B, BFL reports a gain of 91 Elo in text-to-image and 70 in image editing with 38% fewer parameters.

Those are vendor-reported and unreproduced. Two details make them easier to weigh. First, the comparison set: 7B for Qwen-Image 2.1 and 12.9B for Krea 2, with parameter counts taken as each publisher reports them and text encoders excluded from every count — the same accounting that makes Klein "5.6B" while shipping an 8.9 GB Qwen3-VL-4B-Instruct text encoder next to it. Second, the model BFL did not put in the chart: FLUX 3 Image, the larger sibling, is absent from its own smaller model's comparison. There is no published number anywhere saying how far Klein sits below it.

Independent boards have not caught up. As of 16 October, Artificial Analysis carries an entry for FLUX 3 Image on its text-to-image board and none for Klein, so there is no third-party Elo for the model at all. The first number that does not come from BFL will be the interesting one.

What it costs, and how the curve bends

The API rate is the sharpest thing in the release. On BFL's published image pricing, the distilled Klein checkpoint is:

• 768 × 768 — $0.008 per image

• 1K — $0.009 per image

• 1.5K — $0.011 per image

• 2K — $0.014 per image

• 4K — $0.036 per image

The same table prices FLUX 3 Image at $0.041, $0.048, $0.07, $0.10 and $0.607 for those five tiers. That is a 5.3× gap at 1K and roughly 17× at 4K, and it is the entire commercial argument for Klein: if your workload is 4K text-to-image at volume, the smaller model is not a downgrade you tolerate, it is a line item that changes by an order of magnitude.

Note the shape of the curve rather than the entry price. Klein's cheapest tier is $0.008, but the rate is flat-ish to 2K and then jumps 2.6× for 4K, while FLUX 3 Image jumps more than 6×. If your outputs are 1K, the two models are close enough in price that quality should decide it. If they are 4K, they are not in the same conversation.

The licence decides whether you can actually ship

Weights under the FLUX Kommunity License v1.0 are free for non-commercial use, and the licence grants a commercial-output exception to "Qualifying Users" — individuals and companies with under US$5M in gross annualized revenue. Above that line, deploying Klein commercially means a self-hosted licence from BFL or going through the API.

Read the wording carefully, because two summaries of it differ in scope. The launch post describes "free commercial use for individuals and companies with annual revenue under $5M". The model card frames the same exception as covering commercial output generation by Qualifying Users, and adds that it "is not blanket permission for commercial fine-tuning or distribution". For a team whose plan is to fine-tune Klein on proprietary data and ship the resulting model inside a product, the launch post is not the document that answers the question. The full license text is.

There is also a clause worth knowing about before you design a data pipeline around Klein: the licence restricts using the model, its derivatives or its outputs to improve another AI model that performs a function similar to a FLUX model. Synthetic-data generation for training a competing image model is exactly the case that clause is written for.

The one thing you must not skip

Klein does not take short prompts. Both the model card and BFL's page say the same thing in different words: it expects full scene captions covering framing, subject, background and lighting, and a one-line request sent as typed returns generic output. The reference implementation therefore runs a prompt upsampler before every generation — text-to-image and editing alike — and the model card is blunt about it: Do not use the model without a prompt upsampler.

The cost of that is real. BFL's upsampler, flux-3-image-klein-pup/, is a separate 18.8 GB download in BF16 and adds about 28 GB of GPU memory on an 80 GB card when it runs alongside the generator. The documented opt-out is to supply your own: any LLM can take its place if you feed it BFL's system prompt and pass the caption it returns. For anyone planning an on-device or low-VRAM deployment, the upsampler is the piece that quietly breaks the 8 GB budget, and the fix is to run captioning somewhere else and send Klein the finished caption with the prompt-as-typed flag.

Getting to it, and what happens next

Weights are on Hugging Face behind a licence-acceptance gate, with reference inference code and a Gradio demo for bounding-box control in the same organisation. The hosted endpoint is the vendor's own API. Klein is not in OrcaRouter's catalogue today, so there is nothing for us to route here, and we would rather say that plainly than imply otherwise. What OrcaRouter does give you is the other half of a real image pipeline: the hosted image models that are in the catalogue sit behind one key alongside 200+ other models, with the provider's list price passed through at 0% markup and automatic failover if one provider wobbles. Teams that end up running Klein for bulk 4K work and calling a hosted model for the interactive path are doing exactly the split that a single endpoint is built for.

What to watch over the next fortnight is narrower than usual. Three things would settle the open questions: an independent Elo for Klein, ideally on the same board as the Qwen and Krea models BFL benchmarked itself against; a reported memory figure for the INT8 build with the upsampler actually in the loop, rather than the generator alone; and a first look at what fine-tunes do to the model's behaviour, given that LoRA training was supported on day one and the licence has opinions about what those fine-tunes may be used for. Until the first of those lands, treat every quality comparison — including the one in this article — as a vendor's own chart.

Benchmarks age and prices move; the failure record does not: the documented AI incidents and agent failures behind models in this class are collected in the OrcaRouter AI Incident Archive, where each entry carries its own sources, severity, confidence grade and disputed flag.