A 5.6B Image Model With a 20.8 GB Download: What FLUX 3 Klein Actually Asks For

FLUX 3 Klein is a 5.6B model. The download its makers recommend is 20.8 GB, because the text encoder and the required upsampler are both bigger.

A small bone-white tile standing on a stone base in front of two much larger slate slabs on a pale blue-grey backdrop
11 min read
2,175 words

Go looking for FLUX 3 Klein’s VRAM requirements and the first number you meet is 5.6B. It sounds like a small model, and in one sense it is. Then you follow Black Forest Labs’ own instructions for getting it running and the download command pulls 20.8 GB.

Both numbers are correct, they are on the same page, and the gap between them is the thing that decides whether this runs on your machine. It is not a trap and nobody is hiding anything. It is just arithmetic that no guide does for you.

What the parameter count covers

The model card is unusually direct about it. FLUX 3 Image Klein is described as “a 5.6B open weights model designed for image editing”, and two paragraphs later comes the sentence the rest of this article is built on: “The 5.6B parameter label refers to the image transformer; the text encoder is separate.”

Separate, and not small. The text encoder is Qwen3-VL-4B-Instruct — a 4-billion-parameter vision-language model whose job is to turn your words into something the image transformer can condition on. That alone would make the real stack closer to 10B than 5.6B.

There is a third model, and it is the largest of the three. Black Forest Labs ships a prompt upsampler built on a 9B Qwen3.5, and the ComfyUI workflows in the repository run it by default. So the thing you are actually installing is an image transformer, a vision-language text encoder, a 9B language model and an autoencoder. Four files, three of them models — and of those three, the one the headline number describes is the middle one.

The download Black Forest Labs recommends

You do not have to guess at the total, because the model card publishes both the file sizes and the command.

Model card table listing FLUX 3 Klein files and sizes, with the prompt upsampler at 18.8 GB and the image model at 11.1 GB, above a note that int8 files run on 8 GB GPUs such as the RTX 3070
Black Forest Labs' own file table for FLUX 3 Image Klein, captured 11 November 2026: the prompt upsampler is 18.8 GB at BF16 against an 11.1 GB model, and the note below it says the int8 files run on 8 GB GPUs.

All the sizes below are Black Forest Labs’ own, in decimal GB as their table writes them. The int8 download they recommend is four files: the model at 5.8 GB, the Qwen3-VL-4B text encoder at 4.9 GB, the autoencoder at 0.3 GB, and the prompt upsampler at 9.8 GB. That is 20.8 GB.

Take the same four files at BF16 and it is 11.1 + 8.9 + 0.3 + 18.8, or 39.1 GB. At every precision on offer, the prompt upsampler is larger than the model it serves.

The repository itself is larger still — around 87 GiB — because it ships every precision of everything, both the distilled and the undistilled checkpoint. Cloning it is a mistake that costs an afternoon.

FLUX 3 Klein’s VRAM requirements are not its download size

Directly beneath that table sits a line that appears to contradict everything above: “The int8 files run on 8 GB GPUs such as the RTX 3070, and on GPUs without FP8 support (RTX 30 series and older).”

Twenty gigabytes of files, on eight gigabytes of card. Both claims are true, and the reason is worth understanding because it governs every local image model you will ever install.

ComfyUI does not hold the stack in VRAM at once. Reading comfy/model_management.py, it keeps a list of currently loaded models and calls free_memory() when it needs room, evicting loaded models that are not pinned until the requested amount is free. There is a low-VRAM path as well, which computes how much of a model’s weights can live on the card and streams the rest rather than loading it whole, and a standing reserve — 400 MB, raised to 600 MB on Windows because of how shared VRAM behaves — that it refuses to spend.

That is what lets the stack run in sequence rather than side by side: the upsampler rewrites your prompt, and ComfyUI is free to evict it to make room when the image transformer needs to load. The two largest files never have to be resident together.

So the three budgets are not the same number, and confusing them is the commonest mistake here:

  • Disk is the sum. Just under twenty-one gigabytes, and you will want more for a second checkpoint.
  • VRAM is roughly the maximum of the individual pieces, not their total.
  • System RAM absorbs the difference, because evicted models go somewhere.

If you are costing an upgrade on the back of this, that ordering matters. It is the same conclusion reached from the other direction when fitting a large language model onto a small card: the GPU is rarely the part that stops you.

The prompt upsampler is the part people will try to skip

It is the biggest single file, it is a language model rather than an image model, and skipping it would cut the download by nearly half. Resist.

Black Forest Labs says to run one twice on the same page. “Always run a prompt upsampler. FLUX 3 Image Klein is trained on full scene captions, for editing, text-to-image and layout with boxes alike; a short prompt sent as typed gives generic output.” The limitations section says it again from the other side: “Prompt following is heavily influenced by the prompting style. Short prompts produce generic output.”

The reason is in how the model was trained. It expects a complete description — framing, subject, background, lighting — not an instruction. The upsampler’s job is to turn “make it blue” into that paragraph, folding your edit into a full caption of the reference image. Without it the instruction is taken literally as the caption, and the model reframes the shot instead of making the change.

There is one honest way to shrink the download, and the model card offers it: run your own LLM instead, with Black Forest Labs’ system prompt, which they publish. If you already have a capable model loaded for other work, that is 9.8 GB you do not need twice. What you should not do is turn the upsampler off and conclude the model is disappointing.

Choosing a precision and a checkpoint before you spend the bandwidth

Two decisions, both easy to get wrong, both costing a 20 GB re-download.

Precision first. The model card is specific: int8 for 8 GB cards and for GPUs without FP8 support, which means the RTX 30 series and older, while “NVFP4 needs a Blackwell GPU.” NVFP4 is the smallest file at 5.3 GB and it is useless to you on anything older. BF16 is the full-quality option at roughly twice the size, and worth it only if your card and your patience allow.

Then the checkpoint, which is the subtler trap. The repository ships two, and the only thing distinguishing their filenames is -base-. The distilled checkpoint — the one without -base- — runs at 16 steps with no guidance and is, in the model card’s words, “the checkpoint behind the BFL API”. The base checkpoint is undistilled, wants 50 steps and CFG 3.5, and is built for “fine-tuning, LoRA training, research”.

Download the base checkpoint by accident and everything still works. It will simply run 50 steps instead of 16, with guidance on top, for no benefit you can see — and you will probably blame your hardware.

Doing it

There is no official ComfyUI tutorial page for this model yet — the URL where one would live returns a 404, and the ComfyUI blog post you will find in search results is about FLUX.2, a different generation. The model card is the instruction.

The command, straight from it, fetches the four int8 files into the right folders in one go:

hf download black-forest-labs/flux-3-image-klein-comfy \
  diffusion_models/flux3-image-klein-int8-convrot.safetensors \
  text_encoders/qwen3vl_4b_int8_convrot.safetensors \
  vae/flux2-vae.safetensors \
  text_encoders/qwen3.5_9b_flux3_prompt_upsampler_int8_convrot.safetensors \
  --local-dir ComfyUI/models

Swap the first two filenames if you want a different precision or the base checkpoint; leave the last one alone unless you are substituting your own LLM. The files land in diffusion_models, text_encoders and vae respectively, which is where ComfyUI expects them.

Then open one of the workflow JSONs the repository ships — there are twelve, covering text-to-image, image-to-image and multi-reference work for both checkpoints — and sample with the defaults for whichever checkpoint you downloaded: 16 steps and no guidance for the distilled one, 50 steps and CFG 3.5 for the base. The workflows run the upsampler automatically, and expose an enable upsampler switch you should only turn off when your prompt is already a full caption.

For editing you can pass up to ten reference images with the prompt, and placement can be directed with bounding boxes on a 0–1000 grid appended to the caption as JSON. The model card is clear that boxes “guide placement and scale; they do not constrain pixels to a hard mask” — an element can spill past its box, and small requested elements may not appear at all.

For scale: what MiniMax H3-Image asks for

This is not a FLUX problem. It is how this class of model is now packaged, and the week’s other new local image model makes the point harder.

MiniMax H3-Image arrived on Hugging Face on 3 November and ComfyUI’s repackaging of it on 8 November. Its model card lists what you need: the image transformer, a VAE, a recommended 9B prompt enhancer, and a text encoder that is a 32-billion-parameter vision-language model. Taking the leanest version of each file that its own page names, that is roughly 42 GiB.

The ratio has gone the same way, only further. The text encoder is eight times the parameter count of FLUX’s, and the thing generating your image is once again not the largest thing you installed.

That pattern is worth carrying into any model you are sizing up, and it is the visual-model version of what happened when a 1.7B model claimed to replace a 9B one: a parameter count in a model’s name is a label on one component, not a statement about what you have to run.

The other number nobody reads

The licence is where this gets consequential, and both of these models are routinely described as “open source” when neither is.

FLUX 3 Klein ships under the FLUX Kommunity License v1.0, which makes the weights available “for your non-commercial and non-production use or commercial use as a Qualifying User”. The definition of that term is the whole test, and it is refreshingly concrete: “‘Qualifying User’ means you, if at any time you together with your affiliates’ gross annualized revenue is less than US$5,000,000.”

Under five million dollars a year and you can sell what you make with it. The licence also states that outputs are not derivatives, which is the clause that matters for anyone generating commercially. Above that line, you are in non-commercial territory and need to talk to Black Forest Labs — and non-commercial is defined tightly enough to be worth reading, excluding revenue-generating activity, anything with direct impact on end users, and training or distilling other models for commercial use. Section 4 carries a separate list of prohibited uses. The base repository is also gated, so expect to accept terms before the download starts.

MiniMax draws its line in a different place, and its ComfyUI page flags the difference rather than leaving you to find it: the image model’s licence is not the same as the original MiniMax H3 licence, and it requires “a separate, prior written authorization from MiniMax… if the Annualized Revenue of you and/or your affiliates exceeds 1 Million USD, or, you provide Hosted Service(s) to any Third Parties.”

So two models trending in the same week, both free to download, with commercial thresholds a factor of five apart — and one of them also catching anyone who puts it behind a web front end for other people, at any revenue. If you are building something you intend to charge for, that sentence is a more expensive thing to get wrong than the download size.

None of which is an argument against running these locally. Both are genuinely good and both will run on hardware you probably own. It is an argument for doing two pieces of arithmetic before you start the download rather than after: add up the files, and read the revenue threshold. The second of those caught this site’s earlier look at local image-to-3D out as well, where the licence badge on the page and the licence in the file said different things — twice in six days is starting to look less like coincidence. If you are setting up from nothing, the local-model starting guide is the place to begin, and disk space is the first thing to check.

Sources

Every figure in this article traces to one of these. Dates are when the page was read.

  1. FLUX 3 Image Klein for ComfyUI — model card
    Black Forest Labs on Hugging FaceAccessed Nov 11, 2026Official docs
  2. FLUX Kommunity License v.1.0
    Black Forest LabsAccessed Nov 11, 2026Official docs
  3. FLUX 3 Image Klein — base model repository
    Black Forest Labs on Hugging FaceAccessed Nov 11, 2026Official docs
  4. MiniMax H3 Image for ComfyUI — model card
    Comfy-Org on Hugging FaceAccessed Nov 11, 2026Official docs
  5. MiniMax H3 Image
    MiniMaxAI on Hugging FaceAccessed Nov 11, 2026Official docs
  6. comfy/model_management.py (master)
    comfyanonymous/ComfyUIAccessed Nov 11, 2026Official docs

Written by

Kai Devlin AI Automation Engineer

Full-stack developer who builds and runs AI automation systems in production. Runs local LLMs on personal hardware, builds N8N pipelines that actually ship, and deploys on Cloudflare Pages. Every guide on Pipeline Monk is tested on real consumer hardware — a Ryzen 7 5800HS with 16GB RAM and a GTX 1650. If it works on that, it works.