Mia's TensorFold recipe: Qwen3.8-Flash-Next, NVFP4 + MTP

What it builds as an agent

Task: Voxel world (3D scene, one HTML file). One attempt, no help. Counted: the final file counts.

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-20. Raw files: check · run info · command · final choice · contract · sampling · screenshot · clip.mp4.

The run's own headless check browser, which renders the page the model built, used up to 1272 % CPU. The load monitor counted it as another process. Browser check 8.5 out of 10: the page loads, runs without console errors, is not blank, shows a world, flies an automatic camera tour and animates; the 1.5 lost points are the frame rate (7.18 frames per second in software rendering without a GPU, 20 are needed) and the orbit check (mouse drag and wheel changed the picture, but less than the check needs: 0.5 of 1 point). The server answers at most 131,072 tokens per request in this run (half of the 262,144 context, the starter default; Mia's recipe default of 32,768 applies only when a request sets no limit). This is the value the model card gives for the final answer; the card names 262,144 for the thinking part, so this run used a lower limit than the highest card value. The longest answer in the run had 46,314 tokens and none was cut off; my test gate shortened the limit of a request 48 times to what was left of the context. The “finish now” message was sent from 90.3 minutes on (9 requests) and the agent ended by itself at 108.6 minutes. The gate sent no keep-alive. Thinking was on with the card's thinking sampling (temperature 1.0, top_p 0.95, top_k 20). One run, one try. The light in the world is off: too dark at night and too bright by day, which the video also says.

run_showcase.sh --harness qwen-code --task VX --upstream http://127.0.0.1:41835/v1 --model Qwen3.8-Flash-Next --sampling-file $RUN/sampling-show.json --out $RUN/raw/plan-2010-show-r4/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 262144

How fast it runs

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median. Measured 2026-10-20. Raw files: speed result · speed contract · log · long answer.

The speed test ran with the instruct (non-thinking) sampling of the model card. The prompt for code ran at 43.15 tok/s, the prose prompt at 42.49 tok/s (medians of two runs each); the headline 42.82 tok/s is the mean of the two. Decode with 2 and 4 requests at once is not measured: the tool could not read the server's slot count, although the recipe runs 5 streams.

python3 speed2.py --base-url http://127.0.0.1:42943/v1 --label run-speed-r0 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/plan-2010-speed-r0/work/speed2 --contract $RUN/raw/plan-2010-speed-r0/work/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 --tokenizer-json $HOME/.cache/huggingface/hub/models--nvidia--Qwen3.8-Flash-Next-FP4-Local/snapshots/b9ce18a6887e18c089fdea8509a33e63429a3300/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 0.7, "top_p": 0.8, "top_k": 20, "min_p": 0.0, "presence_penalty": 1.5} --sampling-source Qwen/Qwen3.8-Flash-Next README.md:343 (Instruct/non-thinking) and :342 (Thinking), local copy not published; generation_config.json (1.0/20/0.95) = thinking default only, not used for instruct --model Qwen3.8-Flash-Next --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt

How well it answers

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

Note from the run: 8 of 30 GPQA answers with thinking were cut off at their limit of 16,384 tokens and 1 of 200 IFEval answers at its limit of 4096 tokens; these count as wrong. MMLU-Pro and GPQA Diamond (letter only) were cut off in no case. These are my own tests of this compressed checkpoint.

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts mmlupro --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts gpqa --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts ifeval --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts lcb --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts ruler --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts ruler --job plan-2010

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts think --job plan-2010

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 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-20. Raw files: result of every step · log · contract.

Note from the run: The largest size tested is 262,144 tokens, the recipe's context; the answer at that size was cut at its length limit, so it counts as loaded but not as answered in full. Decode speed at these sizes is not measured (the server returns no timings), so the sentence on decode speed in the method text does not apply to this run. The memory number is the rise over the idle value, so it includes the model weights.

bash tools/quality2/measure_all.sh tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json --parts fit --job plan-2010

Also made this possible

• ModelQwenHugging Face @Alibaba_Qwen GitHub Website
• FP4 checkpoint (NVFP4)NVIDIAHugging Face GitHub Website
• Engine (TensorFold)Ash Hart@ashxhart 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

Model

nvidia/Qwen3.8-Flash-Next-FP4-Local @b9ce18a6

FP4 checkpoint (NVFP4)

huggingface.co/nvidia/Qwen3.8-Flash-Next-FP4-Local

Engine

TensorFold — the program that loads the model and answers requests · github.com/ashhart/TensorFold

Recipe (one GB10 box)

github.com/MiaAI-Lab/Qwen3.8-Flash-Next-Single-DGX-Spark-TensorFold by Mia (MiaAI-Lab)

Context window

262,144 tokens: how much text the model can see at once

Steps

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

2. Build the engine image first. We built the image tensorfold-qwen38:zig-db28187-c0a2df4c680d locally with the recipe (recipe commit 656879fd). How to build it: see the README of the recipe, github.com/MiaAI-Lab/Qwen3.8-Flash-Next-Single-DGX-Spark-TensorFold.

3. Start the server with this command in the recipe folder. It loads the model into memory. When the model has loaded, the server waits for requests on port 8888.

   Copy

   IMAGE=tensorfold-qwen38:zig-db28187-c0a2df4c680d \
     SERVED_NAME=Qwen3.8-Flash-Next \
     PORT=8888 \
     CHECKPOINT=nvfp4 ./start.sh

   We used the recipe at commit 656879fd.

   What the parts mean

   • PORT=8888the network port the server listens on

TensorFold (Zig, tensorfold-native) image tensorfold-qwen38:zig-db28187-c0a2df4c680d (built locally from recipe @656879fd, TF_REF db281878, patches c0a2df4c680d), MTP drafts on (depth 6); IMAGE=tensorfold-qwen38:zig-db28187-c0a2df4c680d PREPARE=0 PULL=0 SERVED_NAME=Qwen3.8-Flash-Next PORT=8888 CHECKPOINT=nvfp4 ./start.sh ($HOME/flashnext-tf-recipe @656879fd; via spark-1x-flashnext-fp4.sh start)

Mia's own benchmark, run unchanged

This is Mia's own benchmark tool (commit 21a3511), run unchanged. It has its own section here and its own column on the class 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-20. 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.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/flashnext-fp4-mtp-tensorfold-1x.json <box> --client <client machine> --job plan-2010 --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --model Qwen3.8-Flash-Next --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/work/tooleval/result.json --no-live