Upload reports/escha-w2-qwen36-35b-a3b.md with huggingface_hub

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

@@ -0,0 +1,87 @@
+# 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](https://huggingface.co/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](chart_escha_quadrant.png).