Mia's one-click kit: ThinkingCap Kearuga 27B (0xWhiteMage's EXL3 4.00 bpw quant), with MTP

How fast it runs

Long prompts

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; context steps: prompts of exactly 16K, 32K, 64K and 128K tokens (a filler log first, the code or prose task prompt last), 2 runs per step, 512 output tokens; decode = tokens after the first / time after the first token; prefill = prompt tokens / time to first token of the same request, median over its requests; requests at once: C1,C2,C4,C8 at once; 2 rounds each; 512 tokens per request; prose prompt; total = all tokens / wall time, per request = tokens / end-to-end time; median over the rounds. Measured 2026-11-10. Raw files: speed result · speed contract · log · long answer.

Recipe and what differs from it. The setup is Mia's one-click kit (commit bbb11db) running 0xWhiteMage's ThinkingCap quant. The kit's README is written for Qwen3.8-27B in turboderp's EXL3 quants (lines 14 and 15), and the quant's card names TensorFold with a DFlash 2 drafter on one DGX Spark as the runtime of its own measurements (lines 42 and 152). 0xWhiteMage's recipe repository lists this RTX 5090 setup, the kit with this quant revision, as a "Suggested independent recipe, not a maintainer-requalified install" (docs/RECOMMENDED-RECIPES.md at commit 43aab50 of 19 Oct 2026, lines 16 and 45 to 47; the repository's README lines 31, 69 and 277). A small start script of mine writes the kit's .env and calls the kit's own linux/start.sh (--no-harness --no-pick: no chat page, no model menu), with the settings the kit's README lists for its 4.0 bpw quant on a 32 GB card: context 262,144 tokens, KV cache in 4 bits and a GPU memory plan of 22.8 GB (line 677), and the kit's default draft method DRAFT=mtp (line 356). I lowered none of them. The only differences from my page of the same kit with the Qwen3.8-27B quant are the model folder, the model id and the Hugging Face pins of the .env. The .env also holds the port and the local address, no chat page, CPU_CACHE_GB=0 and VISION=auto (as in the kit's measured settings); I did not record whether the vision tower was loaded, and the tests send text only. Not used: DRAFT=dflash2, which the kit offers for 32 GB cards with its own 4.0 bpw quant (lines 641 and 667 to 669); my card notes that the kit's check does not allow it for this quant's folder, and I did not test that, and I did not use the TensorFold stack of the quant's card. The quant's card also says that MTP quality is outside its text qualification (line 192); this page measures the model as it runs in the kit, and it does not qualify MTP. The quant is revision 11447639 of 0xWhiteMage's repository (two weight files, 16,349,981,188 bytes together, sha256 checked against the hashes that Hugging Face lists; last change of the repository 13 Oct 2026); the engine is ExLlamaV3 1.6.0, which the kit installs from the release of turboderp-org/exllamav3 (line 593 of the kit's README), and the quant was made with ExLlamaV3 1.5.3. I did not record whether this machine used the release wheel or a source build of the tag. The kit folder on the machine is a copy without a git folder, named after commit bbb11db; the README lines quoted here are those of that commit on GitHub.

The headline 136.0 tok/s is the mean of the code prompt (140.2) and the prose prompt (131.8), medians of two runs each (spread 2.4 % and 4.6 %, as in the table). The speed test sent the card's sampling (temperature 1.0, top-p 0.95, top-k 20, min-p 0) with thinking off in every request; the model thinks by default, so a request without that switch would start with reasoning. The long-answer test ended by itself after 7,530 tokens (finish reason stop).

Draft statistics and prompt cache: the setup runs with DRAFT=mtp, but no draft statistics reached the test tool (its contract lists the acceptance rate and the mean accepted length as not available), so the page shows no acceptance rate and I cannot say how many of the drafted tokens were accepted. Every request sent cache_prompt false, and the prefill prompts carry a random nonce of the tool. The tool's own cache check could not confirm the setting: none of the 61 requests it examined reported a cached-token count above zero, but all 61 lacked the field, because the kit's server does not report it. So the check shows no cache hit and does not prove that there was none.

Requests at once: the card has no server-slot entry and the server does not report its slot count, so the number of server slots is not known and this page shows no slot count. The test sent 1, 2, 4 and 8 requests at once anyway. The total stays at 120.6, 119.8, 120.4 and 120.7 tok/s, while the speed of one request falls from 120.6 to 27.0 tok/s (120.6, 89.2, 50.6 and 27.0 tok/s for 1, 2, 4 and 8 requests). Because the slot count is unknown, the table gives the measured rates only: it does not show how the setup scales, and I cannot say whether the requests ran side by side or one after another. The 1-request figure includes the prompt time, so it is below the decode speed.

Long prompts: all four steps ran (16K, 32K, 64K and 128K tokens, exact lengths from the local tokenizer file; the server window is 262,144 tokens, so 128K is half of it). The first token at 128K comes after 62.5 seconds (prefill 2097.4 tok/s); decode there is 118.0 tok/s for the code prompt and 104.7 tok/s for the prose prompt. The window of 262,144 tokens itself was not filled by any test of this page.

The machine: the box runs its own services. The quiet check of this run (one sample every 10 seconds) saw 80 samples, the busiest other process at 1.9 % of one core at most, none above 25 %. The test tool's own guard (two samples a second, 38 steps) repeated one step: the first try of the 128K prose run was thrown away because a process named python stayed above 25 % of a core for two samples in a row (up to 90.0 %), and the repeat is the value shown. That process is the tool's own token-counting helper (tok_local.py in the tool's folder, which builds the exact-length prompts with the local tokenizer file). In the other steps of 64K and 128K the same helper was the busiest other process (up to 69.9 %) without two samples in a row above 25 %; the box's container service reached up to 18.0 % in 3 steps. Nothing else was repeated or removed. The files of the quiet check and the guard samples are not published.

python3 speed2.py --base-url http://127.0.0.1:42505/v1 --label gpu1010-thinkingcap-v2-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/gpu1010-thinkingcap-v2-speed-r0/gpu1010-thinkingcap-v2-speed-r0/speed2 --contract $RUN/gpu1010-thinkingcap-v2-speed-r0/gpu1010-thinkingcap-v2-speed-r0/speed2/speed-contract.json --parts decode,prefill,conc,l1,ctx --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --conc-levels 1,2,4,8 --conc-rounds 2 --conc-max-tokens 512 --conc-prompt prose --ctx-depths 16384,32768,65536,131072 --ctx-runs 2 --ctx-max-tokens 512 --tokenizer-json $HOME/models/thinkingcap-kearuga-exl3-4.00bpw/tokenizer.json --tokenizer-python $HOME/hfvenv/bin/python --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20, "min_p": 0.0} --sampling-source https://huggingface.co/0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw/blob/11447639033dd80a4c04536b5b37ed7d642802ee/README.md lines 178-181 (curl example: temperature 1.0, top_p 0.95, top_k 20, chat_template_kwargs enable_thinking true + reasoning_effort xhigh) and generation_config.json lines 9-11 (temperature 1.0, top_k 20, top_p 0.95); min_p 0.0 from https://huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-27B-GGUF README.md line 100 (rev dc3aa8563d5d48d1d83637eb67147e1b52215cf7). The card gives no separate non-thinking set: the same values are used with thinking off. presence_penalty is not named by any ThinkingCap card -> not sent. Local copy of the card: $HOME/models/thinkingcap-kearuga-exl3-4.00bpw/README.md --model thinkingcap-27b-kearuga-exl3-4.0bpw --no-cache-prompt --server-log $RUN/server-A.log --engine-version-file $RUN/engine-version.txt --server-ctx 262144 --server-ctx-source card box-6-thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090 field ctx

How well it answers

All seven quality tests ran. Six ran with thinking off and one (GPQA 30) with thinking on; the model is built to reason, so the six may understate it. The notes below say how the numbers were taken.

Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured 2026-11-10.

Note from the run: MMLU-Pro (400 questions), GPQA Diamond (198), IFEval (200), LiveCodeBench (40 tasks) and RULER at 8K and 32K tokens (40 tasks each) ran with thinking off (chat template switch enable_thinking false), the sampling of the model card (temperature 1.0, top-p 0.95, top-k 20, min-p 0; the card names one set for thinking on and off, and no presence penalty, so none was sent), seed 42, one request at a time. MMLU-Pro and GPQA Diamond ran with an answer limit of 48 tokens, letter only; IFEval with 4,096 tokens; LiveCodeBench with 32,768 tokens; RULER with 128 tokens. GPQA 30 ran with thinking on (the template's default effort xhigh), the same sampling, an answer limit of 16,384 tokens and one question at a time. GPQA Diamond ran from the public mirror fingertap/GPQA-Diamond (198 rows), because the original is gated and no Hugging Face token was available.

Thinking: ThinkingCap is built to reason. The quant's card shows a request with thinking on at the effort xhigh and calls xhigh the upstream recommendation (lines 181 and 185), and BottleCap AI's own paired evaluation (the card of its GGUF files, line 100) thinks at xhigh with a generation cap of 65,536 tokens. Six of my seven tests ran with thinking off, two of them with a limit of 48 tokens, so they may understate the model; I have not measured by how much. Only GPQA 30 ran with thinking on, with a limit of 16,384 tokens, which is lower than the cap BottleCap AI uses. My tests are not BottleCap AI's, and these numbers neither confirm nor contradict its results.

Cut-off answers count as wrong: 0 in MMLU-Pro, 0 in GPQA Diamond, 0 in IFEval, 0 in long text (the RULER tests), 3 of the 40 in LiveCodeBench (limit 32,768 tokens; the median answer used 3,985 tokens) and 6 of the 30 GPQA answers with thinking (limit 16,384 tokens). The median answer of the thinking test used 1,812 tokens and 13.1 seconds. RULER by task: variable tracking 5 of 10 at 8K and 3 of 10 at 32K; multi-hop question answering 8 of 10 and 3 of 10; multi-key retrieval 10 of 10 and 10 of 10; common-word extraction 10 of 10 and 10 of 10.

The numbers come from three runs on 10 Nov 2026 with the same start command of the card: LiveCodeBench and GPQA 30 first (11:26 to 12:17 on the clock of the measuring machine), then the memory test (restarting the server for every size), and after the speed test MMLU-Pro, GPQA Diamond, IFEval and both RULER tests (12:39 to 12:57). No other run is mixed in. The answer files of all seven tests are published; the files that hold the quiet-check readings are not published.

Foreign load: these tests have no guard; their quiet check lists the busiest other process every 10 seconds. MMLU-Pro, GPQA Diamond, IFEval and RULER: 110 samples, 2 above 25 % of one core (40.0 % and 42.8 %, a short Python command that requests a local web page on port 8080; I did not find out what started it). LiveCodeBench: 191 samples, 2 above 25 % (85.7 % and 97.7 %): the test's own code sandbox, which runs the model's code. GPQA 30 with thinking: 113 samples, none above 25 % (at most 1.9 %). None of this was repeated or removed. The memory in use on the card during these runs, at the full window of 262,144 tokens, read 20,236 to 21,548 MiB (quiet check, every 10 seconds).

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts mmlupro --job gpu1010-thinkingcap-v2

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts gpqa --job gpu1010-thinkingcap-v2

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts ifeval --job gpu1010-thinkingcap-v2

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts lcb --job gpu1010-thinkingcap

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts ruler --job gpu1010-thinkingcap-v2

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts ruler --job gpu1010-thinkingcap-v2

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts think --job gpu1010-thinkingcap

How much context fits

Memory test. For each context size (4K, 8K, 16K ... up to the largest size tested for the setup) the server is started again with that context, one prompt that fills about 95 % of the context is sent, and the model must answer. The largest size that loaded and answered counts. Decode speed is measured on that answer at the largest size. Peak memory is the GPU memory in use (nvidia-smi); the GPU was empty before each start. Measured 2026-11-10. Raw files: result of every step · log · contract.

Note from the run: The server was restarted for every size with the context set to that size (a copy of the card's start script that takes the size from an environment variable; the command of each size is in the raw contract), and one prompt that fills about 95 % of the size was sent (prompts of 3,798 to 125,892 tokens, 96 answer tokens at most); the model had to answer. All six sizes, 4K to 128K (131,072 tokens), loaded and answered. The list of sizes ends at 131,072 tokens, so this is the largest size tested, not the largest size the setup can load: the recipe's own window is 262,144 tokens, which the speed test and the quality tests used, but the memory test did not try it, so this page has no memory-test result and no answer test at 262,144. During those runs the card read 20,236 to 21,548 MiB in use (quiet check, every 10 seconds). The memory number is the GPU memory in use on the whole card (the peak of the test): 15.54 GiB at 4K and 18.26 GiB at 131,072 tokens. The decode speed shown (106.0 tok/s) is that of one short reply of 69 tokens after a prompt of 125,892 tokens; it is not comparable with the decode speeds of the speed test, and the replies of the sizes differ in length (95 tokens at 4K).

bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json --parts fit --job gpu1010-thinkingcap

How it plays the Gauntlet

One solo race, season seed 21, one attempt, no help.

Game rank as of Nov 10, 2026. The rank is the order of the Gauntlet finish times in this memory class. Race page and raw files.

The race ran the recipe named on its race page, with the sampling and answer limit of its lane config. The engine build of the race is not recorded in the race files.

Result (result.json) Race log (log.jsonl) Model answers (io.jsonl) System prompt Exact command Verify output Model config Race page

Also made this possible

• Quant (EXL3 4.00 bpw "Kearuga", revision 11447639)0xWhiteMage@0xWhiteMage Hugging Face GitHub Website
• Model (ThinkingCap, a fine-tune of Qwen3.8-27B)BottleCap AIHugging Face @BottleCapAI GitHub Website
• Engine (ExLlamaV3 1.6.0 and the EXL3 format)turboderp (turboderp-org)@turboderp_ GitHub Hugging Face
• Base model (Qwen3.8-27B)QwenHugging Face @Alibaba_Qwen GitHub Website

Run it yourself

What you need and how to start it, step by step. The results below come from exactly this setup.

What you need

Hardware

1x NVIDIA GeForce RTX 5090 32 GB (one GPU), the whole model in video memory. Driver 610.43.02, kernel 6.12.95+deb13-amd64

System

Linux (we used the Linux start script)

Model

0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw @11447639 (ThinkingCap by BottleCap AI on Qwen3.8-27B)

Quant (EXL3 4.00 bpw "Kearuga", revision 11447639)

huggingface.co/0xWhiteMage/ThinkingCap-Qwen3.8-27B-Kearuga-EXL3-4.00bpw/tree/11447639033dd80a4c04536b5b37ed7d642802ee

Model (ThinkingCap, a fine-tune of Qwen3.8-27B)

huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-27B

Base model (Qwen3.8-27B)

huggingface.co/Qwen/Qwen3.8-27B

Engine

ExLlamaV3 1.6.0 in Mia's kit (commit bbb11db), one RTX 5090 32 GB, 262,144 tokens of context, KV cache in 4 bits — the program that loads the model and answers requests · github.com/turboderp-org/exllamav3/releases/tag/v1.6.0Build and settings we used: ExLlamaV3 1.6.0 (Mia one-click kit bbb11db), DRAFT=mtp

Recipe (one-click kit, commit bbb11db)

github.com/MiaAI-Lab/Qwen3.8-27B-16gb-NVIDIA-GPUs-one-click-install/tree/bbb11db4b7ff688a62841c68e0892fa099bc3362 by Mia (MiaAI-Lab)

Steps

1. Get the recipe, the engine and the model files from the list above.

2. Put these settings into the recipe's .env file. One setting per line.

   Copy

   MODEL_DIR=$HOME/models/thinkingcap-kearuga-exl3-4.00bpw
   MODEL_ID=thinkingcap-27b-kearuga-exl3-4.0bpw
   CONTEXT_SIZE=262144
   CACHE_QUANT=4
   GPU_MEM_GB=22.8
   DRAFT=mtp
   PROFILE=4.0bpw-262k

3. Start the server with this command. It loads the model into memory.

   Copy

   CUDA_DEVICE_ORDER=PCI_BUS_ID \
     CUDA_VISIBLE_DEVICES=0 bash linux/start.sh \
     --no-harness \
     --no-pick

   What the parts mean

   • CUDA_DEVICE_ORDER=PCI_BUS_IDcounts the GPUs in slot order, the same order nvidia-smi shows
   • CUDA_VISIBLE_DEVICES=0which NVIDIA GPU the program may use: the ID of the GPU, its number or the UUID that nvidia-smi -L prints
   • MODEL_DIR=$HOME/models/thinkingcap-kearuga-exl3-4.00bpwthe folder with the model files
   • CONTEXT_SIZE=262144the context window in tokens: how much text the model can see at once
   • DRAFT=mtpMTP (multi-token prediction): the model guesses several tokens ahead and checks them, which makes answers faster
   • CACHE_QUANT=4keeps the context memory (KV cache) in 4 bits, which uses less GPU memory
   • GPU_MEM_GB=22.8how much GPU memory, in GB, the kit plans with
   • PROFILE=4.0bpw-262kthe name of the kit profile these settings belong to; the name gives the bits per weight and the context size

ExLlamaV3 1.6.0 (Mia one-click kit bbb11db), DRAFT=mtp; CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES=0 bash linux/start.sh --no-harness --no-pick (.env: MODEL_DIR=$HOME/models/thinkingcap-kearuga-exl3-4.00bpw MODEL_ID=thinkingcap-27b-kearuga-exl3-4.0bpw CONTEXT_SIZE=262144 CACHE_QUANT=4 GPU_MEM_GB=22.8 DRAFT=mtp PROFILE=4.0bpw-262k)

Mia's own benchmark, run unchanged

This is Mia's own benchmark tool (commit 21a3511), run unchanged. It has its own section on this page, and it is never mixed with my numbers. A cut-off answer counts as wrong here, so a value can differ from sparkDash's own screen.

Seed 1234 applies to the two quality tests; decode, prefill and tool eval send no seed. The benchmark client ran on a separate machine that is never part of the measured group. Measured 2026-10-19. Version 2.50.0, commit 21a3511.

QA. Quality QA, 150 items, seed 1234, temperature 0, thinking off, 4 requests at once (Mia's default). An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

MMLU. Quality MMLU, 285 items (5 for each of 57 subjects, 4 answers), seed 1234, temperature 0, thinking off. An answer cut off at the token limit counts as wrong. ± is the 95 % margin (Wilson).

Decode. Decode bench, 1 request at once, 400 tokens, prompt type structured, temperature 0, thinking off. No seed is sent.

Prefill. Prefill bench at 4K, 8K, 16K and 32K tokens. sparkDash skips a size that does not fit into the context. No seed is sent.

Tool Eval Quick. Tool Eval Quick: tool-eval-bench (SeraphimSerapis, commit c61319b), 15 core scenarios (--short), --no-think, --timeout 120. Score 0 to 100. No seed is sent.

Note from the run: sparkDash 2.50.0 (@21a3511) on a client machine (never in the measured group); Quality: seed 1234, temperature 0, thinking off, a truncated answer counts as wrong; decode, prefill and tool eval send no seed; own row, never mixed with quality-v2. Same setup, earlier day: the sparkDash run is from 19 Oct 2026, three weeks before the speed and quality tests of 10 Nov 2026. The model (revision 11447639 of the quant, last changed on 13 Oct 2026), the kit commit (bbb11db), the start command and the context are the same in the register rows of both runs (checked field by field). sparkDash is Mia's own benchmark tool, run unchanged; its decode and prefill figures are not those of the speed test above and must not be read as one number with them. They use other prompts and settings: sparkDash decodes 400 tokens of a structured prompt at temperature 0 with thinking off, the speed test decodes code and prose prompts of 512 tokens at the card's temperature 1.0. sparkDash reports 264.8 tok/s for 1 request at once, the speed test 136.0 tok/s; I did not test what causes the difference. Foreign load: before the server started, the job's quiet check passed and the GPU was idle (2 MiB in use); there is no record of other load during the run, which took about 11 minutes. In the quality part, 5 MMLU answers reached the limit of 1,024 tokens and count as wrong.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/thinkingcap-27b-kearuga-exl3-4.0bpw-mtp-5090.json <box> --client <client machine> --job tag-1910 --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/run-sparkdash-r7/tooleval/result.json --no-live