# FLUX 3 Image Klein Guide: 8GB VRAM Setup, Prompt Upsampler, and ComfyUI Workflows

Run FLUX 3 Image Klein on 8GB VRAM with ComfyUI. Learn INT8 setup, prompt upsampling, editing, checkpoints, API pricing, and fixes.

Canonical URL: https://aiidelist.com/blog/flux-3-image-klein-8gb-vram-comfyui-prompt-upsampler

Language: en

Published: 2026-10-17

Updated: 2026-10-17

Released on October 15, 2026, **FLUX 3 Image Klein** is Black Forest Labs' 5.6-billion-parameter open-weight image generation and editing model. It supports text-to-image generation, multi-reference editing, native 4K output, and bounding-box layout control. Most notably, its INT8 variant can run on supported NVIDIA GPUs with **as little as 8GB of VRAM**.

However, the complete workflow is more demanding than the 5.6B parameter count suggests. The image transformer, Qwen3-VL text encoder, prompt upsampler, and VAE all have different memory requirements. Choosing the wrong checkpoint or skipping prompt expansion can lead to poor results, excessive loading times, or out-of-memory errors.

This guide explains how to run FLUX 3 Image Klein locally, install the correct ComfyUI models, optimize an 8GB GPU workflow, use the prompt upsampler, and create more controlled images and edits. Technical details are based on the [official Black Forest Labs announcement](https://bfl.ai/blog/flux-3-image-klein), [reference implementation](https://github.com/black-forest-labs/flux-3-image-klein), and [ComfyUI documentation](https://docs.comfy.org/tutorials/flux/flux-3-klein).

## Key Takeaways

- **FLUX 3 Image Klein is a 5.6B open-weight image model** supporting text-to-image, image editing, up to 10 reference images, native 4K generation, and bounding-box layout guidance.
- **8GB VRAM is supported with INT8**, but memory management and CPU offloading may be necessary. This does not guarantee that every high-resolution or multi-reference task fits in 8GB.
- **Prompt upsampling is central to image quality.** The model expects detailed scene captions. Black Forest Labs recommends its Qwen3.5-9B-based prompt upsampler or an alternative LLM producing equivalent captions.
- **The distilled checkpoint uses 16 sampling steps without classifier-free guidance**, while the Base checkpoint uses 50 steps and guidance 3.5 for standard text-to-image generation.
- **The recommended 8GB configuration is distilled INT8 + Qwen3-VL-4B INT8 + FLUX.2 VAE**, with the prompt upsampler executed separately or offloaded when necessary.
- **Official checkpoint filenames changed during the launch period.** Some early ComfyUI workflows reference underscore-based filenames, while the current Hugging Face repository uses hyphenated names.
- **The BFL API starts at $0.009 per 1K-resolution image**, equivalent to approximately $9 for 1,000 generations at that resolution tier, excluding other applicable charges.

## What Is FLUX 3 Image Klein?

FLUX 3 Image Klein is the compact, locally deployable image model in Black Forest Labs' FLUX 3 family. It combines several capabilities previously associated with larger image-generation systems.

Its main capabilities include:

- **Text-to-image:** Generate images from natural-language descriptions.
- **Image-to-image editing:** Modify an existing image using instructions and references.
- **Multi-reference generation:** Combine information from up to 10 reference images.
- **Bounding-box control:** Specify approximate locations and dimensions for subjects or editing regions.
- **Image typography:** Generate visual designs containing text, although spelling and layout errors remain possible.
- **Native 4K output:** Produce high-resolution images without requiring a separate upscaling model, subject to available computing resources.
- **Model adaptation:** Use the undistilled Base checkpoint for research and LoRA training, subject to licensing restrictions.

The model builds on the broader FLUX 3 research program, which uses learning across images, video, and audio to improve representations of physical structure and visual relationships. That training approach does not mean the Klein image checkpoint itself is a general-purpose video or audio generator.

### Why the 5.6B parameter count can be misleading

The **5.6 billion parameters refer to the image-generation transformer**, not every component required for inference.

The complete pipeline can involve:

1. **Prompt upsampler:** A Qwen3.5-9B-based model that expands short instructions into comprehensive descriptions.
2. **Text encoder:** Qwen3-VL-4B-Instruct, which creates conditioning information from text and reference content.
3. **Image transformer:** FLUX 3 Image Klein, responsible for diffusion-based image generation.
4. **VAE:** The FLUX.2 autoencoder, which handles image encoding and decoding.

These components do not necessarily remain loaded in GPU memory simultaneously, but their combined resource requirements explain why memory optimization matters.

FLUX 3 Image Klein should also not be confused with the larger **FLUX 3 Image** model available through hosted APIs or ComfyUI Partner Nodes. Klein is the released open-weight model intended for local execution and customization.

## FLUX 3 Image Klein vs. Klein Base: Which Model Should You Choose?

Black Forest Labs provides a step-distilled checkpoint and an undistilled Base checkpoint.

| Feature | FLUX 3 Image Klein | FLUX 3 Image Klein Base |
|---|---|---|
| Architecture | 5.6B image transformer | 5.6B image transformer |
| Model type | Step-distilled | Undistilled |
| Recommended steps | 16 | 50 |
| Guidance | No CFG; CFG 1 in ComfyUI | 3.5 for standard text-to-image |
| INT8 transformer size | Approximately 5.8GB | Approximately 5.8GB |
| Primary use | Fast generation and editing | Training, LoRA, research |
| Recommended for 8GB VRAM | Yes | Generally less practical |

### When to use the distilled checkpoint

The distilled checkpoint is the best starting point for most users. It reduces the required denoising steps while retaining the capabilities needed for image generation and editing.

It is particularly suitable for interactive creative tools, local image generation, iterative prompt development, and applications where inference latency matters.

### When to use the Base checkpoint

Base is designed for users who require greater flexibility for fine-tuning and research. It requires more sampling steps and is generally less attractive for a memory-constrained inference-only setup.

**Important:** Distillation reduces the number of inference steps, not necessarily the model's file size. The INT8 Base and distilled transformer files are approximately the same size.

Using 50 steps and CFG 3.5 with the distilled checkpoint is not the recommended configuration. Similarly, using the Base checkpoint with distilled sampling settings is not a meaningful quality comparison.

The [official reference repository](https://github.com/black-forest-labs/flux-3-image-klein) documents the model variants and their intended sampling configurations.

## FLUX 3 Image Klein VRAM Requirements: Can It Run on 8GB?

**Yes. Black Forest Labs supports an INT8 inference configuration on NVIDIA GeForce RTX GPUs with as little as 8GB of VRAM.** An RTX 3070 8GB is one supported example.

However, it is necessary to distinguish checkpoint size from total runtime memory.

### Model files and approximate download sizes

| Component | Approximate size | Purpose |
|---|---:|---|
| Distilled transformer INT8 | 5.8GB | Image generation |
| Qwen3-VL-4B INT8 | 4.9GB | Text and reference conditioning |
| FLUX.2 VAE | 0.3GB | Image decoding and encoding |
| Prompt upsampler W4A8 | 6.7GB | Prompt expansion |
| Prompt upsampler INT8 | 9.8GB | Alternative prompt expansion |
| Transformer BF16 | 11.1GB | Higher-precision inference |
| Transformer NVFP4 | 5.3GB | Blackwell-compatible quantization |

These are rounded download sizes from the publisher's model package, not measured peak VRAM consumption.

A 5.8GB transformer combined with a 4.9GB text encoder already exceeds 8GB if both must remain fully resident in GPU memory. Additional memory is needed for intermediate activations, reference images, decoding operations, and runtime overhead.

### How an 8GB workflow becomes possible

The solution is to avoid keeping every component on the GPU simultaneously.

ComfyUI can manage model loading and offloading, allowing inactive components to move into system memory when necessary. Prompt expansion can also be performed independently, leaving the image generator to consume an already-expanded caption.

The recommended approach is:

- Use the **distilled INT8 transformer**.
- Use the **INT8 Qwen3-VL text encoder**.
- Begin with one image at approximately 1MP or less.
- Keep batch size at 1.
- Allow CPU offloading when GPU memory is insufficient.
- Run prompt expansion separately if the full workflow causes memory errors.
- Avoid 4K generation and large multi-reference jobs during initial setup.

CPU offloading reduces GPU memory pressure but adds transfer overhead and can substantially increase generation time.

### INT8 vs. BF16 vs. NVFP4

**INT8:** The practical starting point for an 8GB RTX GPU. The publisher specifically supports INT8 on RTX 30-series and other compatible older NVIDIA hardware.

**BF16:** Provides a higher-precision model representation but has substantially larger weights. It is better suited to higher-memory configurations.

**NVFP4:** Offers smaller model files but requires compatible NVIDIA Blackwell hardware. An RTX 3070, RTX 3090, or RTX 4070 should not use NVFP4 merely because its download is smaller.

**FP8:** Another supported quantization route, but compatibility depends on the GPU architecture and inference implementation.

For an 8GB card, INT8 is the most reliable supported starting choice.

## How to Install FLUX 3 Image Klein in ComfyUI

The native ComfyUI route provides the most accessible local workflow for users who prefer visual configuration rather than building a custom Python inference pipeline.

### Step 1: Update ComfyUI

The [official FLUX 3 Klein ComfyUI tutorial](https://docs.comfy.org/tutorials/flux/flux-3-klein) specifies support in the ComfyUI 0.41 series, including relevant backported builds.

Update ComfyUI before downloading the model files. An outdated installation may produce missing-node errors or fail to recognize the FLUX 3-specific text encoder.

Open the ComfyUI Template Library and search for:

- `FLUX 3 Image Klein Distilled: Text to Image`
- `FLUX 3 Image Klein Distilled: Image Edit`
- `FLUX 3 Image Klein: Text to Image`
- `FLUX 3 Image Klein: Image Edit`

For the first run on limited hardware, choose the **Distilled: Text to Image** template.

### Step 2: Accept the Hugging Face license

Open the [official FLUX 3 Image Klein ComfyUI repository](https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy).

The repository is gated, meaning users must sign in and accept its access conditions before downloading the model files.

The package includes diffusion transformers, text encoders, prompt upsamplers, and the VAE. Download only the variants needed for the selected workflow.

### Step 3: Download the 8GB-friendly model files

For a current hyphenated checkpoint package, the following command downloads the distilled INT8 transformer, INT8 text encoder, W4A8 prompt upsampler, and VAE.

Run it from the directory containing your `ComfyUI` folder:

```bash
python -m pip install -U huggingface_hub
hf auth login
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 \\
  text_encoders/qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors \\
  vae/flux2-vae.safetensors \\
  --local-dir ComfyUI/models
```

**Filename warning — October 17, 2026:** The [current publisher file tree](https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy/tree/main/diffusion_models) uses hyphenated names such as `flux3-image-klein-int8-convrot.safetensors` for distilled and `flux3-image-klein-base-int8-convrot.safetensors` for Base.

Earlier official ComfyUI templates and guides may instead reference `flux3_image_klein_sd_int8_convrot.safetensors` for distilled. These naming conventions should not be mixed blindly. If a template expects an older filename, manually select the downloaded checkpoint in its loader. Confirm the current model card before using an older command.

The intended directory structure is:

```text
ComfyUI/models/
  diffusion_models/
    flux3-image-klein-int8-convrot.safetensors
  text_encoders/
    qwen3vl_4b_int8_convrot.safetensors
    qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors
  vae/
    flux2-vae.safetensors
```

**Do not replace `flux2-vae.safetensors` with a guessed FLUX 3 VAE.** The FLUX.2 VAE is the intended autoencoder for this model package.

### Step 4: Configure the native workflow

Inside the distilled text-to-image template, verify the following components.

| Setting | Recommended starting value |
|---|---|
| Diffusion model | Distilled INT8 Klein checkpoint |
| Text encoder | Qwen3-VL-4B INT8 |
| CLIP loader type | `flux3` |
| VAE | `flux2-vae.safetensors` |
| Sampling steps | 16 |
| CFG | 1 |
| Prompt upsampler | Enabled for short prompts |
| Batch size | 1 |
| Initial output | Approximately 768–1024 pixels per side |

Use the sampler and scheduler configured by the official template instead of borrowing settings from unrelated Stable Diffusion workflows.

When the image is generated, ComfyUI normally saves it through the `SaveImage` node to `ComfyUI/output/`.

### Step 5: Build a memory-efficient execution sequence

For an 8GB system, a staged workflow can be more reliable than retaining the entire graph in GPU memory.

```text
User's short image prompt
        |
        v
Prompt upsampler
(Qwen3.5 or an alternative LLM)
        |
        v
Detailed scene caption
        |
        v
Unload or offload prompt upsampler
        |
        v
Qwen3-VL-4B text conditioning
        |
        v
FLUX 3 Image Klein INT8
(16 sampling steps)
        |
        v
FLUX.2 VAE decoding
        |
        v
Generated image
```

If ComfyUI runs out of memory while loading the upsampler and image generator, perform the upsampling in a separate pass. Save the expanded caption, paste it into the image-generation workflow, and disable the upsampler for that run.

This avoids generating directly from an inadequate short prompt while reducing simultaneous memory requirements.

## FLUX 3 Prompt Upsampler Explained: Why Prompt Expansion Matters

The FLUX 3 Image Klein prompt upsampler is a separate model based on Qwen3.5-9B. It converts short requests into detailed image captions describing visual composition, subjects, materials, lighting, backgrounds, and constraints.

According to [Black Forest Labs' reference implementation](https://github.com/black-forest-labs/flux-3-image-klein), the generator performs noticeably worse when given unexpanded short prompts.

This is an important difference from workflows where users directly enter a short collection of style keywords and expect the image model to infer the rest.

### Short prompt vs. expanded prompt

**Original prompt:**

```text
A red running shoe, product photography.
```

This instruction leaves important questions unanswered: camera angle, exact number of shoes, materials, lighting, environment, and composition.

**Expanded caption:**

```text
Premium studio product photograph of a single red technical running shoe,
shown in a three-quarter side view with the toe pointing right. The shoe
has a breathable woven mesh upper, sculpted white foam midsole, black
rubber outsole, and neatly threaded red laces. It rests on a seamless
warm off-white backdrop. A large diffused softbox from the upper left
creates a gentle contact shadow beneath the sole. Keep the entire shoe
visible, with crisp material texture, balanced proportions, no hands,
no duplicate shoes, no logo, and no added typography.
```

The expanded caption provides a more complete visual specification. It reduces ambiguity and makes it easier to reproduce a particular creative direction.

### Can another LLM replace the official upsampler?

Yes. Black Forest Labs explicitly allows equivalent scene-caption expansion using another LLM.

The important requirement is to preserve the user's intended subjects and constraints while supplying the scene detail expected by the image generator.

For creators with limited GPU memory, this provides a useful architecture: perform prompt expansion on a separate service or lighter local model, then feed the resulting caption to Klein.

### Reusable prompt upsampler instruction

The following template can be used with a general-purpose LLM:

```text
Expand the user's image request into one detailed scene caption
optimized for FLUX 3 Image Klein.

Preserve all requested subjects, quantities, colors, identities,
relationships, and exact text.

Describe the final image using precise visual language:
- Subject and appearance
- Camera position and framing
- Foreground and background
- Materials and textures
- Lighting and atmosphere
- Color palette and visual style
- Elements that must remain unchanged

Do not invent additional subjects, logos, labels, or narrative details.

For image editing, describe the complete desired final scene while
preserving all unchanged attributes of the reference image.

Return only the final scene caption.
```

This approach can improve consistency across a high-volume image-generation pipeline. However, longer prompts are not automatically better. Unnecessary invented details can alter the requested composition or identity.

### Prompt upsampling should be evaluated separately

A useful comparison keeps the image model, seed, output dimensions, and sampling settings constant while varying the expanded caption.

This isolates the effects of the prompt upsampler from differences caused by the image-generation model itself.

## Best FLUX 3 Image Klein Prompting Techniques

FLUX 3 Image Klein responds to comprehensive scene descriptions rather than relying entirely on conventional keyword lists.

A practical prompt structure is:

**Subject + composition + environment + lighting + visual treatment + constraints.**

### Example 1: Photorealistic image generation

```text
Editorial travel photograph of exactly two cyclists crossing a narrow
stone bridge, both moving from left to right, framed in a wide landscape
shot. A quiet mountain village sits in the middle distance, with green
hills beyond it. Soft early-morning mist, natural overcast lighting,
realistic clothing folds, believable bike geometry, and a restrained
earth-tone palette. No extra cyclists, no advertising signage, and
no superimposed text.
```

The prompt defines the subject count, spatial relationship, camera framing, and environmental details.

### Example 2: Product image generation

```text
Commercial product photograph of a premium amber-glass skincare bottle,
standing upright on a smooth travertine surface. Centered composition
with substantial negative space above the cap. A soft warm-white
background, natural window lighting from the left, subtle realistic
reflections, and finely detailed glass texture. Minimal editorial
styling, no hands, no extra products, and no added text.
```

Product prompts benefit from explicitly defining materials, framing, lighting, and the number of objects.

### Example 3: Poster and typography

```text
Minimalist Japanese-inspired editorial poster with an off-white paper
background, a single small vermilion circle positioned above the center,
and generous surrounding negative space. Elegant restrained typography,
fine printed texture, and clean geometric composition. The only visible
English headline reads FLUX KLEIN. No additional text or logos.
```

For production typography, always inspect the generated lettering. The model can produce inaccurate characters or visually distorted words.

### Example 4: Consistent reference-based editing

```text
In <ref_image_0>, preserve the person's identity, facial structure,
hairstyle, camera angle, posture, and original background. Replace the
jacket with a deep forest-green waterproof shell featuring matte fabric,
subtle seams, and realistic folds. Maintain the original daylight,
skin tones, and depth of field. Everything except the jacket should
remain visually consistent with the reference.
```

A full result-oriented edit caption is generally more useful than a short command such as `make the jacket green`.

## FLUX 3 Image Klein Image Editing and Multi-Reference Workflows

Klein supports both single-reference edits and compositions based on multiple references.

In ComfyUI, references are loaded through the relevant image nodes and connected to the **Set Reference Multi Latent** workflow components.

The first reference is addressed as `<ref_image_0>`, followed by `<ref_image_1>` and subsequent reference identifiers.

### How to structure a multi-reference prompt

A useful prompt specifies exactly what each reference contributes.

For example:

```text
Use the character identity, hairstyle, and clothing from <ref_image_0>.
Use the architectural background and camera perspective from
<ref_image_1>. Use the warm illustrated texture and muted color palette
from <ref_image_2>. Create one coherent scene with consistent lighting,
realistic proportions, and a unified visual style.
```

This reduces ambiguity when reference images contain conflicting information.

### Why unwanted changes can still happen

Reference images guide generation, but they do not guarantee that every pixel remains unchanged.

An edit may alter facial details, accessories, lighting, nearby objects, or background textures. This is especially relevant when a short instruction leaves the desired final image underspecified.

The hosted BFL API advertises a pixel-restoration capability intended to preserve unedited areas. That should not be confused with the ordinary local generation behavior of an arbitrary ComfyUI workflow.

For exact commercial image edits, compare the output against the original and inspect high-importance regions rather than relying solely on the wording of the prompt.

## Bounding Boxes: How to Control Object Placement

FLUX 3 Image Klein supports bounding-box-based layout control. This provides a way to guide subject placement without relying entirely on descriptive spatial language.

Bounding boxes can be useful for product compositions, poster layouts, separated subjects, and certain object-movement edits.

### Understanding the coordinate formats

Two related but different formats appear in the official materials.

- **In-caption ComfyUI-style layouts:** `[top, left, bottom, right]` coordinates on a 0–1000 grid.
- **Reference CLI box files:** `[y_min, x_min, y_max, x_max]` normalized to values between 0 and 1.

The formats describe corresponding geometric relationships, but their coordinate scales differ.

### Example: Positioning two objects

```text
Wide illustrated coastal landscape at sunrise with a red hot-air balloon
<balloon_1> in the upper-left sky and a white lighthouse <lighthouse_1>
on the right-hand cliffs. Delicate painterly clouds and warm morning light.

[{"id":"balloon_1","bbox":[80,100,450,420],"desc":"A small red hot-air balloon above the coastline."},{"id":"lighthouse_1","bbox":[300,600,950,900],"desc":"A white lighthouse on a rocky cliff."}]
```

Each object identifier connects its textual description with an approximate region of the image.

**Bounding boxes are placement guidance, not hard masks.** Objects may extend beyond their assigned boxes, small requested details may not appear, and editing may affect nearby content.

The [publisher's reference implementation](https://github.com/black-forest-labs/flux-3-image-klein) documents the normalized CLI format, while the [ComfyUI model card](https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy) explains the in-caption layout format.

## FLUX 3 Image Klein Performance: Speed, Quality, and Benchmarks

Black Forest Labs positions Klein as a strong quality-versus-speed option among open-weight image-generation models.

### Reported generation speed

According to its October 15 launch measurements, the distilled INT8 model generates an approximately 1-megapixel image in:

- **About 4 seconds on an NVIDIA RTX 5090.**
- **Under 9 seconds on an NVIDIA RTX 4070.**

These are publisher-reported results measured in specific configurations. They should not be interpreted as guaranteed end-to-end generation times or as measured RTX 3070 8GB performance.

Prompt expansion, model loading, GPU memory transfers, and image decoding can add time beyond the core generation process.

### Quality compared with FLUX.2 Klein

In its internal evaluations, Black Forest Labs reports that FLUX 3 Image Klein achieves:

- **91 additional Elo points in text-to-image** compared with FLUX.2 Klein 9B.
- **70 additional Elo points in image editing** compared with FLUX.2 Klein 9B.
- Approximately **38% fewer image-generator parameters** than the 9B predecessor.

These figures come from the publisher's evaluations, not an independent universal benchmark. They should be considered evidence of the company's reported improvement rather than a guarantee that Klein wins every task or prompt.

### How to benchmark a local installation

A reproducible comparison should record:

1. GPU model and available VRAM.
2. ComfyUI version.
3. Exact checkpoint filename and quantization.
4. Original and expanded prompts.
5. Image dimensions and number of references.
6. Sampling steps, guidance, seed, sampler, and scheduler.
7. Peak memory consumption and total elapsed time.
8. Whether the model was already loaded before timing began.

This separates image quality differences from cold-start costs and memory-management overhead.

## FLUX 3 Image Klein API Pricing vs. Local Inference

The official [BFL API endpoint](https://docs.bfl.ai/api-reference/utility/generate-an-image-with-flux-3-klein) supports hosted FLUX 3 Image Klein generation and editing.

It accepts a prompt, optional reference images, output settings, and other supported parameters. The endpoint responds with an asynchronous job identifier and polling URL.

### BFL API price by resolution

| Resolution tier | Approximate price per image | Cost per 1,000 generations |
|---|---:|---:|
| 768sq | $0.008 | $8 |
| 1K | $0.009 | $9 |
| 1.5K | $0.011 | $11 |
| 2K | $0.014 | $14 |
| 4K | $0.036 | $36 |

These are published October 2026 rates. Actual charges depend on the selected tier, provider billing, and any subsequent pricing changes. Confirm current rates using [BFL's pricing information](https://bfl.ai/pricing).

**Important:** The phrase `$0.009 per 1K image` describes the price for an image in the 1K resolution tier. It does not mean that 1,000 images cost $0.009.

### Example API request

```bash
curl --request POST \\
  --url https://api.bfl.ai/v1/flux-3-image-klein \\
  --header "x-key: $BFL_API_KEY" \\
  --header "Content-Type: application/json" \\
  --data '{"prompt":"A single red ceramic mug on a warm off-white studio background, three-quarter view, soft side lighting, crisp glaze texture","resolution":"1k","aspect_ratio":"1:1","output_format":"png"}'
```

The request submits an image-generation job. Retrieve its result using the polling information supplied in the API response.

### When local inference makes more sense

Local inference can be attractive when generation volume is substantial, users need more direct control over their processing infrastructure, or image workflows require repeated experimentation without per-image API charges.

However, local inference still has hardware, electricity, maintenance, storage, and engineering costs. Self-hosting rights must also be considered separately from the commercial-output permissions in the model license.

### When the hosted API makes more sense

The API reduces setup complexity and removes the need to manage local GPU memory. It is particularly useful for initial application development, variable workloads, and operations requiring higher-resolution outputs without purchasing additional hardware.

Developers building on Cloudflare can also review the [Cloudflare Workers AI FLUX 3 Image Klein documentation](https://developers.cloudflare.com/ai/models/black-forest-labs/flux-3-image-klein/). That deployment route has its own billing and platform conditions.

## FLUX 3 Image Klein Troubleshooting Guide

The most common problems involve outdated ComfyUI versions, mismatched model files, unsuitable sampling settings, and memory pressure.

| Problem | Likely cause | Recommended solution |
|---|---|---|
| Missing ComfyUI nodes | Old ComfyUI build | Update to a version supporting FLUX 3 Klein |
| Model file not found | Template references an older underscore filename | Select the actual downloaded checkpoint in the loader |
| CUDA out-of-memory | Too many components resident or excessive image size | Use INT8, batch size 1, smaller images, and CPU offloading |
| Very slow first generation | Weight loading, upsampling, and memory transfers | Measure cold-start and warmed inference separately |
| Poor distilled output | Incorrect steps, guidance, or weak prompt | Use 16 steps, CFG 1, and a complete scene caption |
| NVFP4 load failure | Unsupported GPU or loader | Use INT8 on pre-Blackwell NVIDIA RTX cards |
| Unexpected image edits | Incomplete caption or non-strict reference conditioning | Describe the full final scene and inspect differences |
| Incorrect generated text | Probabilistic typography errors | Simplify wording and verify text after generation |
| 4K output crashes | High-resolution memory demand | Lower resolution or switch to higher-VRAM hardware |
| Prompt upsampler exceeds memory | Additional 9B-class component | Expand the prompt separately and unload the upsampler before inference |

### Why a workflow may load but produce poor images

A successful model load does not confirm that the workflow is configured correctly.

Check whether the selected transformer is Base or distilled. Then verify that the prompt has been expanded, the correct Qwen text encoder is loaded, the sampler uses suitable settings, and the VAE matches the published model package.

### Why 4K generation may fail on an 8GB card

Native 4K support refers to the model's output capability, not a universal minimum hardware specification.

Higher output dimensions increase the computational burden, and multiple high-resolution references add further memory demands. Begin at approximately 1MP, establish a reliable baseline, and scale gradually.

### Why a prompt upsampler may appear to slow everything down

Prompt expansion introduces a separate inference stage. On memory-limited hardware, switching between the upsampler and the image generator may involve substantial transfers between GPU and system memory.

Separate prompt expansion or reusable caption caching can reduce repeated overhead for similar generation requests.

## FLUX 3 Image Klein License and Commercial Use

The generator weights are released under the **FLUX Kommunity License**, rather than a fully permissive Apache-2.0 license.

According to Black Forest Labs, the license allows non-commercial use and provides a commercial-output exception for qualifying users with less than **$5 million in gross annualized revenue, including affiliates**, subject to the full license conditions.

This should not be interpreted as unrestricted permission to redistribute the weights, operate commercial model-hosting services, or commercially fine-tune and distribute derivative models.

Those uses may require a separate commercial agreement.

The Qwen3-VL text encoder and the prompt upsampler have their own Apache-2.0 licensing terms, but those terms do not replace the generator's FLUX Kommunity License.

Before deploying a production service, review the [official model license](https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy) and [BFL commercial licensing options](https://bfl.ai/licensing).

### Model limitations

FLUX 3 Image Klein can produce impressive visual content, but several limitations remain:

- Image typography may contain spelling or formatting errors.
- Prompt adherence can vary across seeds and complex compositions.
- Identity preservation is not guaranteed in every editing task.
- Bounding boxes do not provide pixel-exact masking.
- Unedited areas can change during local generation.
- Images can contain inaccurate details or reproduce biases.
- The model should not be used as an authoritative source of factual visual information.

These limitations matter especially for commercial graphics, product imagery, branding, and sensitive image-editing applications.

## Frequently Asked Questions

### Can FLUX 3 Image Klein really run on 8GB VRAM?

Yes. Black Forest Labs supports an INT8 route on compatible NVIDIA GPUs with 8GB of VRAM. However, this may require component offloading, limited output resolution, and additional system memory. Not every editing or 4K workload will fit.

### Is the FLUX 3 prompt upsampler required?

A detailed scene caption is strongly recommended. The official Qwen3.5 prompt upsampler is designed for that purpose, but an alternative LLM can produce an equivalent caption. Sending short, unexpanded prompts generally produces weaker results according to the publisher.

### Can the prompt upsampler run separately from ComfyUI?

Yes. Prompt expansion can be performed in an independent process or service. The final caption can then be passed to a local Klein workflow with its upsampler stage disabled.

### Is FLUX 3 Image Klein the same as FLUX.2 Klein?

No. FLUX 3 Image Klein is a newer model in the FLUX 3 family. Its 5.6B image transformer differs from the earlier FLUX.2 Klein models, and its text-conditioning and prompt-expansion pipeline must be configured appropriately.

### Should RTX 3070 users choose INT8 or NVFP4?

INT8 is the recommended starting point. NVFP4 requires compatible Blackwell hardware and should not be treated as a universal low-memory replacement for INT8.

### What is the difference between `_sd_` and `-base-` checkpoint names?

In early underscore-based naming, `_sd_` identifies the step-distilled checkpoint. In the currently listed hyphenated package, `flux3-image-klein-...` denotes distilled, while `flux3-image-klein-base-...` denotes Base. Always verify the active model repository because launch-period documentation may reference different revisions.

### Can FLUX 3 Image Klein generate native 4K images?

Yes. Native 4K output is supported, but significantly more computing resources may be required than for a small 1MP generation. Support for 4K does not guarantee that a full 4K workflow will run successfully on every 8GB GPU.

### Can Klein preserve every unchanged pixel during editing?

Not reliably through ordinary local generation alone. References and bounding boxes guide the output but do not guarantee pixel-perfect preservation. The hosted BFL API advertises pixel restoration as a separate capability.

### Is FLUX 3 Image Klein free for commercial use?

Qualifying users may generate commercial outputs under the FLUX Kommunity License, subject to the revenue threshold and other conditions. This does not automatically permit unrestricted commercial fine-tuning, redistribution, or paid inference hosting. The full license governs permitted use.

## Conclusion

**FLUX 3 Image Klein makes advanced image generation and editing more practical on consumer GPUs, but successful local deployment depends on understanding the entire inference pipeline rather than just the 5.6B transformer.**

For an 8GB NVIDIA GPU, the most practical starting configuration is the **distilled INT8 checkpoint, Qwen3-VL-4B INT8 text encoder, FLUX.2 VAE, 16 sampling steps, CFG 1, and a small single-image workload**.

The prompt upsampler deserves particular attention. Expanding short requests into complete scene captions can be as important as selecting the correct model settings. Performing that expansion separately also provides a useful way to reduce peak GPU memory usage.

Start with the [official ComfyUI workflow guide](https://docs.comfy.org/tutorials/flux/flux-3-klein), verify the latest model filenames in the [Black Forest Labs repository](https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy), and establish a reliable baseline before experimenting with multi-reference editing, bounding boxes, LoRA adaptation, or 4K output.