witcheer/rtx-5090-benchmarks

RTX 5090 LLM Benchmarks

Speed and quality benchmarks for quantized LLMs on NVIDIA RTX 5090 32GB, measured with llm-bench-rig.

Quality Benchmarks

Generative evaluation through llama-server chat completions. Replicates standard benchmark methodology using custom evaluators — no lm-evaluation-harness dependency.

Results are split by reasoning mode: comparing a thinking-on (reasoning) model's quality against a thinking-off model is apples-to-oranges, so the two groups are ranked separately. q_avg is the mean of the five tasks.

Thinking OFF (non-reasoning · direct answer)

Model	Params	Quant	MMLU	ARC-C	HellaSwag	GSM8K	HumanEval	q_avg
Gemma 4 31B-it	30.70B	Q6_K	87.8	97.6	92.0	97.5	96.3	94.2
Qwopus3.6-27B-Coder	27.32B	Q5_K_M	87.5	96.8	95.2	97.5	93.3	94.1
Qwen3.6-27B	26.90B	Q6_K	87.9	96.9	95.4	97.3	92.7	94.0
Qwopus3.6-27B-Coder-Compat	27.32B	Q6_K	87.9	96.7	95.3	97.8	90.9	93.7
Qwable-5-27B-Coder	26.90B	Q6_K	87.9	97.1	95.5	97.0	90.9	93.7
Qwen3.6-35B-A3B	34.66B	UD-Q4_K_M	85.0	95.7	93.3	96.7	95.7	93.3
Qwen3.6-27B	26.90B	NVFP4	87.0	96.7	94.9	97.1	90.2	93.2
Qwen3-Coder-Next	79.67B	UD-Q2_K_XL	83.7	96.0	89.3	96.0	93.3	91.7
Gemma 4 12B-it	11.91B	Q6_K	78.9	94.0	81.6	96.4	87.2	87.6
gpt-oss-20b	20.91B	Q4_K_M	78.6	94.6	74.5	94.8	94.5	87.4
Nemotron-3-Nano	31.58B	UD-Q4_K_XL	74.5	89.9	75.6	90.5	80.5	82.2
Nemotron-Cascade-2	31.58B	Q4_K_M	74.4	91.5	75.7	87.1	79.3	81.6
North-Mini-Code-1.0†	30.48B	Q6_K	73.3	60.2	70.8	95.8	86.6	77.4

† North-Mini-Code-1.0 is a reasoning model, run think-OFF for board parity. ARC-Challenge is reasoning-gated: 60.2 think-OFF to ~95 think-ON (+35), which deflates its q_avg. See the report.

Thinking ON (reasoning · extended chain-of-thought)

Model	Params	Quant	MMLU	ARC-C	HellaSwag	GSM8K	HumanEval	q_avg
Qwen3.6-35B-A3B	34.66B	UD-Q6_K	94.7	97.0	87.0	92.0	98.0	93.8
gpt-oss-120B¹	116.83B	MXFP4	89.5	95.0	80.0	97.0	98.0	91.9
Qwen3.6-28B-REAP-A3B	28.24B	Q6_K	87.7	95.0	82.0	90.0	94.0	89.7

HumanEval correction (2026-06-04). An earlier harness passed API stop sequences (\ndef, \nclass) that fired mid-reasoning, truncating inline-reasoning models before they emitted code — producing false-low scores (Qwen3-Coder-Next read 10%, not 93%). Every model has since been re-run on the fixed, reasoning-aware harness (no stop sequences, max_tokens=4096, indentation-preserving response handling). A second extraction fix (2026-06-04) makes program assembly format-agnostic — it generates candidate assemblies and keeps whichever one compiles — after Nemotron-3-Nano exposed a case where the model indents only the first body line differently (raw HumanEval read 21%; corrected to 80.5%). Do not cite any HumanEval figure published before this date.

Why two tables. Thinking-off rows answer directly; thinking-on rows emit an extended reasoning chain first. The two modes are not comparable on the same axis — including on MCQ/GSM8K — so they are ranked separately. Within a family, turning thinking on trades raw knowledge recall for reasoning depth (compare Qwen3.6-35B-A3B in both tables: MMLU 85.0 → 94.7).

¹ gpt-oss-120B runs via MoE CPU-offload (--n-cpu-moe 20) — it does not fit 32GB VRAM (59GB model); ~30GB VRAM + the rest in system RAM, ~47 tok/s generation. It and the other two thinking-on rows were run on a ~100-item-per-task subset (MMLU 2/subject).

Sampling. MMLU & HellaSwag use 50% stratified sampling (seed=42); ARC-Challenge, GSM8K, and HumanEval run the full item counts (HumanEval = all 164). Full per-model reports in reports/.

Methodology

Benchmark	Dataset	Few-shot	Scoring	Items
MMLU	cais/mmlu	5-shot	Letter extraction (A/B/C/D)	14,042
ARC-Challenge	allenai/ai2_arc	25-shot	Letter extraction	1,172
HellaSwag	Rowan/hellaswag	10-shot	Letter extraction	10,042
GSM8K	openai/gsm8k	5-shot CoT	Exact numeric match	1,319
HumanEval	openai/openai_humaneval	0-shot	pass@1 (code execution)	164

All benchmarks run at temperature=0. MCQ and GSM8K use max_tokens=2048; HumanEval uses max_tokens=4096 with no stop sequences (reasoning models emit code only after long inline reasoning — premature stops were the bug corrected above). Multiple-choice tasks use generative letter extraction instead of loglikelihood scoring — scores are internally consistent for model comparison but may differ from logprob-based evaluations by 5-15%.

Full per-model reports with MMLU category breakdowns, parse reliability stats, and speed data: reports/

---

Speed Benchmarks

What's measured

• Prompt processing (pp): parallel batched token throughput at context lengths 128, 512, 2048, 4096, 8192, 16384
• Text generation (tg): sequential autoregressive token throughput at 128 tokens
• All models fully GPU-offloaded (ngl=99)

Speed data schema

Column	Description
model	Model name
architecture	Dense or MoE (with active param count)
params_b	Total parameters in billions
quant	Quantization method
size_gib	File size in GiB
engine	Inference engine (llama.cpp or vLLM)
backend	Compute backend (CUDA)
gpu	GPU model
vram_gb	VRAM in GB
test	Benchmark test (pp128, pp512, ..., tg128)
tokens_per_sec	Throughput in tokens/second
stddev	Standard deviation
date	Benchmark date

Key findings

MoE (3B active) vs Dense (27B) on same-family Qwen3.6 models:

• Prompt processing: 2.4x faster across all context lengths
• Text generation: 3.5x faster (271 vs 77 t/s)
• Both degrade ~17% at 16K context (attention + VRAM, not parameter count)

---

Field Reports

One-shot investigations that don't fit the leaderboard format — claim verification, new-architecture probes, and consumer-hardware autopsies, all measured on the same rig. Newest first.

Report	Finding
Z-Image-Turbo on a 5090: few-step distillation, measured · chart · samples	First RTX-5090/sm_120 numbers for Z-Image-Turbo, an open-weights (Apache-2.0) 6B text-to-image DiT with a Qwen3-4B text encoder, measured out-of-box (bf16, SDPA, no torch.compile, no quant). A 1024px image takes 3.18s (~19/min), a 512px one 0.83s. The "turbo" is distillation from the ~50 denoising steps a normal diffusion model runs down to 8, and compute is exactly linear in the step count (each step is one DiT forward): 1.69s at 4 steps, 3.20s at 8, 6.23s at 16, with 4 steps near-indistinguishable from 8 on portraits. Resolution is the real cost, not memory: 0.83/3.18/9.99/23.36s at 512/1024/1536/2048, super-linear because attention scales with pixel count squared. The whole model fits a 32GB card at every tested size (true per-image peak 20.4/21.7/24.6/28.8GB), so 2048px keeps ~4GB of headroom: a time wall, never a VRAM wall. The classically-hard cases hold at 8 steps, where it renders exact text on a sign ("WITCHEER", letters correct) and draws exactly-N objects on request, with colours and spatial relations landing too (sample grid attached). Measurement note: per-image VRAM comes from torch.cuda.max_memory_allocated() with reset_peak_memory_stats() each iteration, because nvidia-smi over-reports. PyTorch's caching allocator retains its high-water mark and never releases it between generations, flattening a naive VRAM curve to a wrong constant. Speed and footprint only; a GenEval quality pass (its mmcv/mmdet detector needs a from-source sm_120 build) is the natural follow-up. Companion to the ACE-Step music bench, the other few-step distilled generator on this rig.
Nemotron-TwoTower autopsy: a 2.4x speedup that costs a second 30B model · chart	NVIDIA's Nemotron-TwoTower is a diffusion LM adapted from a frozen autoregressive Nemotron-3-Nano-30B that generates 2.42x faster than plain AR at 98.7% quality (arXiv 2606.26493) — clever, and datacenter-only by construction. The speedup comes from running two full 30B backbones co-resident: a frozen context tower plus a trained denoiser that unmasks several tokens per diffusion step. The checkpoint ships both stacks (126GB bf16, 63B params) and the card requires 2x80GB (59GB/GPU). The towers can't be shared (the paper's own ablation: tying is "substantially worse") or run sequentially (the denoiser cross-attends to and seeds Mamba state from the live context tower every block-step), so the 2.42x is bought by doubling the model's resident memory. The comparison that matters: on one RTX 5090, speculative decoding already delivers the same multiplier for a draft head in single-digit GB — from this rig's t036 spec-decode run on Gemma-4-26B-A4B (sm_120): MTP 2.13x, DFlash 2.19x, EAGLE-3 1.69x, for ~0-2GB of drafter (MTP ships inside the model). Same ~2.2x speedup, ~60x the memory. Two honest caveats: different mechanisms on different models (an architectural argument, not a controlled A/B — TwoTower won't run on the rig), and TwoTower's 2.42x is measured vs plain AR with no speculative-decoding baseline, so against a production AR server already at ~2.2x via spec-decode the marginal win mostly disappears while still costing a second 30B backbone. Doesn't run on consumer hardware at all: 126GB exceeds a 96GB box even fully offloaded, no quant of the custom trust_remote_code arch exists, and the mamba_ssm/causal_conv1d kernels are the usual Blackwell build wall. The two HF repos are the same checkpoint (config + shard sha256 identical; -Labs- adds inference.py). Arithmetic autopsy from the published artifact, no 5090 run. Companion to the GLM-5.2 datacenter-only autopsy and the spec-decode three-way.
Making music on a gaming GPU: ACE-Step 1.5 writes a 4-minute song in 1.75s · chart	First RTX-5090/sm_120 numbers for ACE-Step 1.5, an open-weights text-to-music model. One gaming GPU generates a full 4-minute song in 1.75s of compute (2B turbo, DiT-only, bf16, 8-step, batch 1) — level with the model authors' own A100 claim (~1-2s) and ~6x past the RTX 3090 (<10s), at 137x real-time. The higher-quality XL 4B tier costs ~1.65x the time (2.9s, 83x) and ~60% more VRAM (14.8 vs 9.4GB); both fit far inside 32GB, and XL would run on a 16GB card. Real-time factor RISES with length — 81x at 30s to 137x at 4min — because the turbo model's step count is fixed at 8 (distilled from ~50), so a 4-minute track is ~5x the compute of a 30-second one, not 8x. Measured out-of-box with no torch.compile and no quantization: a floor, not a ceiling. Speed only — audio quality is left to the ear (paired 2B-vs-XL samples), a prompt-alignment score the natural follow-up. Companion to the DiffusionGemma AR-vs-diffusion null.
Bias-only steering: nothing moves at bounded budget, and random rewards match correct ones · chart	Bias-Only Reasoning Steering (arXiv 2505.18706, EMNLP 2025) claims RL-training one bias vector per layer (~0.0016% of params, added to mlp.down_proj) matches full RL fine-tuning: Qwen2.5-Math-7B MATH500 52.2 to 79.9 (steering even beats full-FT). Their pinned stack is dead on arrival on consumer Blackwell — torch 2.6.0+cu124/vllm 0.8.5 fails its first kernel launch on sm_120 — so the recipe was reimplemented from their own configs (RLOO, steering lr 1e-3, qwen_math template, DeepScaleR) at a matched bounded budget (20 steps x 8 prompts x 8 generations, ~1,280 rollouts vs their ~645K), plus the controls neither paper reports: their-own-config LoRA (r4, down_proj only), random-reward steering (Spurious-Rewards protocol), and a zero-training 'To'-prefix probe of their companion paper's first-token-substitution mechanism. A five-arm null: base 54.6 MATH500 / 45.0 AMC23 (reproduces their 52.2/45.8 starting point), steering 54.4/45.0, LoRA 53.8/40.0, random-reward steering 54.2/45.0, 'To'-prefix 53.0 — every arm is the base. Correct rewards buy nothing over coin flips at this budget, and the claimed ~10-11pt 'To'-prefix gain lands at -1.6 on the standard template, where the base's generations already open with 'To'. Wall-clock decomposition (identical across arms): rollouts 75%, backward+update 25%, grading under 1% — the '34s vs 52m' headline counts only the optimizer sliver, and the slice that shrinks with trainable-param count is ~none of a step; on 32GB the real bias-only win is memory (full-param 7B RL does not fit at all; ~100K bias params train comfortably). Bounds where the gain is not (early), does not refute their full-recipe endpoint. Steering checkpoints served in stock vLLM via a Qwen2-to-Llama re-badge (mlp_bias=true), fp32-verified logit-identical.
Ornith-1.0-35B's self-written scaffold doesn't survive a different harness · chart	DeepReinforce's Ornith-1.0 (MIT) is an RL coder that co-trains a task-specific agent scaffold INTO the weights; the 35B claims 75.6 SWE-bench Verified (the 82.4 headline is the unrunnable 397B flagship), measured in OpenHands. Held the bugs, harness, quant (Q4_K_M), and thinking mode (off) fixed and changed only the model: against the exact base it was post-trained from (Qwen3.5-35B-A3B) in the rig's strict native loop, Ornith-35B resolves 5/12 vs the base's 7/12 — a regression, and a strict subset (it recovers nothing the base missed). The two losses (astropy-12907, xarray-3677) are bugs the base solved, lost to tool-call JSON fragility: Ornith emits multi-line bash with unescaped newlines, llama-server's strict parser 500s, and even after the loop is hardened to feed the error back and let it retry (a fix inert for the base, which never 500s), it burns its full 40-step budget producing no patch. The reading: their 75.6 lives in a lenient harness with the model's own scaffold; stripped to a strict neutral loop the self-scaffold model is more fragile than the base it was trained from, so the orchestration didn't travel. An agentic-coding number is a property of the model and the harness, not the model alone. And the rig's own synthetic Agentic Score is worse than blind to it: it ranks Ornith-35B at 98.06, ABOVE the base's 97.5 (#6 on the board), while Ornith resolves fewer real bugs — the synthetic axis inverts the ranking, scoring fluent tool-driving rather than real-bug fixing. Not a refutation of the 75.6 (different harness, temperature, and scaffold); the 397B flagship is datacenter-only and untested. The fourth Qwen-family coding tune to regress on the real anchor — only pi-tune, trained on real agent traces, improved.
Swap the agent harness, not the model: a +1/12 persistence lever · chart	How much of an agentic-coding score is the model and how much is the harness wrapped around it? Held the model fixed (Qwen3.6-27B-Q6_K, one local llama-server on a 5090, think-off, temp 0) and swapped only the agent scaffold, graded on 12 SWE-bench Verified bugs with the official harness. The rig-native tool loop (40-step budget) resolves 8/12; omp v16.1.14 (a deps-free CLI agent, 450s budget, same model and :8090 endpoint) resolves 9/12 — a strict superset, the lone delta being sphinx-8621. The mechanism is persistence, not reasoning: on the 4 hard bugs the native loop committed no patch (gave up) 3 times, omp once; omp lands patches where native quits, and one of those passed. Both harnesses miss the same 3 bugs (seaborn-3187, requests-1921, pylint-7080) — same model, same ceiling, so the scaffold only moves the give-up rate. Empty-patch rate is the give-up tell, here separating two harnesses on a fixed model. Honest limits: n=12 single seed, so the +1 is inside the noise (the signal is the direction plus the mechanism); the budgets differ by construction (steps vs wall-clock), which is the point — a harness is prompt plus tools plus stopping policy, bundled. The inverse of the Ornith-1.0 claim the rig tests next (RL that bakes the scaffold into training).
Qwen-AgentWorld's zero-fine-tune transfer doesn't reproduce on a 5090 · chart	Qwen-AgentWorld (arXiv 2606.24597) trains a language world model to predict environment transitions and claims the warm-up transfers to agentic tasks with zero agent fine-tuning, +3.4-12.8%. Tested the released LWM-warmed 35B-A3B against its own base Qwen3.5-35B-A3B in a think-OFF/temp-0 controlled A/B on one RTX 5090. The synthetic agentic board is flat (97.5 = 97.5, a saturated axis that hides differences); the real SWE-bench Verified anchor (30 bugs, official harness) goes 14/30 vs the base's 16/30 — a reshuffle rather than a collapse (11 solved by both, 3 AgentWorld-only, 5 base-only), net -2 with more give-ups (13 empty patches vs 10, mean 33/40 steps: it explores more and commits fewer fixes). The claimed +3.4-12.8% transfer lands at 0% on synthetic and -12.5% on real coding. A scoped null: think-OFF to match the base's banked number, so it doesn't refute a think-ON gain (that A/B is the queued falsification leg), and it tests the SWE-coding slice of a seven-domain claim.
FP4 on a consumer 5090: the Blackwell headline loses to plain int4 · chart	FP4 is the Blackwell selling point — benchmarked on one RTX 5090 (sm_120) against the quants you'd actually run, Qwen3-14B in vLLM 0.21. Two findings that compound. (1) NVFP4 is the only quant that won't run out of the box: AWQ/FP8 use prebuilt Marlin kernels, but NVFP4 makes FlashInfer JIT-compile native sm_120 FP4 cutlass kernels at load — needing ninja on PATH + a real CUDA toolkit + the correct CUDA_HOME (the default /usr/local/cuda-13.0 doesn't exist on the box) + a flashinfer-cache clear. (2) Once native FP4 is genuinely running (declared modelopt_fp4, not a Marlin dequant fallback), it's still slower than AWQ int4 at every batch: batch-1 decode AWQ 150 vs NVFP4 100 (0.66x) vs FP8 90; batch-32 AWQ 3937 vs NVFP4 3321. The 4-6x FP4 numbers are B200 tensor-core throughput; on consumer sm_120 a mature int4-Marlin kernel wins. bf16-14B doesn't fit 32GB (no KV room). (3) The academic real-FP4 path (QuTLASS MXFP4, arXiv 2509.23202), built from source on sm_120a (CUTLASS submodule, torch 2.8/cu128, forced -ccbin g++-14 past the GCC-15/CUDA-12.8 guard): its 4x is real at the GEMM — the MXFP4 matmul crosses 4x by batch 128 and peaks ~6x over bf16 on Qwen3-8B — but end-to-end decode runs 3-4x slower than bf16 (20.4 vs 78.6 tok/s at batch 1) and uses ~2x the VRAM, because decode is memory-bound and pays a fixed per-layer rotation+quant tax the tiny matmul can't amortise. Verdict: use AWQ int4 for serving, skip NVFP4 on consumer Blackwell; QuTLASS MXFP4 only pays off for compute-bound high-batch/prefill work, not single-stream serving.
One-Shot EM doesn't reproduce on a 5090: entropy fell, accuracy didn't · chart	One-Shot Entropy Minimization (arXiv 2505.20282) claims +24.7 on Qwen2.5-Math-7B from ONE unlabeled example in ~10 steps, no rewards. The full-param recipe OOMs on 32GB (14GB weights + 14GB bf16 grads), so the consumer-feasible version is LoRA (batch 16). Measured greedy pass@1 with the authors' grader: base reproduces the paper (MATH500 53.4 vs 53.0), but EM adds +2.0 at its peak step then collapses back by step 15, and AMC23 goes −2.5 (claim was +25.8 / +26.2). The keeper is the mechanism: the entropy objective trained fine (mean per-token entropy 0.098→0.035) while accuracy stayed flat — distribution-sharpening, not learning, in the paper's own words. Same base as Spurious Rewards (+21 on MATH500 from random rewards). Honest limits: full-param didn't fit, so this isn't a refutation of the multi-GPU number; the few-shot format control backfired on Qwen-Math's native zero-shot CoT.
Draft-free spec-decode on Qwen3-8B: workload split + dumb-vs-fancy null · chart	Cache-only speculative decoding (no draft model, no extra VRAM) on Qwen3-8B: one greedy loop, three drafters (AR / one-line prompt-lookup / Cacheback's dynamic LRU table) × three workloads. The speedup is workload-shaped, not method-shaped — code 1.45-1.47x, summarize 1.30x, open chat 1.26x, with MAT tracking speedup 1:1, biggest where local agents live and no workload at zero. The null: Cacheback's LRU table ties one-line prompt-lookup (identical on 2/3 workloads, +0.01 MAT on code) — at leader-length 1 they are the same algorithm; Cacheback's real edge is its frozen corpus + tree drafting, not the dynamic table, and the cited "1.86x" is Vicuna-7B + frozen corpus on a 4090, not a modern 8B. Lossless: 46072/46080 tokens byte-identical to greedy; the 8 misses are exact bf16 logit ties (gap 0.000) where greedy itself is non-deterministic, not a decoder bug.
Sovereign TTS head-to-head: 1.7B Apache beats 4B research-license · chart	Qwen3-TTS-1.7B (Apache) vs Fish-S2-Pro (4B, research license) on one RTX 5090, 150 Seed-TTS-eval EN utterances, both bf16 and neither compiled. Round-trip WER is a tie (0.6% each — Fish's sub-1% claim holds, Qwen matches it); SIM-o 0.699 vs 0.625; but RTFx 2.22× vs 0.39× and first-audio latency 1.72s vs 9.74s. Fish-S2-Pro's serving stack assumes SGLang + torch.compile + datacenter cards (its RTF<0.5 is an H200 number) — out-of-the-box on a consumer GPU the small open model is 5.7× faster at the same intelligibility. Size + serving assumptions, not quality. A compiled-Fish rerun is the obvious follow-up.
GLM-5.2 autopsy: clever MLA+DSA, still datacenter-only · chart	The biggest open-weights drop in months (743B MoE, MIT, 1M context), measured by arithmetic from the published config — not served. Credit first: glm_moe_dsa = MLA + DeepSeek sparse attention compresses the KV cache ~57× (1M = ~88 GiB vs ~4.9 TiB). But the weights can't fit 96GB addressable at any quant (743B needs 1.03 bits/weight; smallest ~1.58-bit = ~147 GB), the 1M KV alone ≈ the whole machine, and DSA saves compute not memory. ~235 GB to use 1M context — past a single H200. Clever ≠ consumer; the home-lab move is to wait for a GLM-5.2-Air.
Qwen3.6-27B pi-tune: the coding tune that works · chart	A community QLoRA SFT of Qwen3.6-27B on REAL non-thinking agent traces, measured controlled vs its base at matched Q6_K across four legs. Quality (93.3 vs 94.0) and synthetic Agentic Score (98.01 vs 98.61) stay flat — but real SWE-bench Verified resolve goes UP 19 → 20/30 (give-ups 8 → 6) and the MTP drafter holds (2.0-2.4× vs base 1.8-2.2×) where Qwopus-Coder's degraded. The first of three Qwen3.6-27B coding tunes to improve real bug-fixing: across all three the synthetic score is a 2.4pt band while real SWE spans 11-20, so training-data provenance (real traces > synthetic distill), not the "agentic coder" label, is what the anchor sees.
Qwable-5-27B-Coder: real traces, still regresses · chart	A real-trace SFT of Qwen3.6-27B (Claude Fable-5 then Kimi 2.7 Coder agent traces), measured controlled vs its base at matched Q6_K. Quality (93.7 vs 94.0) AND the synthetic Agentic Score (98.61 vs 98.61, identical to the decimal) stay flat — but real SWE-bench Verified resolve drops 19 → 17/30 and give-ups rise 8 → 10. The 4th Qwen3.6-27B coding tune on the anchor: real traces are necessary but not sufficient (pi-tune's terminal/repo/DevOps traces remain the only data that moved real resolve up). The MTP drafter survived the SFT (1.9-2.4×, base range) — so drafter-survival is not capability-preservation.
Qwable-3.6-27b: the distill every cheap eval passes, SWE-bench fails · chart	A dense Qwen3.6-27B + Fable-5-style SFT, measured controlled vs its base at matched Q4_K_M. Quality (93.4 vs 94.0) AND the synthetic Agentic Score (97.64 vs 98.19) stay flat — but real SWE-bench Verified resolve drops 18 → 11/30 and give-ups rise 7 → 13. Quant ruled out (base Q6 → Q4 = −1 bug). The agentic board would call it neutral; only the reality anchor caught the give-up regression — a 3rd failure mode, and the inverse of the MoE Qwable-v1 (whose synthetic honestly declined).
Qwable-v1: agentic distillation regresses vs base · chart	A Claude-Code/Fable-5-distilled "agentic coder" (Qwen3.6-35B-A3B) measured controlled vs its vanilla base + the Opus-reasoning-distill, same Q5_K_M. Every post-train step LOWERS the agentic score (99.58 → 97.92 → 96.25), and real SWE-bench Verified resolve drops 19 → 11/30 with give-ups nearly doubling (9 → 16 empty patches). Not a mirage — synthetic fairly predicts real here; the distillation regressed a top-tier base (the vanilla base ties best real resolve on the board).
ECHO maze microcosm · chart	ECHO's "world model for free" env-token loss, isolated in a 10M from-scratch maze transformer (behavior cloning; the only A/B is the loss mask). A clean null under both observation regimes — full-obs and walls-only — every gap inside the seed spread, no growth with maze size. The free aux loss is worth exactly that in pure imitation; the reported gain must live in ECHO's on-policy RL coupling, not the loss as a plug-in. (The paper has no maze — this microcosm is original, verified by grepping the source + repo.)
Spec-decode three-way (Gemma 4 26B-A4B) · chart	MTP vs EAGLE-3 vs DFlash on one RTX 5090 (vLLM 0.21, sm_120), including the EAGLE-3 leg nobody publishes. Single-stream near-tie: DFlash 2.19x, MTP 2.13x, EAGLE-3 1.69x — DFlash is feast-or-famine (prose 1.04x, repetitive 4.37x), MTP the steady all-rounder. Six consumer-Blackwell fixes to run it at all (NVFP4 to MARLIN, FLEX_ATTENTION for the #42068 attention deadlock) plus a self-caught /metrics parser bug. Dense 31B excluded: no clean quant fits 32GB.
Qwopus3.6-27B-Coder · chart	Four legs measured: q_avg 94.1 (#2 thinking-off, beats its base at a smaller quant); "100 tps" MTP verified (96-114 t/s) but the finetuned head accepts worse than the original (1.4-1.6x vs 1.8-2.2x); a perfect 100 Agentic Score — and 57% real SWE-bench resolve, below its own base (63%). Trained on Hermes traces: the in-distribution mirage the reality anchor was built to catch. 67% claim doesn't reproduce.
Qwopus3.6-27B-Coder-Compat: the regressions healed · chart	The "compatibility" re-release of Qwopus-Coder, measured controlled vs base Qwen3.6-27B + the prior Coder at matched Q6_K (think-off, temp 0). Quality flat (q_avg 93.7). The prior tune's two regressions both heal: the degraded MTP draft head recovers 1.4-1.6x → 1.9-2.3x (back on the base curve), and real SWE-bench Verified resolve returns to base parity — 8/12, the exact same bugs as base, +1 over the prior tune (recovers pytest-6202) with one fewer give-up. Agentic Score 100.0 ties the prior (saturated — the synthetic axis can't separate the two; the anchor can). A compat fix that costs no capability: the coder tune no longer carries a drafter or real-bug penalty.
Keye-VL-2.0-30B autopsy · chart	Five measured walls: "lossless 256K" needs 25.8GB of KV alone; the shipped sparse attention is O(N²)-memory (one 30.65GiB allocation at ~32K, measured); 4-bit quant reaches 4.7% of params; the code's API window is two transformers release candidates wide. Does not run on consumer hardware.
LocateAnything-3B · chart · raw	ScreenSpot-Pro 55.3% measured vs 60.3 claimed (32GB forces extra downscale; accuracy tracks screenshot size). Real fault line: text 63.2% vs icons 42.7%. PBD parallel box decoding verified at 2.07x on the SDPA fallback.
HRM-Text-1B · chart · raw gens	GSM8K 79.5% (claimed 84.5: holds at n=200). Omitting token_type_ids — which every standard harness does — silently costs 26 points. The recurrence bill: a 1.2B that decodes like a ~5B (42.9 tok/s bf16, 4x KV cache).
DiffusionGemma vs AR · chart	AR wins at every answer length: diffusion pays a fixed ~3s per 256-token canvas (0.8 effective tok/s on short answers; best case still 2.3x slower). Day-0 public GGUFs were unloadable — convert from source.
Gemma 4 31B QAT + MTP · chart	The MTP draft head lifts decode 76 to 125 tok/s (1.67x). QAT's real value is VRAM, not quality: the Q4 footprint is what fits 128K context plus the draft head on one card.
NVFP4 vs Q6_K · chart	Qwen3.6-27B: NVFP4 trades ~1pt q_avg against Q6_K.
GRPO on one 5090 · chart	Single-GPU RL: +7.66 GSM8K on a 4B. Train-prompt-to-eval-prompt alignment is the lever.
Embedding retrieval bench · chart	Local embedding models benchmarked for retrieval quality vs speed on the 5090.
Mistral Small 4 speed · chart	Speed profile vs gpt-oss-20b — and a benchmarking trap: reasoning is gated behind reasoning_effort, which defaults off.
LFM2.5-VL 1.6B extraction · chart	A 1.6B VL model as a local structured-data extractor.
Nex-N2-mini agentic probe	Adaptive Thinking saves 65% of tokens but costs 13pts task success. Superseded by the dedicated Agentic Score leaderboard (below).

Related Datasets

• witcheer/agentic-score-leaderboard — model-agnostic agentic tool-calling benchmark (7 models, 40 tasks) + the SWE-bench reality anchor
• witcheer/sovereign-asr-bench — local ASR on the 5090: Parakeet-TDT vs Whisper (WER / RTFx / VRAM)

---

Hardware

Component	Spec
GPU	NVIDIA GeForce RTX 5090 32GB (Blackwell, sm_120a)
CPU	AMD Ryzen 5 9600 (6c/12t)
RAM	64GB DDR5-5600
OS	Ubuntu 26.04 LTS
CUDA	12.8 (patched for glibc 2.41)

Tooling

All benchmarks generated with llm-bench-rig — open-source pipeline for speed and quality benchmarks on GGUF and safetensors models.