reports/escha-w2-qwen36-35b-a3b.md

Qwen3.6-35B-A3B at 2-bit: EschaLabs' Escha-W2, independently measured

Date: 2026-08-11 · Hardware: RTX 5090 32GB (sm_120) · Runtime: EschaLabs escha-sglang wheel 1.0.2+qwen3moe (closed-source SGLang fork) · Weights: EschaLabs/Qwen3.6-35B-A3B-Escha-W2 (12.3 GB, eschamoe 2-bit experts / int8 dense)

why this run

Escha-W2 is a 2-bit quantized build of Qwen3.6-35B-A3B with an unusually rigorous vendor card (paired FP8 protocols, published KLD corpus, a reproduced 4090 grid) — and, as far as I can find, no independent quality board anywhere. This rig already carries the same base model as a GGUF row (UD-Q4_K_M, llama.cpp), so a same-model, same-harness cross-check costs one serving window: their claims, my measurement, one card.

The community pitch that prompted it ("Q8 quality, q3 speed, 1M context") is also checkable.

method

• Server: their shipped serve.sh, exact published 5090 single-user recipe (INT8=on ATTN_BACKEND=triton MEM=0.82 CTXLEN=32768), THINK=0. Server trim: 27.0 GB VRAM.
• Quality: this rig's standard five-task board (MMLU / ARC-C / HellaSwag / GSM8K / HumanEval, 50% stratified sample on MMLU+HellaSwag, seed 42, temperature 0, thinking off), run over the server's OpenAI-compatible /v1 — same evaluators, prompts, and extraction as every other row.
• Speed: streamed chat completions, decode tok/s = completion_tokens / (total − TTFT), which matches the card's own 1000/TPOT single-stream convention. Three runs per shape, median.
• 10.5k requests total, zero server failures, one serving window (50 min).

Cross-stack caveat, stated up front: the comparison row (UD-Q4_K_M) is served by llama.cpp and its 270.6 tok/s is llama-bench tg128; Escha-W2 runs the vendor's own SGLang-fork runtime measured under chat-server conditions. Quality numbers are apples-to-apples (same harness, same items over HTTP in both cases); the speed comparison spans two serving stacks — that is the point of the run, but it is not a kernel-for-kernel quant comparison. Note the conventions differ conservatively: chat-server conditions typically read below llama-bench tg128 (template + sampling overhead), and Escha-W2 leads anyway.

results

quality — same model, same harness, 21.7 GB apart

build	size	stack	MMLU	ARC-C	HellaSwag	GSM8K	HumanEval	q_avg
UD-Q4_K_M (board row)	20.6 GB	llama.cpp	85.0	95.7	93.3	96.7	95.7	93.3
Escha-W2 2-bit	12.3 GB	escha-sglang	84.2	95.4	92.7	96.6	93.3	92.4

The 2-bit build gives up 0.9 q_avg against the Q4 GGUF of the same model. Four of five tasks sit within 0.8; the loss concentrates in HumanEval (−2.4), exactly the axis the vendor's own card flags as the one real 2-bit gap (their LiveCodeBench retention: 93.4%). Their honesty holds up.

speed — vendor claims vs measured

claim (their card, 5090)	measured here	verdict
283 tok/s single-stream decode	285.7 tok/s (median, ~128-tok prompt)	confirmed, +1%
259.6 tok/s at 2048-token prompt	262.6 tok/s	confirmed, +1.2%
~25–35 s startup	25 s to healthy	confirmed

For board context: the same model as UD-Q4_K_M runs 270.6 tok/s tg128 fully resident. The 2-bit build is ~6% faster than the Q4 GGUF while serving from a 40% smaller file. TTFT is not quoted: the single-user recipe leaves the radix prefix cache on, and repeated bench prompts hit it (first-run 307 ms at a 2k prompt, cached runs 30 ms), so a clean cold-TTFT number needs a RADIX=0 pass this window didn't include.

the community pitch, scored

• "Q8 quality" — nearly. −0.9 q_avg vs Q4 of the same model on this board, with the deficit almost entirely in code generation. Call it Q4-minus-a-little, not Q8.
• "q3 speed" — undersold. It is faster than the Q4 GGUF, not merely Q3-class.
• "1M context" — not supported anywhere on the vendor card. Shipped recipes cap at 32k per request; RULER is measured to 128k. The "1.4M token pool over 32 agents" reading conflates the shared KV pool across concurrent streams with per-request context.
• "no other 35B for GPU should be run again" — on a 32GB card, the Q4 GGUF remains the better pick: +0.9 quality, same speed class, open runtime. The 2-bit build's real win is the footprint — it puts this exact model on 16 GB cards where the Q4 GGUF cannot fit at all.

honest limits

• The runtime is a closed-source wheel (escha, SGLang fork + proprietary CUDA kernels). The numbers are real; the kernels are not inspectable. That is a trust decision each operator makes.
• Batched throughput (their ~2,670 tok/s @ bs32 claim) and the 16 GB-card recipes were not measured — single serving window, single-stream focus.
• Thinking-ON evals (their MMLU-Pro / MATH-500 / GPQA numbers) were not re-run; this board is think-off by construction. Their thinking-on claims remain vendor-reported.
• MC tasks here use generative letter extraction, not loglikelihood — consistent within this board, not directly comparable to their commonsense-6 absolute numbers.

raw

results/escha-w2-qwen36-35b-a3b/ — quality_escha.json, speed_escha.json, per-task *_detail.json. Chart: chart_escha_quadrant.png.