Arthemy Qwen Tuner (Simple)

Everything Z-Image knows about your words, it learns through one component: a Qwen3-4B text encoder - a real LLM, not a CLIP. It's a separate ~4B-parameter model that runs before the diffusion transformer and turns your prompt into conditioning vectors. That's why Z-Image prompts feel like prose rather than tags. And it's why, when a prompt is technically "correct" but the image misses the vibe, the fix may live in the encoder, not the sampler.

Arthemy Qwen Tuner (Simple) splits Qwen3-4B's 36 layers into six semantic zones of six layers each, and gives you a slider per zone. Push a zone's weights up or down and you change how hard the model leans on that stage of understanding - no training, no extra model files, just live weight scaling.

The six zones

From the author's map, moving from raw tokens to abstract reasoning:

• Zone 1 - Embedding (layers 00–05): tokenization and initial embedding
• Zone 2 - Syntax Low (06–11): low-level grammar
• Zone 3 - Syntax High (12–17): higher-level syntax
• Zone 4 - Semantics (18–23): meaning
• Zone 5 - Context (24–29): contextual logic
• Zone 6 - Abstract (30–35): abstract reasoning

The practical framing from the README: nudging the syntax zones changes how strictly the model adheres to grammar, while the abstract zones shift how freely it interprets the "vibe" of your prompt. As with the Z-Image tuner, treat the zone labels as the author's best guess - they're experimental, but they give you somewhere to start.

How it works (and why it won't fry your cache)

Unlike the Z-Image tuners, the Qwen tuner does not mutate weights in place. It uses ComfyUI's native patching system - lazy add_patches that reference the original weights and apply a computed strength at inference. That means it's non-destructive, stacks cleanly, and - the important bit - you do not need ArthemyTunerLoader for this side of the pack. The README says so explicitly.

The tuner finds each layer by regex-matching the layers.N. (or h.N.) keys in the encoder's state dict, skips normalization and bias tensors, and registers a patch whose strength is (your_scale − 1). A scale of 1.0 patches nothing - that layer stays stock.

Inputs and outputs that matter

• clip - the CLIP from a CLIPLoader. The pack's example workflow loads qwen_3_4b.safetensors with type lumina2, so if you're copying that setup, match it.
• mode - Real Value = your slider is the literal multiplier. Soft Value maps through 0.8 + 0.2 × value, so a slider of 1.5 becomes a gentle ~1.1. Start in Soft.
• base_strength (0–2) - a master gain that scales every zone on top of their individual values.
• Six zone floats - each defaulting to 1.0.

Three outputs: a CLIP (wire it into CLIPTextEncode - that's the whole point), an info string telling you how many patches went active, and debug_data, a dict with the per-layer strengths if you want to inspect what actually changed.

CLIPLoader (qwen_3_4b, lumina2) ──> Arthemy Qwen Tuner (Simple) ──> CLIPTextEncode ──> KSampler

Common issues

• info says 0 patches - the regex didn't match your encoder's key structure, which usually means you fed it something that isn't a Qwen3-4B file. Check the model in the loader.
• Smaller zones have barely any effect - that's normal; per-zone patches are subtle. This is a fine-control tool, not a personality transplant.
• Encoder precision - the community is genuinely split on whether a quantized Qwen encoder costs visible quality (see the fp8-vs-full debates). If your tuned encoder looks mushy, try the higher-precision file.

The one real trap: because the encoder is the filter through which all your words pass, a bad tuning corrupts every prompt equally. Keep the zones near 1.0 while you learn what each one does.