bertholomus's TP4 recipe: DeepSeek-V4.1-Flash-1017

What it builds as an agent

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

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`.

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 baseline1 / 1

Measured 2026-10-22. Raw files: check · run info · command · final choice · contract · sampling · gate stats · screenshot · clip.mp4.

Other processes used up to 56 % CPU during the run. Browser check 9.0 out of 10: the page loads, runs without console errors, is not blank, shows a world (28,691 parts, 372,250 triangles, English text), flies an automatic camera tour in both windows, animates and answers to mouse drag and wheel; the one lost point is the frame rate (3.11 frames per second in software rendering without a GPU, 20 are needed). The agent finished by itself after 49.7 minutes, one try, no help; the “finish now” message (from 90 minutes) was not needed. 16 versions of the page were seen, 15 loaded without errors, and the last one counts. The limit per answer was 262,144 tokens, the value on the DeepSeek model card (README lines 77 to 84). The author's server default is 32,768 tokens (config.env.example line 25, SERVER_FLAGS) and applies only when a request sets none, so I raised the limit for this test (the server setup is unchanged). 67 requests, no error, no request shortened (8,094,618 prompt tokens, 121,707 answer tokens); 65 requests ended with a tool call and 2 with a normal stop, none at the limit; the longest answer had 33,835 tokens. Thinking was on with the author's sampling (temperature 1.0, top_p 0.95, top_k 20), the context was 1,048,576 tokens. The agent ran in a container on the third GB10 box of the ring (limited to 1.25 GB of memory and 4 CPU cores), because the Mac could not be used as the host in time; the model server and its settings are the same as in the other tests. During the run, my own memory watcher and the ssh health checks of my test tools were running on the boxes; the load monitor counted them as foreign load.

run_showcase.sh --harness dsh-021 --task VX --upstream http://127.0.0.1:18080/v1 --model DeepSeek-V4.1-Flash-TP4 --sampling-file $RUN/raw/bert-vx-2210-show-r0/show.in/sampling-show.json --out $RUN/raw/bert-vx-2210-show-r0/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 1048576

It also built this

Task: Music machine (3D scene with sound, 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.

Design and create the most impressive, creative, elaborate and detailed
physical music machine you are capable of: a 3D machine in which real
physics makes the music. Balls (marbles) roll, drop, bounce and get lifted
through the machine, and every hit on a tuned part (bars, bells, strings,
drums, pipes, anything you invent) plays a note. The look, the instruments
and the mechanics are ENTIRELY your choice — push it as far as you can:
scale, variety, detail, motion, sound quality, musicality. Surprise me.

The machine must play music on request:
- A text field where the user types the kind of piece they want, in their
  own words (for example "sad jazz waltz, slow" or "happy 8-bit chase
  music"), plus a few one-click presets. The machine then plays a matching
  piece: style, mood, tempo, key and instruments must audibly change.
  There is no AI at view time: interpret the text with your own rules.
- The user can play with the balls: grab, drag and throw them, drop new
  balls anywhere with a click, and remove them. A ball the user throws
  must make sound on whatever it hits, through the same physics.
- The music must come from the physics: a note sounds at the moment a ball
  hits the part that makes it, never on a separate timer.

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, the Web Audio API and whatever libraries you like, but embed
  everything — no internet access at view time, no external files, no
  audio files (make all sound with the Web Audio API).
- The machine must present itself: on load it starts playing a default
  piece with an automatic slow cinematic camera tour (orbiting the machine,
  occasionally zooming in on the parts that are playing), plus mouse
  controls (orbit/zoom) for manual viewing. If the browser blocks sound
  until the first click, show a clear "click for sound" hint and start the
  sound on that click; the machine already moves before it.
- 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 runs 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 machine is built, set `window.scene` to the Three.js scene (if you use Three.js) and `window.ready = true`.
- For the automatic test, also provide `window.machine` with: `play(text)` (starts a piece for that request text), `addBall(x, y, z)` (drops a ball at that point and returns an id), `throwBall(id, vx, vy, vz)`, and `hits` (an array that gets one entry `{t, note, part}` for every note played, with `t` from `performance.now()`).

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)1 / 1
• window.machine API: play / addBall / throwBall functions + hits array (0.25), hit entries {t, note, part} (0.25)0.5 / 0.5
• default piece plays on load without input: new hits within 15 s after window.ready (>= 3 full, 1-2 half)1 / 1
• play(text) twice (sad jazz waltz / happy fast 8-bit chase): each >= 4 hits in 15 s (0.25 each), the two differ in tempo or notes (0.5)1 / 1
• addBall returns an id and throwBall(id, ..) works (0.25), >= 1 new hit within 5 s after the throw (0.25)0.5 / 0.5
• Web Audio: an AudioContext exists (0.5) and is running (0.5), >= 10 oscillator / buffer-source start() calls (0.5), >= 50 % of the hits have a start() within 30 ms (0.5)2 / 2

Measured 2026-10-22. Raw files: check · run info · command · final choice · contract · sampling · gate stats · screenshot · clip.mp4.

Other processes used up to 100 % CPU during the run. This extra build test ran with version 1 of the music-machine prompt (sha256 e2de9d67..., the text shown below). The prompt has been revised since; this run was not repeated with the newer text. Browser check 10.0 out of 10: the page loads, runs without console errors, is not blank, runs at 31.88 frames per second in software rendering, offers the machine's play, addBall and throwBall functions, plays a piece on load, changes the piece when asked for a sad jazz waltz and a happy 8-bit chase, and has a running Web Audio context. The agent finished after 91.9 minutes, one try, no help. The “finish now” message (from 90 minutes) was sent 3 times, the first time at 91.0 minutes. 49 versions of the page were seen, 45 loaded without errors, and the last one counts. The limit per answer was 262,144 tokens (DeepSeek model card), the author's server default is 32,768. 104 requests, no error, no request shortened (24,862,928 prompt tokens, 327,264 answer tokens); 103 requests ended with a tool call and 1 with a normal stop, none at the limit; the longest answer had 34,446 tokens. The settings and the agent host are the same as for the voxel world.

run_showcase.sh --harness dsh-021 --task MM --upstream http://127.0.0.1:18080/v1 --model DeepSeek-V4.1-Flash-TP4 --sampling-file $RUN/raw/bert-mm-2210-show-r0/show.in/sampling-show.json --out $RUN/raw/bert-mm-2210-show-r0/show --limit-s 7200 --inject-after-s 5400 --poll-s 20 --ctx 1048576

How fast it runs

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-22. Raw files: speed result · speed contract · log · long answer.

Requests at once: the server has 16 slots (from the author's recipe). The speed test ran with the author's settings: 16 streams (config.env.example line 31), DSpark drafts on, context 1,048,576 tokens, the request flag for no thinking and the author's sampling (temperature 1.0, top_p 0.95, top_k 20), seed 42. The headline 81.81 tok/s is the mean of the code prompt (82.78) and the prose prompt (80.84), medians of two runs each. Speculative drafts were accepted at a rate of 57.2 %. How the four GB10 boxes are connected is not how the author runs them: the author serves four GB10 boxes over a switched RDMA network; my GB10 boxes are cabled as a switchless ring without diagonals. I used the author's own neighbor mode for that (TF_DS_NEIGHBOR_RDMA=1, the author's pull request 30), together with the switchless NCCL 2.30.7 library. The author's README says this mode was not measured on a switched network. One of the four GB10 boxes (an ASUS GX10) runs an older driver (580.173.02) and kernel (6.17.0-1031) than the other three (580.178.04, 7.0.0-1019); the link check before the run measured all eight links at 109 Gb/s. The window is 25,165,824 positions (the author's v0.3.1 value). The speed test was run twice. The first run (13:35) had a login check of my test tools and my own memory watcher on the boxes inside it. The page uses the second run (15:17), made after that check was stopped and after the watcher moved to the Mac. Two light status scripts of mine (one login to each box every 3 and every 5 minutes) ran during all parts, including the second speed run; its quiet check saw at most 4.7 % of one core as foreign load. The sparkDash section further down is a separate run with sparkDash's own prompts at temperature 0; its decode value (174.23 tok/s, structured output, 400 tokens, one request) belongs to a different test and is not mixed with the speed test.

python3 speed2.py --base-url http://127.0.0.1:37289/v1 --label bert-vx-2210-speed-r5 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/raw/bert-vx-2210-speed-r5/bert-vx-2210-speed-r5/speed2 --contract $RUN/raw/bert-vx-2210-speed-r5/bert-vx-2210-speed-r5/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 --tokenizer-json $HOME/bert-2210/model/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 1.0, "top_p": 0.95, "top_k": 20} --sampling-source The author's served values: bertholomus/deepseek-v4.1-tensorfold-tp4-4xgb10@8f84e7ac config.env.example SERVER_FLAGS '--thinking --max-tokens 32768 --temperature 1.0 --top-p 0.95 --top-k 20' (a request's own values win). The base card deepseek-ai/DeepSeek-V4.1-Flash-1017 README.md:77-84 recommends top_p 1.0; the recipe's served 0.95 wins (SENDEPLAN 8: run it as the author runs it today), same decision as Mia's 2x card. Speed v2 runs with thinking off (enable_thinking false per request), show/think with thinking on. --model DeepSeek-V4.1-Flash-TP4 --no-cache-prompt --server-log $RUN/logs/server-A.log --engine-version-file $RUN/logs/engine-version.txt --server-slots 16 --server-slots-source bertholomus/deepseek-v4.1-tensorfold-tp4-4xgb10@8f84e7ac config.env.example:31 (PARALLEL=16), :32 (ENGINE_ENV TF_DS_STREAMS=16); README.md:39 ('16 streams sharing a 25,165,824-position window')

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-22.

Note from the run: 48 of 400 MMLU-Pro answers and 60 of 198 GPQA Diamond answers started to explain step by step instead of giving the letter, were cut off at the 48-token limit and count as wrong; that is how the model behaves with thinking off, so both scores are lower than for a model that answers with the letter first. None of the 40 LiveCodeBench answers was cut off; 4 of 30 GPQA answers with thinking ran to the limit of 16,384 tokens and count as wrong. The median time of a GPQA answer with thinking is about 20 seconds. GPQA Diamond ran on the public mirror fingertap/GPQA-Diamond (the original is gated). An incident during the thinking part (22 Oct, 14:45 to 14:47, items 7 to 13): the sparkDash test agent's probe server on my Mac tried six logins to the first GB10 box as root (all closed before login, no key, no command) and one further one-second login of my user came from another machine; the load monitor showed no process above 4.8 % of one core in that window. The answers do not depend on wall time (seed 42, the limit counts tokens), so no effect on the scores is expected; the time median of that part cannot be shown to be unaffected. These are my own tests of this pack; the checkpoint's quality is the author's.

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts mmlupro --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts gpqa --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts ifeval --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts lcb --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts ruler --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts ruler --job bert-vx-2210

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts think --job bert-vx-2210

How much context fits

Memory test. The recipe fixes the context (1,048,576 tokens), so the server is started once with the recipe's own command and reserves its memory up front. Then, for each size (4K, 8K, 16K ... up to the largest size tested), one prompt that fills about 95 % of that size is sent, and the model must answer. The largest size that answered counts; it is the highest size tested, not a limit of the setup. Decode speed at that size was not measured. Peak memory is, on each of the four boxes, the rise of used memory (MemTotal - MemAvailable) over the idle value before the step; the table and the number show the highest of the four boxes. Unified memory, so GPU and CPU share it. Measured 2026-10-22. Raw files: result of every step · log · contract.

Note from the run: fit memory per node, highest rise over idle: box-3 103.2 GiB, box-4 100.7 GiB, box-1 99.6 GiB, box-2 99.5 GiB The recipe fixes the context (1,048,576 tokens): the server was started once with the author's setting, then a prompt of about 95 % of each size from 4K up to 128K (131,072 tokens) was sent. 128K is the largest size tested, not the largest size the setup can load. Decode speed at these sizes is not measured. The memory number is the rise of used memory over the idle value, so it includes the model weights; the number shown is the highest of the four boxes.

bash tools/quality2/measure_all.sh tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json --parts fit --job bert-vx-2210

Also made this possible

• ModelDeepSeekHugging Face @deepseek_ai GitHub Website
• Model files (EXL3 4.0 bpw, rev a2f91e27)bertholomusHugging Face @bertholomusai GitHub
• Engine (TensorFold)Ash Hart@ashxhart GitHub Hugging Face Website
• EXL3 formatturboderp@turboderp_ Hugging Face GitHub

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

4x NVIDIA DGX Spark class boxes, tensor parallel 4 over a switchless CX7 ring without diagonals: 2x ASUS Ascent GX10, 1x Gigabyte AI TOP ATOM, 1x Lenovo ThinkStation PGX. One box (an ASUS GX10) runs an older driver (580.173.02) and kernel (6.17.0-1031-nvidia) than the other three (580.178.04, 7.0.0-1019-nvidia). That is named openly.

Model

bertholomus DeepSeek-V4.1-Flash-1017 EXL3 4.0bpw (rev a2f91e27) + checkpoint DSpark drafts

Model files (EXL3 4.0 bpw, rev a2f91e27)

huggingface.co/bertholomus/DeepSeek-V4.1-Flash-1017-EXL3-4.0bpw

Engine

TensorFold, tensor parallel on 4 GB10 boxes (switchless ring), EXL3 4.0 bpw with DSpark drafts — the program that loads the model and answers requests · github.com/ashhart/TensorFold

Recipe, EXL3 4.0 bpw checkpoint and DeepSeek-V4.1 support in TensorFold

github.com/bertholomus/deepseek-v4.1-tensorfold-tp4-4xgb10 by bertholomus

Steps

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

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

   Copy

   serve-ring.sh start

TensorFold native (Zig 0.17.0) a16a167e, TP=4 2D split (parity), DSpark drafts, neighbor RDMA ring (PR #30) with switchless NCCL 2.30.7, kit HF 6c2d074d; serve-ring.sh start ($HOME/bert-2210/config.env, rank order box-3=0 box-4=1 box-1=2 box-2=3; ring variant of the author's scripts/serve.sh via not published start)

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-22. 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.

python3 tools/quality2/sparkdash_client.py tools/quality2/cards/ds1017-bertholomus-exl3-4.0bpw-tp4-4x-v031-vx.json <box> --client <client machine> --job bert-vx-2210 --out $RUN

tool-eval-bench --base-url http://127.0.0.1:<port> --model DeepSeek-V4.1-Flash-TP4 --short --no-think --timeout 120 --json-file $BENCH/sparkdash-client/runs/bert-vx-2210-sparkdash-r6/tooleval/result.json --no-live