Qwen3.8-27B-Uncensored-HauhauCS-Aggressive — AWQ W4A16 (MTP preserved)

4-bit AWQ (W4A16, group 128, asymmetric) build of HauhauCS/Qwen3.8-27B-Uncensored-HauhauCS-Aggressive-MTP-GGUF, with the native NextN/MTP draft head kept intact for speculative decoding under vLLM.

19 GB on disk. 9.66 GiB of weights per GPU on a 2xRTX 3090 (TP=2), leaving room for a 560,900-token KV cache at fp8.

Provenance — read this first

HauhauCS released this model as GGUF only. There is no upstream BF16 safetensors checkpoint to quantize from, so this build was produced by reconstructing one:

Qwen3.8-27B-Uncensored-HauhauCS-Aggressive-Q8_K_P.gguf   (29.3 GiB, sha256 4e7735df4d1e...)
mmproj-...-Aggressive-BF16.gguf                          (vision tower, bf16)
        |
        +- dequantise + reconstruct -> BF16 HF safetensors (52 GB)
        |
        +- llm-compressor AWQ -------> W4A16 compressed-tensors (19 GB)   <- this repo

This is a quant of a Q8_K_P quant, not of the original weights. The ~8-bit source error is baked in and compounds with the 4-bit step. If HauhauCS ever publishes BF16 safetensors, a build made from those should be preferred over this one.

The vision tower is the exception: the mmproj GGUF ships bf16, and the tower is excluded from quantization, so it is bit-identical to upstream.

Why a reconstruction was needed

qwen3_5 is a hybrid architecture — 64 decoder layers, of which 48 are Qwen3_5GatedDeltaNet linear-attention and 16 are full attention (layer N is full-attention iff N % 4 == 3) — plus a 27-layer vision tower and an embedded NextN head. No off-the-shelf GGUF-to-HF converter handles it, so the mapping was written from scratch and proven total and bijective: 866 GGUF tensors <-> 866 non-vision HF tensors, plus 334 mmproj -> 333 HF vision tensors.

Three llama.cpp storage conventions had to be inverted. Each one loads and runs happily if you get it wrong, and produces fluent nonsense:

The value-head ordering is the one that hurts. It affects in_proj_qkv, in_proj_z, out_proj and conv1d on all 48 linear-attention layers. With it wrong the model loads, serves, and answers every prompt with degenerate repetition.

Dequantization is done in fp32, not bf16: bf16 eps at 1.0 is 0.0078, so a norm weight of 0.9666 rounds to 0.96875 and subtracting 1.0 yields -0.03125 against a true -0.0334 — a 6% error on every normalization weight in the model.

Verification

Reconstruction was gated on a numeric check against a different fine-tune of the same base, so it validates layout and storage convention, not weight identity:

• Correlation sweep — every linear-attention tensor at +0.99998; A_log/dt_bias +0.97917, norm.weight +0.99219 (small tensors, at the Q8_0 noise floor). This is the check that catches permutations; the broken build scored 0.04–0.73 here.
• Norm-offset sweep — all 19 norm families at +/-0.00000, confirming no residual +1.

Correlation cannot prove the weights are right, only that they are in the right shape and convention. The behavioural tests below are what establish the model works.

Quantization recipe

Left in bf16 (ignore): lm_head, the entire 27-layer vision tower, the in_proj_a / in_proj_b delta-rule scalars on all 48 linear-attention layers, and the MTP head.

If you re-quantize this yourself: llm-compressor never sees model-mtp.safetensors, so the ignore list it emits omits the MTP module entirely. You must add re:.*mtp.* and re:mtp\..* to quantization_config.ignore by hand, or vLLM builds the drafter as W4A16, fails to find weight_packed, silently skips every MTP tensor and dies with KeyError: 'weight' in qwen3_5_mtp.py.

Validation

All measured on this build, 2xRTX 3090 (TP=2), vLLM nightly, fp8 KV cache, MTP n=3.

Speed

Throughput on this build is workload-dependent by roughly 30%. MTP acceptance is much higher on predictable text than on varied prose, so tokens/second is a property of the prompt as much as of the model. No single figure is meaningful without the prompt that produced it.

Pinned measurement, 2026-08-21 — single-user (c=1), thinking disabled, 600-token generations, temperature 0, with the repetition_penalty: 1.05 default this card recommends:

Run-to-run spread was under ±1 t/s in every cell. Prompt content costs about 30%; the GPU power limit costs about 2%.

An earlier head-to-head against the Qwen3.8-27B-abliterated W4A16 build, taken in a single controlled session on the same box with the same harness and settings. The prompt was not recorded, so read this as a relative result only and not as absolute throughput:

MTP acceptance rate 64.9%, mean accepted length 2.95 of 4 — the draft head is genuinely doing work, which is where the margin over the comparison build comes from.

No standardized benchmarks (MMLU, GSM8K, etc.) were run. The numbers above are functional and performance checks, not a quality evaluation. Treat quality as unmeasured.

Recommended sampling settings — read this before you file a bug

Do not use greedy decoding (temperature: 0) with this model. It will emit the same sentence over and over until it hits your token cap and never produce a stop token. This is the classic Qwen3 + quantization degenerate-repetition mode, not a defect in the weights, and it is fully reproducible: greedy is deterministic, so the same prompt loops the same way every time.

generation_config.json in this repo now ships a repetition_penalty of 1.05, which is enough to prevent it. If your stack ignores generation_config.json, set it yourself:

Measured on this build, greedy worst case, 6000-token cap:

The penalty is not free — it costs about 6% throughput. Interleaved A/B/A/B on the same box, thinking disabled, 600-token generations, c=1: 68.4 / 67.1 t/s median with the penalty off versus 64.3 / 63.6 t/s at 1.05. That is the price of not looping; we think it is worth paying by default, and you can lower it to 1.02 if you would rather have the throughput.

It does not otherwise cost you anything measurable. Checked at 1.05 against penalty-off on the tasks a repetition penalty is most likely to damage — all identical:

Do not go much above 1.10 — that is where repeated code syntax and identifiers start being penalized.

Two traps if you try to fix this yourself

• presence_penalty will not work as a server-side default in vLLM. vLLM only carries a fixed whitelist out of generation config into its default sampling params — repetition_penalty, temperature, top_k, top_p, min_p, max_new_tokens (ModelConfig.get_diff_sampling_param). A presence_penalty entry is silently ignored.
• presence_penalty and frequency_penalty cannot be defaulted at all over the OpenAI API, because the OpenAI schema defaults them to 0.0 — clients always send them explicitly, so your default never applies. repetition_penalty defaults to None on the request and is filled from the server's defaults, which is why it is the only lever that survives a client setting its own temperature.

Why your client probably will not save you

Coding agents commonly pin temperature: 0 for determinism and send no penalty at all. Two checked as of 2026-08-21: one sends no temperature when thinking is enabled but hardcodes temperature: 0 on its sub-agent and skill paths; the other sends no temperature and no penalty of any kind, ever. In both cases every request rides entirely on the server defaults.

Optional: chat_template_medium.jinja

This model's stock chat template defaults reasoning_effort to xhigh, which spends the whole budget thinking and returns an empty answer on a large fraction of requests. The default chat_template.jinja in this repo is unmodified upstream — we did not silently change the behaviour of a redistributed artifact.

For convenience an opt-in copy is included as chat_template_medium.jinja, byte-identical except for one line, which defaults reasoning_effort to medium instead:

-{%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
+{%- set resolved_reasoning_effort = reasoning_effort|default('medium') %}

Use it with --chat-template chat_template_medium.jinja, or keep the stock template and pin the value per-request with --default-chat-template-kwargs as shown below. Both work; the flag merges per-key, so clients sending their own chat_template_kwargs stay covered.

Serving with vLLM

vllm serve /path/to/this/repo \
  --served-model-name qwen3.8-27b-hauhau-aggressive \
  --tensor-parallel-size 2 \
  --max-model-len 262144 \
  --gpu-memory-utilization 0.95 \
  --max-num-seqs 4 \
  --max-num-batched-tokens 4096 \
  --kv-cache-dtype fp8 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder \
  --enable-prefix-caching --enable-chunked-prefill \
  --compilation-config '{"cudagraph_mode": "PIECEWISE"}' \
  --speculative-config '{"method":"mtp","num_speculative_tokens":3}' \
  --default-chat-template-kwargs '{"enable_thinking": true, "reasoning_effort": "medium"}'

Notes from getting this stable on 2x3090:

• Pin reasoning_effort to medium. The Qwen3.8 chat template defaults to xhigh, which spends the entire budget thinking and returns an empty answer. Measured on this build over 4 hard prompts: at xhigh, 2 of 4 produced no answer at all (~5,400 words of reasoning, then finish_reason=length); at medium, 0 of 4 failed, averaging ~529 words of thinking and ~954 words of answer. The flag merges per-key, so clients sending their own chat_template_kwargs are still covered.
• cudagraph_mode: PIECEWISE, not FULL — FULL replay segfaults with MTP (vllm#40756) at identical c=1 throughput.
• On 3090s without working P2P, set NCCL_P2P_DISABLE=1 and --disable-custom-all-reduce.
• Streaming tool calls need a patched qwen3_coder tool parser on stock vLLM. Without it the <tool_call> tag is emitted as prose content and the subsequent SSE chunks go silent — it looks exactly like the model failing at tool use, but it is a parser bug (vLLM-side), not the weights. The "streaming tool calling: PASS, no tag leakage" result in the validation table above was produced with that patch applied.

Files

HauhauCS FastMTP is not used here — that is a llama.cpp-only draft sidecar needing his runtime patch. This repo carries the native embedded NextN head (blk.64 -> mtp.*), which the reconstruction preserves and vLLM consumes directly.

Provenance / credit

• Fine-tune: HauhauCS — all model quality and the uncensored behaviour are theirs.
• Base architecture: Qwen team, qwen3_5.
• This repo contributes only the GGUF-to-HF reconstruction and the AWQ quantization.

As of 2026-08-18 no AWQ/W4A16 build of any HauhauCS Aggressive model appears on the Hub (searched model ids across 90 derivative repos; GGUF, NVFP4 and MLX builds exist).

Limitations

• Quantized from Q8_K_P, not from original BF16 weights — see Provenance.
• Verification establishes correct tensor layout and working behaviour, not weight-level fidelity to the upstream fine-tune.
• No standardized quality benchmarks were run.
• This is an uncensored model. It will answer requests that safety-tuned models refuse. You are responsible for how you use it.