My current environment

• vLLM version: v0.17.1 (also confirmed on v0.16.1rc1 and nightly v0.17.1rc1.dev88)
• GPU: NVIDIA RTX PRO 6000 Blackwell (SM120, 96 GB VRAM)
• Model: Qwen3.5-35B-A3B (FP8 block-quantized via llm-compressor, Qwen3_5MoeForConditionalGeneration)

Bug description

--calculate-kv-scales causes catastrophic output corruption when used with FP8 KV cache on hybrid GDN+Attention models. The corruption is silent — no errors or warnings — and manifests as hallucinated inputs, topic fixation loops, and gibberish on even the simplest queries.

Root cause: calc_kv_scales() in vllm/model_executor/layers/attention/attention.py computes per-layer FP8 quantization scales from a single dummy forward pass during model profiling. In hybrid GDN+Attention models like Qwen3.5, the GDN (Gated Delta Network) layers have uninitialized recurrent state during this dummy pass. Their outputs are garbage, which feeds into downstream attention layers, producing wildly incorrect per-layer scales. These bad scales are then frozen and used for all subsequent inference, causing catastrophic FP8 quantization errors.

Fix: Removing --calculate-kv-scales (scales default to 1.0) resolves the issue completely. Default scales work correctly because typical BF16 KV activations are well within FP8 E4M3's ±448 representable range.

Minimal reproducer

# BROKEN: --calculate-kv-scales poisons scales via uninitialized GDN state
vllm serve Qwen/Qwen3.5-35B-A3B \
  --kv-cache-dtype fp8 \
  --calculate-kv-scales \
  --attention-backend FLASHINFER \
  --enable-prefix-caching \
  --default-chat-template-kwargs '{"enable_thinking": false}'

# Query: "What is 7 * 8 + 3 * 4?"
# Expected: 68
# Actual: "7 × 7 = 56" (hallucinated the input number)

# WORKING: remove --calculate-kv-scales, everything else identical
vllm serve Qwen/Qwen3.5-35B-A3B \
  --kv-cache-dtype fp8 \
  --attention-backend FLASHINFER \
  --enable-prefix-caching \
  --default-chat-template-kwargs '{"enable_thinking": false}'

# Query: "What is 7 * 8 + 3 * 4?"
# Result: 68 ✓

Isolation evidence

The Llama 3.3 test confirms the bug is specific to hybrid GDN+Attention architectures where recurrent state is uninitialized during the profile pass — not a general FP8 or FlashInfer issue.

Detailed symptoms

With --calculate-kv-scales enabled:

• Arithmetic: "7 × 8 + 3 × 4" → model answered "7 × 7 = 56" (hallucinated input). "37 × 43" → answered "39 × 26".
• Multi-turn context: Told "My name is Alexander" → responded "I don't actually know your name".
• First-request corruption: The very first request after server start is already broken — this is not cross-request state leakage.

Without --calculate-kv-scales (scales = 1.0):

• All arithmetic, factual recall, multi-turn context, and code generation tests produce correct output identical to BF16 KV cache.

Root cause analysis

calc_kv_scales() at vllm/model_executor/layers/attention/attention.py:481:

def calc_kv_scales(self, query, key, value):
    self._k_scale.copy_(torch.abs(key).max() / self.k_range)  # k_range = 448 (fp8 max)
    self._v_scale.copy_(torch.abs(value).max() / self.v_range)
    # ... scales frozen after first call

In Qwen3.5's hybrid architecture (64 layers alternating attention ↔ GDN):

1. Dummy profile pass starts with random/zero inputs
2. Early attention layers compute reasonable scales
3. GDN layers process through uninitialized recurrent state (conv_state, ssm_state) → garbage activations
4. Later attention layers compute scales from garbage → wildly wrong scales
5. During real inference, these wrong scales produce catastrophic FP8 quantization errors
6. Errors cascade through GDN recurrent state, amplifying with each layer

This does not affect pure attention models (e.g., Llama) because all layers produce reasonable activations from dummy data.

Suggested fixes

1. Skip recurrent layers during calibration: Zero or clamp GDN/Mamba outputs during the scale calibration pass so they don't poison downstream attention layer scales.
2. Multi-pass calibration: Run the calibration multiple times so recurrent state warms up before freezing scales.
3. Warn on hybrid + calculate-kv-scales: At minimum, emit a warning that scale calibration may be unreliable for hybrid models with recurrent layers.
4. Document the limitation: Note that --calculate-kv-scales should not be used with hybrid models and that default scales (1.0) work correctly.

Affected models

Any hybrid model with recurrent layers (GDN, Mamba, SSM) interleaved with attention layers:

• Qwen3.5-35B-A3B (Qwen3_5MoeForConditionalGeneration)
• Likely also: Qwen3-Next, Jamba, and other hybrid architectures