Black Forest Labs released FLUX.3 Image Klein, a 5.6-billion-parameter 02 open-weights image model, on October 15, 2026 01. The company says its INT8 build runs on GeForce RTX cards with as little as 8 GB 04 of video memory. Its hosted endpoint charges $0.009 08 per image at 1K resolution, according to the company's release notes. One model now has two homes: a metered API and the graphics card under a creator's desk.
At that price, one million images cost $9,000 25 in API fees. On a card the user already owns, the same million cost electricity. That gap decides where an image product sends its default request, and most teams still file it under specs.
No launch report counts how many 8 GB 04 NVIDIA cards are in use. The claim we can defend is reach, measured in hardware that qualifies, and we will keep the argument at that size.
The Owned-Hardware Threshold
A model stops being an API purchase once its smallest useful build fits in memory the customer has already paid for. Two releases show the pattern. Black Forest Labs shipped Klein at 5.6B 07 parameters. LightOn shipped LightOnOCR-3 for document work in sizes from 0.8B 03 up to 4B. It handles layout boxes and chart-to-table extraction.
The four figures that decide where a render runs
The Owned-Hardware Threshold has three gates, and a product crosses only when all of them open. The first is memory. Black Forest Labs puts the generator weights at 11.2 GB 10 in BF16 and 5.6 GB 11 in FP8, and says the INT8 build fits 8 GB 04 cards. Its ComfyUI repository on Hugging Face gives the RTX 3070 as an example card.
The second is speed. NVIDIA-measured figures cited by Black Forest Labs put step-distilled INT8 generation at 16 12 steps at about 4 seconds per 1-megapixel image on an RTX 5090, and under 9 seconds on an RTX 4070. Distillation does most of the work here. It trains a model to finish in fewer passes, so the distilled Klein runs 16 16 steps where Klein Base runs 50 17.
The third is permission. Klein ships under the FLUX Kommunity License, published with the weights on Hugging Face. The terms allow free commercial output generation for individuals and companies under US$5 million in gross annualized revenue, affiliates included. A model can clear memory and speed and still stall at this gate once a company grows past that line.
Deciding Local First Before Benchmarks Settle
The evidence supports one decision now and leaves two open. A desktop creative tool should build a local path for its heavy users this quarter. Whether that path becomes the default for every user depends on numbers nobody has published yet.
Black Forest Labs' own wording is inconsistent. The INT8 claim says 8 GB 04. The release notes say the open weights run on consumer GPUs "down to an RTX 3090," which is a 24 GB 21 card. The press release says "consumer GPUs and laptops."
Some napkin math accounts for part of the gap. According to the Hugging Face model card, the 5.6B 07 label covers only the image transformer, and Qwen3-VL-4B-Instruct is a separate text encoder. At one byte per parameter in INT8, that comes to about 5.6 GB 11 plus 4 GB, or 9.6 GB 26 before any working memory. Nobody has said whether 8 GB 04 cards hold both at once or load them in turns, and the answer determines real latency.
The prompt upsampler is a third piece. The model card is blunt: "Do not use the model without a prompt upsampler." It also allows "any LLM you prefer" for that step. So a product can run the upsampler in the cloud and keep the image work on the user's card.
The call comes down to cash flow. At $0.009 08 per 1K image, a user making 300 27 images a month costs $2.70 in API fees. No install wizard or support ticket costs less than $2.70. For that user, the API stays the right default.
The heavy user flips the math. Black Forest Labs lists the 4K tier at $0.036 09, four times the 1K 08 price. A developer writing on dev.to reports that a single 4K render through OpenRouter took about 75 seconds 18. A studio running hundreds of 4K edits a day pays for that work and waits on it, even though it may fit on hardware the studio already owns, pending testing.
Quality is the unknown that could reverse all of this. Black Forest Labs says internal evaluations rank Klein first in text-to-image and image editing, and above Ideogram V4.5 and FLUX.2 [pro]. The company makes the same claim for multi-reference generation. Those are the company's own tests, and they tell us nothing about the INT8 build on an 8 GB 04 card. We think builders should read that ranking as a reason to test, and nothing more.
Three signals would change the call. Independent tests could show INT8 output degrading on typography or hands. Measured failure rates on 8 GB 04 cards could swamp a support team.
Where the local default could still break
Transformer plus encoder exceeds the 8 GB 04 claim.
The 5.6B 07 transformer and the Qwen3-VL-4B text encoder come to about 9.6 GB in INT8 before working memory. Nobody has said whether 8 GB cards hold both at once or swap them, and that answer sets real latency.
Growth can close the permission gate.
The FLUX Kommunity License allows free commercial output only under US$5 million in gross annualized revenue, affiliates included. A product can clear memory and speed and still stall here once it scales.
Each precision halving lowers the hardware floor.
Black Forest Labs lists 11.2 GB 10 in BF16 and 5.6 GB 11 in FP8, and the NVFP4 build needs about 2.8 GB of weights. Every halving moves the floor down to a cheaper class of card.
Per-Image Billing Narrows by 2029
The long arc runs through memory halving. On launch day, Black Forest Labs listed 11.2 GB 10 for BF16 and 5.6 GB 11 for FP8. The NVFP4 build stores each weight in half a byte, so the same 5.6B 07 transformer needs about 2.8 GB 29 of weights. Every halving moves the floor down to a cheaper class of card.
Price moved on the same day. The dev.to developer reports that the flagship FLUX.3 Image starts at about $0.041 19 per image on OpenRouter. Black Forest Labs lists Klein's lowest tier at $0.008 20, a ratio of about 5.1 30 to 1. Cheaper and smaller showed up in the same release.
A heavy user making 200 31 images a day at 1K 08 pays $1.80 daily in API fees. That is $657 32 over a year and about $1,971 33 over three. The light user at 300 34 images a month pays $97.20 across the same three years. These are two customers who want different products, and the threshold separates them cleanly.
The risk is lopsided. A local path costs a team some engineering weeks plus an ongoing support load. Skipping it leaves room for a rival to offer unlimited generations with no per-image cost on its own servers. At that point per-image pricing becomes the fee customers route around.
API-first vendors have a harder move to make. Their revenue is the per-image fee, so matching a free local tier eats into their own income. Black Forest Labs sells the endpoint and gives away the weights, and its press release presents Klein as building on the earlier open-weights release of FLUX 3 Action. That two-sided bet is counterpositioning against any vendor that only sells calls.
By 2029, per-image billing might survive mainly for light users and machines without a qualifying card. The 4K jobs may stay there too. The date is our projection from a single release cycle. One cycle is thin evidence, and the next memory halving will test it.
Route Each Render Through a VRAM Check
The build is a small router that checks the machine, runs Klein locally when it fits and calls the API when it does not. VRAM is the memory on the graphics card, separate from the computer's main RAM. INT8 means each model weight is stored in 8 bits, or one byte.
Step one: read the hardware by running nvidia-smi --query-gpu=name,memory.total --format=csv on each NVIDIA machine. Save the output with the machine name. Any card under 8 GB 04, or any non-NVIDIA card, goes straight to the API branch.
Step two: install the INT8 files from Black Forest Labs' flux-3-image-klein-comfy repository on Hugging Face. The repository asks you to accept license conditions before download. Load the distilled transformer and the int8 text encoder in ComfyUI. If memory runs short, point the upsampler step at a hosted LLM.
Step three: generate 20 images at 1K 08 and record seconds per image plus peak memory from nvidia-smi during the run. Expect an out-of-memory error on the first attempt. That error means the card ran out of VRAM. Lower the resolution or offload the text encoder, then rerun.
Step four: write the routing rule from your own measurements. If the median image finishes under 10 seconds with zero memory errors, local becomes the default on that machine. Otherwise, the request goes to the Klein endpoint at $0.009 08 per 1K image. Send 4K requests to the API at $0.036 09 until a local 4K run passes the same test.
Step five: log cost per image on both branches for one week, and rerun the benchmark after every driver update. If it does not, the router still works with only the API branch switched on.
Build a VRAM router for every render
- Read the hardware. Run nvidia-smi --query-gpu=name,memory.total --format=csv on each NVIDIA machine and save the output. Send any card under 8 GB 04 or any non-NVIDIA card straight to the API branch.
- Benchmark 20 images at 1K 08. Load the distilled INT8 transformer and int8 text encoder from the flux-3-image-klein-comfy repository in ComfyUI, then record seconds per image and peak memory. On an out-of-memory error, lower resolution or offload the text encoder and rerun.
- Write the routing rule from your numbers. If the median image finishes under 10 seconds with zero memory errors, make local the default on that machine. Send everything else, and all 4K jobs, to the endpoint at $0.009 or $0.036 09 per image.
Heavy users belong on the card they own, and light users can stay on the API.
At $0.009 08 per 1K image, a 300-image-a-month 27 user costs $2.70 and the API remains the sensible default. A user making 200 33 images a day pays about $1,971 over three years, which pays for a local path many times over. Quality on the INT8 build is still unproven, so we would ship the router with measurements attached and rerun them after every driver update. Teams that build the local branch this quarter keep their options open while the benchmarks settle.