Flux 2 Klein 9B in ComfyUI: A Local Performance Test

Running the new Flux 2 Klein 9B model locally changes the game for interactive visual intelligence in 2026. In this guide, I will show you how to set it up directly inside ComfyUI, providing an in-depth look at its architecture, workflow configuration, and local performance benchmarks.

Written by Matteo Giardino.

What is Flux 2 Klein 9B?

Flux 2 Klein is an open-source (Apache 2.0) interactive visual intelligence model that has recently taken the AI community by storm. With 9 billion parameters, it strikes an impressive balance between quality and local execution capability. Instead of relying on cloud APIs, I decided to test it locally to see if it lives up to the hype. Developed by Black Forest Labs, this model introduces novel architectural improvements over its predecessors. It utilizes an enhanced flow-matching mechanism and a hybrid transformer architecture, significantly reducing the computational overhead required for high-resolution image synthesis.

You can download the model weights directly from the official Hugging Face repository.

Explore more AI tutorials

Read the guide

Hardware Requirements

Before diving in, make sure your machine is ready. Running a 9B visual model requires a decent amount of VRAM. I tested it on an Apple Silicon Mac with 32GB of unified memory, but a dedicated NVIDIA GPU with at least 12GB of VRAM will work seamlessly. If you are running on lower-end hardware, you might need to enable memory-efficient attention (like xFormers) or utilize 8-bit quantization to prevent out-of-memory (OOM) errors.

If you are building a complete local AI stack, you might also be interested in running DeepSeek R1 locally.

Setup ComfyUI for Flux 2

To get started, you need to update your ComfyUI installation and download the required weights. ComfyUI's node-based interface is perfect for experimenting with new architectures like Flux 2.

cd ComfyUI
git pull
# Install the essential custom nodes for Flux models
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

Download the Flux 2 Klein 9B .safetensors or .gguf file from Hugging Face and place it in your models/checkpoints directory. I highly recommend using the GGUF quantized versions if you are constrained by VRAM, as they maintain excellent fidelity while drastically reducing memory usage.

Building the Workflow

Inside ComfyUI, start with a basic image generation workflow. You need to load the checkpoint, connect the standard text prompt nodes, and link them to the KSampler. Because Flux 2 is optimized for interactive tasks, you will notice the prompt understanding is highly accurate.

To take full advantage of the model, you should configure the KSampler with a specific scheduler. In my experience, using euler with the simple or sgm_uniform scheduler yields the best results for the Klein architecture. Set the steps to around 20-25; pushing it higher offers diminishing returns and just burns GPU time.

If you're already familiar with setting up local AI assistants, building this graph will feel natural.

Common Pitfalls and Troubleshooting

During my testing, I encountered a few hurdles that are worth mentioning. First, if your generations appear completely black or filled with noise, ensure you are using the correct VAE. Flux 2 Klein often requires its specific VAE to decode the latents properly.

Second, if ComfyUI crashes during the decoding phase, you might be running out of system RAM (not just VRAM). ComfyUI allows you to launch with the --lowvram argument, which can help mitigate these issues by aggressively offloading layers to system memory.

Performance and Results

My local tests showed that inference times are incredibly fast for a model of this size. On my Mac (M2 Max), it generated a high-quality 1024x1024 image in under 15 seconds. On an RTX 4090, you can expect generation times well under 5 seconds. The interactive capabilities mean you can refine your prompts and see real-time adjustments without the typical lag associated with cloud-based models.

The prompt adherence is genuinely surprising. It accurately renders complex scenes, handles text generation natively, and adheres to strict stylistic constraints.