niklaslenzBottleCapAI's ThinkingCap Qwen3.8-Flash-Next (GGUF Q4_K_M) on llama.cpp
1x NVIDIA DGX Spark (GB10, 128 GB unified memory), one box.
Overall score as of 25 Oct 2026. Scores are relative to the best run in the class today; a better model later moves older runs down.
How the overall score is calculated
| Part | This run | Best in class | Relative | Weight | Points |
|---|---|---|---|---|---|
| Speed, one request | decode 30.5 tok/s | best 56.2 tok/s | 54.2 % | 17.5 % | 9.5 |
| Speed, 8 at once | total 44.3 tok/s | best 125.2 tok/s | 35.4 % | 17.5 % | 6.2 |
| Quality | mean of 7 tests: 67.4 % | best mean 70.8 % | 95.2 % | 25 % | 23.8 |
| Browser check | 8.5 of 10 | 85.0 % | 5 % | 4.3 | |
| My rating | 3.5 of 10 | 35.0 % | 35 % | 12.3 | |
| Overall | 100 % | 56.0 |
The seven quality tests: MMLU-Pro 61.8 · GPQA 51.5 · IFEval 85.5 · LiveCodeBench 57.5 · long text 8K 75.0 · long text 32K 57.5 · GPQA 30 with thinking 83.3.
The speed part is half the decode speed with one request and half the total speed with 8 requests at once, each relative to the best run of this class; a run without a total for 8 requests at once gets the better of its decode speed alone and the mix with its highest measured total. Quality is relative to the best run of this class, the browser check and my rating are out of 10. The parts are rounded one by one. sparkDash, the memory test and speculative-decoding numbers are not part of it. How the score is made, and the assumption behind it.
What it builds as an agent
Task: Voxel world (3D scene, one HTML file). One attempt, no help. Counted: the final file counts.
The exact promptcopy it and try it yourself↓
This is the task prompt word for word, as we handed it to the agent harness. The harness adds its own system prompt and tools, and some harnesses add short context notes of their own. A run that goes past 90 minutes also gets a short “finish now” message, as the prompt says. To try it yourself, give it to your own coding agent: it needs a shell and a working folder.
Design and create the most impressive, creative, elaborate and detailed
voxel art world you are capable of. The theme and style are ENTIRELY your
choice — pick whatever world you can execute best and push it as far as
you can: scale, variety, detail, color, animation, atmosphere, life.
Surprise me.
Hard requirements:
- Everything ends up in ONE single self-contained HTML file (game.html in
the current working directory) that opens and runs directly in Chrome.
Use WebGL and whatever libraries you like, but embed everything —
no internet access at view time, no external files.
- The scene must present itself: include an automatic slow cinematic
camera tour (orbiting the world, occasionally zooming in on highlights)
that starts on load, plus mouse controls (orbit/zoom) for manual viewing.
- All user-facing text (UI, HUD, titles, descriptions, hints) must be in
ENGLISH, regardless of the language of any project files you encounter.
When finished, verify your HTML actually loads and renders without
console errors, then state DONE with the absolute path of game.html.
Do not ask questions.
How you work (same for every model):
- You work alone in the folder /work (this is the current working directory). Nobody will answer questions. Aim to finish in about 60 minutes. After 90 minutes you will get a message to finish; then you have at most 30 more minutes. Hard stop after 120 minutes.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh game.html` (opens the page in a headless browser, saves a screenshot and prints console errors). There is no internet and no access to other machines.
- Keep a working /work/game.html at all times. If you are stopped, the last version that loaded without errors counts.
- JavaScript libraries available offline in the test browser, through an import map with these exact URLs: "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js", "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/", "simplex-noise": "https://cdn.jsdelivr.net/npm/simplex-noise@4.0.3/dist/esm/simplex-noise.js", "@tweenjs/tween.js": "https://cdn.jsdelivr.net/npm/@tweenjs/tween.js@25.0.0/dist/tween.esm.js", "cannon-es": "https://cdn.jsdelivr.net/npm/cannon-es@0.20.0/dist/cannon-es.js". No other external resources.
- After the scene is built, set `window.scene` to the Three.js scene (if you use Three.js) and `window.ready = true`.
Play it yourself
Open full screenAI-generated The page this setup built, running live in your browser: click into it and use the controls it shows itself (usually drag to look around, scroll to zoom). It needs WebGL and can be slow on a weak graphics card.
The browser check
- page loads without page error1 / 1
- window.ready === true within 30 s1 / 1
- no console errors (whole session)1 / 1
- frame is not blank1 / 1
- frame rate in software GL (rAF over 5 s)0 / 1
- world: scene size 0.5 (parts >= 80 or >= 20000 triangles; canvas fallback), visible text English if any 0.51 / 1
- automatic camera tour: the view changes on its own in two successive ~5 s windows (1 each)2 / 2
- animation in the world (nodes / instances / particles moving besides the camera)1 / 1
- OrbitControls: drag and wheel change the picture beyond the animation baseline0.5 / 1
Measured 2026-10-25. Raw files: check · run info · command · final choice · contract · sampling · gate stats · gate log · screenshot · clip.mp4 · web.mp4 · web-poster.jpg.
Other processes used up to 1728 % CPU during the run. Browser check 8.5 out of 10 (voxel-world task): the page loads without a page error, is ready after 0.01 s, has no console errors, is not blank, shows a world (24,435 parts, 300,268 triangles, English text), flies the automatic camera tour (the picture changes in both windows), animates (22 animated nodes). The 1.5 lost points are the frame rate (1.59 frames per second in software rendering without a GPU, 10 give half a point and 20 the full point) and half of the orbit-controls test (the mouse wheel changed the picture, the mouse drag changed it less than the check needs). This build ran on the first run, with the author's command and the prompt cache on (see the speed note). The agent (OpenCode 1.19.3) took 99.7 minutes, one try, no help. After 90 minutes the harness sends “Time is up. Finish now” and the model got it at 95.4 minutes; the run ended by itself at 99.7 minutes. 36 requests, no error, no request blocked, none shortened by my test proxy except that the proxy cut the answer limit to the free context (1,607,105 prompt tokens, 50,482 answer tokens, largest prompt 67,257 of 262,144 tokens). 15 versions of the page were seen on the way, all 15 loaded without errors, and the last one counts; the first one came after 14.7 minutes. The limit per answer was 253,952 tokens, the maker's own figure (ThinkingCap README 'Serving'). Thinking was on with the ThinkingCap card's sampling (temperature 1.0, top_p 0.95, top_k 20). What it built: AETHERIA, a voxel sky kingdom of 7 floating islands (a snow mountain, a mirror lake, a waterfall, a lantern village, windmill terraces, a crystal hollow, castle ruins, a desert mesa), 3 sky whales, an airship, bird flocks, clouds, an aurora, fireflies, stars and a moon, with a 160-second day and night cycle and a camera tour of 13 chapters. In my recording about half of each day is night, and the scene is dark then; near the mirror lake the tour camera flies into blocks for a few seconds, so the picture is one colour. The 1,728 % CPU reading came at the end of the run; the load monitor named /opt/pyenv/bin/python, a program inside the test container.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
run_showcase.sh --harness opencode-limit-input --task VX --upstream http://127.0.0.1:34657/v1 --model ThinkingCap-Qwen3.8-Flash-Next --sampling-file $RUN/sampling-show.json --out $RUN/raw/thinkingcap-2410b-show-r4/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 262144It also built this
Task: Airship dock (3D scene, one HTML file). One attempt, no help. Counted: the final file counts. This extra build test is shown for the full picture; it is not part of the ranking.
The exact promptcopy it and try it yourself↓
This is the task prompt word for word, as we handed it to the agent harness. The harness adds its own system prompt and tools, and some harnesses add short context notes of their own. A run that goes past 90 minutes also gets a short “finish now” message, as the prompt says. To try it yourself, give it to your own coding agent: it needs a shell and a working folder.
Design and build the most impressive, creative, elaborate and detailed steampunk airship dock voxel world you are capable of. Theme: a steampunk airship dock. Everything else (style, story, extra details) is your choice.
How you work:
- You work alone in the folder /work. Nobody will answer questions. Aim to finish in about 60 minutes. After 90 minutes you will get a message to finish; then you have at most 30 more minutes. Hard stop after 120 minutes. Spend the time where it shows in the result.
- Tools on this machine: shell, files, python3 with numpy and Pillow, ffmpeg, node, and `shot.sh index.html` (opens the page in a headless browser, saves a screenshot and prints console errors). There is no internet and no access to other machines.
- You may create your own assets locally with these tools (textures, sky, sounds, music) and embed them in the file as data URIs. Do not download anything.
- Keep a working /work/index.html at all times: write a first working version early, then improve it step by step. If you are stopped, the last version that loaded without errors counts.
- Check your work with `shot.sh` as often as you like, fix every error, and keep improving until you are satisfied. Then stop.
Deliverable: ONE self-contained file /work/index.html that opens and runs in Chrome.
- JavaScript libraries: only these, through an import map with these exact URLs (they work offline in the test browser). Use whatever helps, including all Three.js addons (post-processing, sky, water, noise and so on):
- "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js"
- "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/"
- "simplex-noise": "https://cdn.jsdelivr.net/npm/simplex-noise@4.0.3/dist/esm/simplex-noise.js"
- "@tweenjs/tween.js": "https://cdn.jsdelivr.net/npm/@tweenjs/tween.js@25.0.0/dist/tween.esm.js"
- "cannon-es": "https://cdn.jsdelivr.net/npm/cannon-es@0.20.0/dist/cannon-es.js"
- No other external resources. Build every object from cubes (voxels); InstancedMesh is allowed.
- The page fills the whole window and resizes with it. All visible text is in English.
- After the scene is built, set `window.scene` to the Three.js scene and `window.ready = true`.
- An automatic slow cinematic camera tour starts on load. Mouse input switches to OrbitControls (drag to rotate, scroll to zoom).
- Sound, if any, starts only after the first click (browsers block autoplay).
- A small label in the top-left corner: "Steampunk Airship Dock".
Minimum content (go far beyond it):
1. A tall iron docking tower with platforms, stairs or ladders, and a mooring arm at the top.
2. At least two airships, each with a balloon envelope, a gondola and propellers.
3. Big brass gears on the tower or the buildings.
4. Pipes and at least three chimneys that emit rising steam particles.
5. At least one crane and a stack of cargo crates.
6. A ground area with a workshop building and a small rail track.
7. Propellers and gears rotate, steam rises and fades, and one airship slowly approaches the tower, docks, waits and leaves again, in a loop.
8. Warm sunset lighting with shadows.
Play it yourself
Open full screenAI-generated The page this setup built, running live in your browser: click into it and use the controls it shows itself (usually drag to look around, scroll to zoom). It needs WebGL and can be slow on a weak graphics card.
Measured 2026-10-25. Raw files: check · run info · command · final choice · contract · sampling · gate stats · gate log · screenshot · clip.mp4.
The run's own headless check browser, which renders the page the model built, used up to 1188 % CPU. The load monitor counted it as another process. Extra build, not part of the score. This run used the airship-dock prompt (the one the 16 GB and 32 GB classes use), not the voxel-world prompt this page is ranked on. Same box, same model file, same server command (the author's command, prompt cache on), same agent and same limits as the voxel-world run above; only the prompt differs. My rating of this extra world: 4.5 of 10 (it does not count in the score). The agent finished by itself after 85.8 minutes, one try, no help; the “finish now” message (from 90 minutes) was not needed. 19 versions of the page were seen on the way, 13 loaded without errors, and the last one counts. Browser check 8.5 out of 10: the frame rate lost its point (5.2 frames per second in software rendering) and the check for the required objects gave 1.5 of 2 (no visible label found in the top left; 2 airships, steam, voxel mass found). 37 requests, no error, none shortened (1,898,717 prompt tokens, 63,424 answer tokens, largest prompt 77,229 of 262,144 tokens). Answer limit 253,952 tokens, context 262,144 tokens, thinking on with the card's sampling (temperature 1.0, top_p 0.95, top_k 20). The load monitor saw other processes during the run (up to 1,188 % CPU, the run's own headless check browser).
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
run_showcase.sh --harness opencode-limit-input --task K1 --upstream http://127.0.0.1:46483/v1 --model ThinkingCap-Qwen3.8-Flash-Next --sampling-file $RUN/sampling-show.json --out $RUN/raw/thinkingcap-2410-xdock-show-r0/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 262144How fast it runs
| Measurement | Result |
|---|---|
| Decode | 30.5 tok/s |
| Words per second | 20.6 words/s |
| Characters per second | 147.5 chars/s |
| Decode, code prompt | 30.6 tok/s |
| Decode, prose prompt | 30.3 tok/s |
| Spread of the decode runs (CV) | 7.7 % |
| Spread of the code runs (CV) | 5.7 % |
| Spread of the prose runs (CV) | 7.7 % |
| Decode, window 1 | 30.4 tok/s |
| Prefill at 2K | 697.2 tok/s |
| Prefill at 8K | 668.5 tok/s |
| Prefill at 32K | 631.0 tok/s |
| Time to first token at 2K | 2.9 s |
| Time to first token at 8K | 12.3 s |
| Time to first token at 32K | 51.9 s |
| Draft acceptance rate | 42.7 % |
| Mean accepted length | 2.7 tokens |
| 1 request at once (total) | 23.6 tok/s |
| 2 at once (total) | 34.0 tok/s |
| 4 at once (total) | 46.0 tok/s |
| 8 at once (total) | 44.3 tok/s |
| 1 request at once (per request) | 23.6 tok/s |
| 2 at once (per request) | 17.4 tok/s |
| 4 at once (per request) | 12.0 tok/s |
| 8 at once (per request) | 7.6 tok/s |
| Server slots (from the recipe) | 4 slots |
| Long answer, wall time | 128.8 s |
Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; 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-10-25. Raw files: speed result · speed contract · log · long answer.
Requests at once: the server has 4 slots (from the author's recipe). C8 exceeds the slots: the extra requests wait in the queue, and they were measured anyway. The speed test ran the author's serve command with one addition (bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-GGUF at revision 76d5cd6f, README 'Speculative decoding (MTP)'): llama-server on the Q4_K_M files (8 parts, 113.2 GB; the card calls Q4_K_M the recommended size/quality balance), --spec-type draft-mtp --spec-draft-n-max 4, llama.cpp commit 5f5acfe (the commit the card says it was checked with), context 262,144 tokens (the author's command sets no -c, so the server loads the model's own value), no -np (so the server default of 4 slots with a shared KV cache, tools/server/server.cpp lines 169 to 172), F16 KV cache. One flag was added: --cache-ram 0 (no RAM prompt cache). Two runs of the same setup make up this page. My first run (job thinkingcap-2410b) used the author's command exactly. It was killed by the Linux out-of-memory killer three times out of three, each time at the start of the 2-requests-at-once test (the server log ends without a message, dmesg shows "Out of memory: Killed process (llama-server)"): the author's setup (context 262,144, 4 slots, prompt cache on) needs 114.85 GiB at its peak on this 121 GiB box, and every parallel request adds a prompt-cache entry of about 500 MiB. For the second run (job thinkingcap-2410c) I added one flag, --cache-ram 0, which switches the server's RAM prompt cache off; I asked for no prompt cache in the speed test anyway. Model file, llama.cpp commit, context of 262,144 tokens, 4 slots, MTP drafts and sampling are the same in both runs. Speed, quality and sparkDash on this page are from the second run; the memory test and the voxel-world build are from the first run, with the author's own command (prompt cache on). The flag changes no weights, context or sampling; it only limits the server's RAM cache of earlier prompts. I did not repeat the build test, which takes about 100 minutes, with the flag. Sampling for the speed test is the non-thinking sampling of the base Qwen3.8-Flash-Next card (temperature 0.7, top_p 0.8, top_k 20, presence penalty 1.5), because the ThinkingCap card gives no values for thinking off; seed 42; no prompt cache in the requests. The headline 30.45 tok/s is the mean of the code prompt (30.63) and the prose prompt (30.28), medians of two runs each (spread 5.7 % and 7.7 %). The draft acceptance was 42.7 % (2.705 tokens per round). Requests at once: the author's command sets no -np, so the server runs 4 slots. C1, C2 and C4 fit into them; C8 sends 8 requests at once and the other 4 wait in the queue, which is why 8 at once is not faster than 4 at once. A larger -np is possible with the shared KV cache; I did not test it, because the author's command does not set it.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
python3 speed2.py --base-url http://127.0.0.1:42433/v1 --label thinkingcap-2410c-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/thinkingcap-2410c-speed-r0/thinkingcap-2410c-speed-r0/speed2 --contract $RUN/raw/thinkingcap-2410c-speed-r0/thinkingcap-2410c-speed-r0/speed2/speed-contract.json --parts decode,prefill,conc,l1 --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 --sampling {"temperature": 0.7, "top_p": 0.8, "top_k": 20, "min_p": 0.0, "presence_penalty": 1.5} --sampling-source thinking: bottlecapai/ThinkingCap-Qwen3.8-Flash-Next README 'Serving' (temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, thinking on at reasoning_effort=xhigh, the template default); instruct (thinking off): the ThinkingCap card gives no non-thinking values, so the base Qwen3.8-Flash-Next README Instruct/non-thinking values as on the other Qwen3.8-Flash-Next cards --model ThinkingCap-Qwen3.8-Flash-Next --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt --server-slots 4 --server-slots-source llama.cpp 5f5acfe tools/server/server.cpp:169-172 (-np auto = 4 slots, kv_unified); the author's command (GGUF README.md 'Speculative decoding (MTP)') sets no -npHow well it answers
| Test | Result95 % margin | Right | Cut offcount as wrong | Raw files | |
|---|---|---|---|---|---|
| MMLU-Pro 400 fixed questions, letter only | 61.8 % ± 4.7 pts | 247 / 400 | 0 | answers · summary · log · contract | command |
| GPQA Diamond 198 questions, letter only | 51.5 % ± 6.9 pts | 102 / 198 | 4 | answers · summary · log · contract | command |
| IFEval 200 fixed prompts, strict | 85.5 % ± 4.9 pts | 171 / 200 | 0 | answers · summary · log · contract | command |
| LiveCodeBench 40 newest tasks, the code runs | 57.5 % ± 14.7 pts | 23 / 40 | 0 | summary · log · contract | command |
| Long text 8K 4 tasks x 10 at 8192 tokens | 75.0 % ± 13.0 pts | 30 / 40 | 0 | log · contract · answers · summary | command |
| Long text 32K 4 tasks x 10 at 32768 tokens | 57.5 % ± 14.7 pts | 23 / 40 | 0 | log · contract · answers · summary | command |
| GPQA 30, thinking on 30 questions, limit 16,384 tokens | 83.3 % ± 13.1 pts median 2,943 tokens, 207.8 s per question | 25 / 30 | 4 | log · contract · answers · summary | command |
Thinking off, except the last test. Seed 42. Sampling from the model card. A cut-off answer counts as wrong. Measured 2026-10-25.
Note from the run: Quality ran on the second run (prompt cache off, see the speed note). The questions ran 4 at a time, the server's slot count (same questions, limits and seed 42 for every question); the median time per question of the thinking test (207.8 s) was measured under that load. MMLU-Pro and GPQA Diamond ran with a short answer limit (the answer is one letter); IFEval and LiveCodeBench with longer limits, none cut off in LiveCodeBench (0). Answers cut off at their limit count as wrong: 4 of the 198 GPQA Diamond answers (the short letter-only limit) and 4 of the 30 GPQA answers with thinking (the limit of 16,384 tokens); no other test lost an answer. GPQA Diamond ran from the public mirror fingertap/GPQA-Diamond (198 questions), because the original is gated and I had no access token. Sampling: instruct tests with the base Qwen3.8-Flash-Next card's non-thinking values (temperature 0.7, top_p 0.8, top_k 20, presence penalty 1.5, because the ThinkingCap card names none), GPQA with thinking with the ThinkingCap card's values (temperature 1.0, top_p 0.95, top_k 20). These are my own tests, and no other run of this setup is mixed into the quality numbers on this page. Two runs of the same setup make up this page. My first run (job thinkingcap-2410b) used the author's command exactly. It was killed by the Linux out-of-memory killer three times out of three, each time at the start of the 2-requests-at-once test (the server log ends without a message, dmesg shows "Out of memory: Killed process (llama-server)"): the author's setup (context 262,144, 4 slots, prompt cache on) needs 114.85 GiB at its peak on this 121 GiB box, and every parallel request adds a prompt-cache entry of about 500 MiB. For the second run (job thinkingcap-2410c) I added one flag, --cache-ram 0, which switches the server's RAM prompt cache off; I asked for no prompt cache in the speed test anyway. Model file, llama.cpp commit, context of 262,144 tokens, 4 slots, MTP drafts and sampling are the same in both runs. Speed, quality and sparkDash on this page are from the second run; the memory test and the voxel-world build are from the first run, with the author's own command (prompt cache on). The flag changes no weights, context or sampling; it only limits the server's RAM cache of earlier prompts. I did not repeat the build test, which takes about 100 minutes, with the flag.
Exact commands we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts mmlupro --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts gpqa --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts ifeval --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts lcb --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts ruler --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts ruler --job thinkingcap-2410cbash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts think --job thinkingcap-2410cHow much context fits
| Context size | Prompttokens | Filled | First token | Prefilltok/s, as the server reports it | Decodetok/s | Peak memoryGiB | Result |
|---|---|---|---|---|---|---|---|
| 4K 4,096 tokens | 3,891 | 95.0 % | — | 666 | 33.8 | 112.32 | answered (length) |
| 8K 8,192 tokens | 7,782 | 95.0 % | — | 676 | 26.6 | 110.89 | answered (stop) |
| 16K 16,384 tokens | 15,564 | 95.0 % | — | 675 | 29.4 | 111.74 | answered (stop) |
| 32K 32,768 tokens | 31,129 | 95.0 % | — | 657 | 24.7 | 112.28 | answered (stop) |
| 64K 65,536 tokens | 62,259 | 95.0 % | — | 647 | 31.3 | 113.18 | answered (stop) |
| 128K 131,072 tokens | 124,518 | 95.0 % | — | 622 | 21.2 | 114.23 | answered (stop) |
| 256K 262,144 tokens | 249,036 | 95.0 % | — | 566 | 17.6 | 114.85 | answered (stop) |
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 rise of used memory (MemTotal - MemAvailable) over the idle value before the step, on the one box. Unified memory, so GPU and CPU share it. Measured 2026-10-25. Raw files: result of every step · log · contract.
Note from the run: This memory test comes from the first run, with the author's own command and the prompt cache on (see the speed note for why a second run exists). The largest size tested is the model's own context of 262,144 tokens, which the author's command loads; the sizes from 4K to 131K came before it. For each size the server was started again with --fit off and the size as context, one prompt that fills about 95 % of it was sent, and the model answered at every size. The memory number is the rise of used memory over the idle value of the GB10 box (unified memory, so GPU and CPU share it): 112.32 GiB already at 4,096 tokens (the 113 GB model file), 114.85 GiB at 262,144 tokens (a prompt of 249,036 tokens); the box has about 121 GiB, which leaves little room, and this is what made the first run's 2-requests-at-once test run out of memory. The decode speed at the largest size was 17.63 tok/s (96 generated tokens, one request).
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
bash tools/quality2/measure_all.sh tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json --parts fit --job thinkingcap-2410bAlso made this possible
- Base model (Qwen3.8-Flash-Next)
QwenHugging Face @Alibaba_Qwen GitHub Website - Engine (llama.cpp)
ggml-org (llama.cpp)@ggml_org GitHub Hugging Face 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 DGX Spark (GB10, 128 GB unified memory), one box.
- Model
- bottlecapai/ThinkingCap-Qwen3.8-Flash-Next GGUF Q4_K_M @76d5cd6f
- Fine-tune, GGUF Q4_K_M and serve command
- huggingface.co/bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-GGUF
- Base model (Qwen3.8-Flash-Next)
- huggingface.co/Qwen/Qwen3.8-Flash-Next
- Engine
- llama.cpp 5f5acfe on one DGX Spark, the maker's own GGUF with MTP drafts, context 262,144 tokens — the program that loads the model and answers requests · github.com/ggml-org/llama.cppBuild and settings we used: llama.cpp 5f5acfe (built from source, CUDA sm_121, aarch64), MTP self-speculation (--spec-type draft-mtp, 4 drafts), F16 KV
Steps
Get the engine and the model files from the list above.
Exact command we measured withfor reproducing↓
You do not need this to run the model. It is the start text exactly as our run recorded it, with the engine build in front, so anyone can repeat the result.
# Memory test and voxel-world build (first run, job thinkingcap-2410b): the author's command, unchanged
llama.cpp 5f5acfe (built from source, CUDA sm_121, aarch64), MTP self-speculation (--spec-type draft-mtp, 4 drafts), F16 KV; llama-server -m ThinkingCap-Qwen3.8-Flash-Next-Q4_K_M-00001-of-00008.gguf --alias ThinkingCap-Qwen3.8-Flash-Next -c 262144 --spec-type draft-mtp --spec-draft-n-max 4 --host 127.0.0.1 --port 8888
# Speed, quality and sparkDash (second run, job thinkingcap-2410c): the same command plus --cache-ram 0 (RAM prompt cache off)
llama.cpp 5f5acfe (built from source, CUDA sm_121, aarch64), MTP self-speculation (--spec-type draft-mtp, 4 drafts), F16 KV; llama-server -m ThinkingCap-Qwen3.8-Flash-Next-Q4_K_M-00001-of-00008.gguf --alias ThinkingCap-Qwen3.8-Flash-Next -c 262144 --spec-type draft-mtp --spec-draft-n-max 4 --cache-ram 0 --host 127.0.0.1 --port 8888Context and sampling: 262,144 tokens (the model's own window, passed as -c 262144; the author's command sets no -c, the server then loads the model value), 4 server slots (llama.cpp default, shared KV cache), F16 KV cache, MTP self-speculation with 4 drafts, seed 42, no prompt cache requested; speed, quality and sparkDash with --cache-ram 0 (second run), memory test and builds with the author's command unchanged (first run). Sampling from the cards, per part: speed, quality and sparkDash with thinking off use the base Qwen3.8-Flash-Next card's values (temperature 0.7, top_p 0.8, top_k 20, presence penalty 1.5; the ThinkingCap card gives none); GPQA with thinking and the build tests with thinking on use the ThinkingCap card's values (temperature 1.0, top_p 0.95, top_k 20; reasoning effort xhigh, the template default). The answer limit for the build tests was 253,952 tokens, the value the maker names ("The generation cap is 253,952 tokens for most benchmarks", ThinkingCap README 'Serving'); the server cuts it to the free context per request. Agent for the build tests: OpenCode 1.19.3, because neither BottleCapAI nor Qwen names a local agent harness. Hardware: 1x NVIDIA DGX Spark (GB10, 128 GB unified memory), one box.. All raw files of this setup: raw/v2/thinkingcap-flash-next-gguf-1spark-llamacpp.
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.
| Test | Result95 % margin | Right | Cut offcount as wrong | Raw files | |
|---|---|---|---|---|---|
| Quality QA 150 questions | 88.7 % ± 5.1 pts | 133 / 150 | 0 | answers · summary | command |
| Quality MMLU 285 questions | 90.2 % ± 3.5 pts | 257 / 285 | 9 | answers · summary | command |
| Tool Eval Quick 15 scenarios, tool use | 97 / 100 | 14 / 15 passed | — | tool eval result · tool eval report · tool eval command · summary | command |
| Decode, 1 request at once first token 110 ms | 57.9 tok/s | — | — | decode result · summary | command |
| Prefill at 4K first token 4.8 s | 862.3 tok/s | — | — | prefill result · summary | command |
| Prefill at 8K first token 10.4 s | 796.2 tok/s | — | — | prefill result · summary | command |
| Prefill at 16K first token 19.9 s | 831.1 tok/s | — | — | prefill result · summary | command |
| Prefill at 32K first token 42.3 s | 778.6 tok/s | — | — | prefill result · summary | command |
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-25. 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 runs its own tests (its own QA and MMLU questions at temperature 0, thinking off, a cut-off answer counts as wrong; no QA answer and 9 of the 285 MMLU answers were cut off at the answer limit and count as wrong), so its decode and prefill values are not comparable with Speed v2 above: its decode test uses a structured prompt, Speed v2 a code and a prose prompt. The sparkDash client ran on another machine and was never part of the measured group. It ran on the second run (prompt cache off).
Exact commands we measured withfor reproducing↓
You do not need this to run the model. It is the exact command of our measurement, so anyone can repeat the result.
python3 tools/quality2/sparkdash_client.py tools/quality2/cards/thinkingcap-flashnext-q4km-llamacpp-5f5acfe-1x-2410-cr.json <box> --client <client machine> --job thinkingcap-2410c --out $RUNtool-eval-bench --base-url http://127.0.0.1:<port> --model ThinkingCap-Qwen3.8-Flash-Next --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/thinkingcap-2410c-sparkdash-r3/tooleval/result.json --no-live