fpga-archive-demo-box1-20261110 · EAGLE4 FPGA archive
Demo auto-run loop on box1: built, tested, and LIVE (2026-11-10)
The user asked for this verbatim: "can you for demo demo site on box1 build this in with our collectd best prompts?" "This" is Finn's spec, docs/DEMO_AUTORUN_SPEC_FINN_20261106.md. The work was done by a box1-qwen-junior worker.
State: SWAPPED LIVE at 18:41:07Z, 1.2 s downtime. https://demo.yshicarrick.com is served by the new demo_server.py (md5 0c25a7dc…) and demo.html (md5 d020cf31…). The server is pid 2993342 on 0.0.0.0:8099 with TLS. The public URL returned HTTP 200 for /api/autorun/status and /demo.html (demo login), and 404 for /autorun_logs/.... The loop is IDLE. Boot state is Manual.
Nothing else was touched: the engine on :30020, cards 01/42/61/62, cloudflared, eagle4-dashboard.service and the H200 memory. No new GPU engine was started.
Rollback (one command, about 1 s of downtime)
bash scripts/4c1/demo/demo_autorun_swap.sh rollback
The script copies demo_server.py.bak_20261110_pre_autorun (md5 b3e8bfa0…, the pre-swap live file) and demo.html.bak_20261110_pre_autorun (md5 3c6aa0bc…) back over the live files. It then restarts only the uvicorn on :8099. It finds that pid with ss and checks its argv in /proc before stopping it. It relaunches the server exactly as serve_demo.sh does. swap and restart modes also exist.
What was built
| File | Role |
|---|---|
reports/arch_site/demo_autorun.py (md5 98a7a47e) |
The server-side loop. It provides /api/autorun/{start,pause,resume,stop,status,sets}, with aliases at /autorun/*. It holds MODEL_CFG, the per-model limits with their evidence. Each prompt is a fresh one-turn conversation. The default gap is 1.5 s. The loop wraps at the end of a set; dataset order is the default and shuffle is optional. A prompt fails after 60 s with an error marker and is skipped. After 3 consecutive failures the loop backs off for 10 s. It pauses above 85 °C on card 61:00.0 (ami_tool sensors, polled every 10 s). It keeps the last 5 turns. Status is long-polled with since and hv. |
demo_server.py (= tested demo_server_autorun.py) |
The three chat generators moved to module level unchanged; only their arguments changed. The loop drives the same generate path as manual chat. While the loop is active (running or paused), these answer "busy": /api/chat with 409, /api/chat/stream with an SSE error frame, and POST /api/model, /model/probe, /model/readback and `/drafter/free_run |
demo.html (= tested demo_autorun.html) |
Adds a Manual / Auto-run control beside the mode tabs and a "Max reply 256/512/1024" selector. Manual defaults to 256, as before. The Auto-run bar has a set picker, Shuffle, Start (Apply while running), Pause/Resume and Stop. It also adds the tally strip and a "source · n of N" label above each turn. Replies render with the same gold burst blocks. Model switch and "Measure drafter speed" are disabled while the loop runs. Every viewer follows the one loop, and a refresh reattaches. Switching to Manual stops the loop after a confirm. Clicking a mode tab mid-loop switches modes at the next prompt and resets the tally. |
reports/arch_site/prompts/*.jsonl + MANIFEST.json |
best_llama (15) is the DEFAULT set; best_qwen (10) is used only if Qwen is served. humaneval164 (164) uses the wrapper "Complete the code I provided." + prompt, which matches all 80 measured rows byte for byte. speedbench_qualitative has 880 rows (11 categories × 80, turns[0]). n_tok is counted with the endpoint's chat template; words_in_sentence gives 282, equal to the engine's prompt_tokens 282. Rows over the 512-token prompt budget are dropped at load and the count is shown: 1 of 164 HumanEval rows and 96 of 880 SPEED-Bench rows. test_errskip.jsonl loads only with EAGLE4_AUTORUN_TESTSETS=1 and is hidden on the live server. |
scripts/4c1/demo/build_autorun_prompt_sets.py |
Builds the sets offline. Inputs were fetched once from Hugging Face into /mnt/data/eagle4_scratch/humaneval164_raw_20261110/he_test.parquet (md5 755ae047) and /mnt/data/eagle4_scratch/speedbench_raw_20261110/qualitative_test.parquet (md5 58d4d3ac). SPEED-Bench (nvidia/SPEED-Bench, nvidia-evaluation-dataset-license) was reachable, so all three sets ship. |
scripts/4c1/demo/test_demo_autorun.py |
The acceptance tests below. Credentials are read from demo_auth.conf and never printed. |
scripts/4c1/demo/demo_autorun_swap.sh |
swap / rollback / restart. |
reports/arch_site/autorun_logs/autorun_YYYYMMDD.jsonl |
One line per prompt: set, id, mode, model, cap, tokens, tok/s, accept, verify steps, ttft, wall, ok/err, text. This answers Finn's open question with yes. Not served publicly. |
Token cap (max context)
- The ATT image E2b
0xE4B713E2has CTX_WIN 768 (straps read from the 0x13E0 xml,ATT_PHASE_CYCLES_E2b.md:9). The host default isEAGLE4_CTX_WIN768 (c4_loop.py:35), and the live endpoint does not override it. At d11 the md-aware cap is 680 rows. - Rows past the cap are clamped by the host (
c4_loop.py:305-309). The H200 still verifies every token, so a longer reply stays correct, but its accept can fall. - Finn's formula,
min(1024, card_ctx − 512), would give 256. It assumes a hard window, and the host clamp means there is none, so the cap is set by measurement instead. - Measured on this engine at 18:3xZ: a 1024-token reply completed with no error (
finish=length, 1024 tokens, prompt 178, total 1202, 533.37 tok/s @ accept 4.285, 239 verify steps). A 512-token reply ran at 563.17 @ 4.231. HumanEvalwords_in_sentenceat cap 1024 stopped at EOS after 334 tokens (723.65 @ 8.146). - Config: Llama
max_new_measured=1024and selector 256/512/1024. Qwen is set to 512, which is the spec's fallback and not measured. - Default cap per set: Best = 256 and HumanEval = 256, because every measured number for these is at 256. SPEED-Bench = 1024.
Tests and numbers
Tests ran on the :8098 copy, which shared the same engine on :30020 through the normal chat API. The suite was then re-run on the live :8099 after the swap. Raw logs: /mnt/data/eagle4_scratch/demo_autorun_test_{r1,r2,live}_20261110.log.
| Test | :8098 copy | live :8099 |
|---|---|---|
| t1: manual FPGA chat while idle | PASS, 256 tok, 973.32 tok/s @ 7.529 | PASS, 930.22 @ 7.529 |
| t3: Best set, FPGA, cap 256 | 5 prompts, 0 errors: 1,280 tok, mean 1,049.6 tok/s (token-weighted) @ accept 9.08. Per prompt: words_in_sentence 1083 @ 8.83, even_odd_palindrome 995 @ 8.83, sort_array 1066 @ 8.83, is_sorted 1026 @ 9.14, pluck 1084 @ 9.85 | 3 prompts: 992.3 @ 8.83 (995 / 1020 / 963) |
| t4: busy responses during the loop | PASS: stream error frame busy=autorun, /api/chat 409, probe 409, model switch 409 |
PASS |
| t5: pause, then resume | PASS: the reply in flight finished, the count held at 5 for 5 s, and resume continued | PASS |
| t6: refresh reattach | PASS: a fresh status call gets the full snapshot (5 turns, v/hv) | PASS |
| t7: stop | PASS: stop took 0.09 s, the tally reset, and manual chat answered right after | PASS (0.06 s) |
| t8: error-skip (row 2 with a bad mode) | PASS: prompts 4, ok 3, errors 1 (unknown mode 'bogus'), the loop continued and wrapped |
n/a (test set hidden) |
| t9: GPU+EAGLE while that engine is down | PASS: 409 "engine is not running; the auto-run loop never starts engines" | PASS |
| t10: SPEED-Bench, cap 1024 | PASS: 6 prompts, 0 errors, 2,661 tok, 654.3 tok/s @ 5.06 | not run |
| t11: HumanEval 164, cap 512 | PASS: 6 prompts, 0 errors, 1,945 tok, 547.1 tok/s @ 5.98 | not run |
| UI (headless Chrome via CDP, :8098) | PASS: boot view Manual; Auto-run shows 4 sets; Start gives a running tally ("prompts 4 · tokens 1024 · mean 1027 tok/s · mean accept 8.9 · card 51 °C"); bursts render; model buttons and probe are disabled while running and re-enabled after Stop; page reload reattaches (view auto, 5 turns); Pause/Resume and Stop work; Manual send works afterwards; 0 JS exceptions. Screenshots in the session scratchpad (ui/01_running.png … 04_manual.png) |
— |
Offline mock (demo_autorun.Autorun with fake deps) |
PASS: thermal pause at 90 °C ("thermal: card device 90 C > 85 C"), back-off after 3 failures, timeout error marker, set switch at the boundary, stop | — |
Comparison with measured numbers. The 2026-11-09 Best-prompt numbers are 976–1028 tok/s @ 7.31–7.53, measured on F3t/E2b at w2 d7 and cap 256 (DEMO_REQUEST_RECOMMENDATIONS_20261109.md). Through the loop, the live engine (E2b + MLPV 0x1342, w2 d11) measured 992–1050 tok/s @ 8.8–9.1 at cap 256. Accept is higher because the tree is d11 rather than d7. These are MEASUREONLY, goldendepth-unproven runs on Llama, which is how the engine is labelled.
Open items
- GPU modes are untested in the loop. Neither the :30017 (GPU only) nor the :30019 (GPU + EAGLE) engine was up, and I was told not to start any. The loop refuses those modes until a manual message has started the engine. The FPGA-equals-GPU-only greedy text check is therefore not done.
- No 8 h soak. There was no long run, because the H200 was shared with another agent's timing test until 21:00Z. The longest loop run here was under a minute; the loop thread and history were checked for bounds (5 turns, ≤4096 burst entries). An 8 h FPGA soak is still owed.
- Thermal stop reads one card. It uses only card 61:00.0 (MLPV), because that is the sensor the server already reads. The other three cards' power figures come from
power_live.json, which has no temperatures. - Any viewer can drive the loop. Start, Pause and Stop are open to every logged-in viewer, including the public demo tier. Kiosk autostart is not implemented; boot is Manual, as asked.
- Qwen limits are unmeasured. The Qwen cap of 512 and the Qwen best set are config only; this image has not run them.
- Load from these tests. Short bursts of chats went through the engine between 18:30 and 18:41Z while the other agent's H200 draft-only timing test was running. They totalled about 40 replies of ≤1024 tokens.
Addendum 18:45Z: energy card (white paper v5 section 5) — LIVE, demo.html only, no restart
- The user asked: "can we show the mentioned power consumption in box1 demo?" I added a card in the side column, between the live "Drafting energy per token" matrix and the "Drafter (FPGA) speed" panel. It is titled "Energy (measured, talon2 2026-11-04)" and tagged "dated · not live". No live panel was removed or replaced.
- Contents (measured only):
- One drafter forward: 4 V80 0.177 ms · 255.03 W · 45 mJ vs H200 0.37 ms · 276.67 W · 102 mJ.
- H200 power while serving: 227.0 W when the FPGAs draft vs 276.7 W when the GPU drafts.
- H200 J/token: Llama 0.314 vs 0.335; Qwen 1.637 vs 1.689.
- V80 static power: 251.1 W idle · 255.0 W drafting.
- One live line: "H200 on box1 now (live): N W", taken from
/api/telemetry, shown next to the talon2 references of 227.0 W and 276.7 W.
- Sources: every number appears verbatim in
whitepaper_v5.html(lines 411, 480-481, 487-490, 503-504) andCLAIMS_V6_20261104.md(lines 15-17 and 28). The footnote on the card says the forward times are the 2026-10-19 box1 measurement, that the H200 value is a depth-slope fit, and that forward mJ = time × mean W. - Render check: headless Chrome at 390 px in light and dark, plus 1300 px. The page is light-only by design (
color-scheme: light), so the dark-preference render is identical. Page scroll width is 390 px, so there is no horizontal scroll at phone width. 0 JS exceptions. Screenshots:reports/results/DEMO_AUTORUN_BOX1_20261110_shots/phone_{light,dark}.pnganddesktop_light.png. The auto-run UI shots01-04*.pngare in the same folder. - Go-live: I wrote
demo.htmlanddemo_autorun.htmlin place withos.replace(md5 10e0f757…). StaticFiles serves from disk, so 0 s downtime and no restart (pid 2993342 unchanged). The public page shows the card. - Rollback (no restart):
cp reports/arch_site/demo.html.bak_20261110_pre_energy reports/arch_site/demo.html(md5 d020cf31…). A matchingdemo_autorun.html.bak_20261110_pre_energyalso exists. reports/arch_site/demo_energy_preview.htmlis left behind: it is the preview copy and is identical todemo.html. I did not remove it, because file removals are not allowed.
Addendum 18:50-18:55Z: Qwen best-prompt test, then back to Llama d11 (user: "also do the prompt test on qwen")
- Precondition. At 18:50:13Z the H200 held only the demo engine (pid 2786927, 80,360 MiB); the GPU timing agent had released it at 18:49Z.
- Toggle configuration. The web toggle could not switch the E2b cards as the 8099 server was started. Its default flash record names 0x129C, and the last web switch (11-09 19:07) was refused at
c4 discover.- I restarted 8099 at 18:48Z (1.3 s,
demo_autorun_swap.sh restart) withEAGLE4_TOGGLE_FLASH_RECORD=scripts/4c1/flash_records/flash_4c1_box1_e2b_20261107.jsonandEAGLE4_TOGGLE_LATCHED_DEPTH=15, asBOX1_DEMO_READINESS_E2B_F3T_20261110.md§4D prescribes. - The swap script now exports both by default.
- ⚠
eagle4-dashboard.service/serve_demo.shwere NOT changed, so a reboot starts 8099 without them.
- I restarted 8099 at 18:48Z (1.3 s,
- Switch to Qwen (the demo's own toggle, operator tier):
POST /api/model {"model":"qwen27b"}at 18:50:28Z. Run dir/mnt/data/eagle4_scratch/4c1_demo_toggle/qwen27b_20261110_135028.- Steps in order: identity dual → endpoint stopped (
/admin/shutdown) → discover → readback → fold skipped (E2b is G4_EMBFOLD 0) → switch 48.8 s → arm (d7, latched 15) → golden. - Golden:
GOLDEN RECORD-IDENTITY PASS (trees identical 9/9, levels compared 24, record e2b_qwen_md7_2_kc64 md5 8906b857)andGOLDEN GATE PASS by RECORD IDENTITY. The bf16 golden itself reads FAIL 0/9, which is the A8Q design difference. - Endpoint warm after 87 s: Qwen3.8-27B, w2 d7 VTOK 20, FPGA mode, state ready 18:52:52Z.
- Steps in order: identity dual → endpoint stopped (
- Auto-run, Qwen "Best demo prompts", FPGA, cap 256 (run_id 20261110T185300Z): 10/10 prompts, 0 errors, 2,391 tokens. Mean 269.3 tok/s (token-weighted; 270.9 per-prompt mean) @ accept 7.74.
| # | prompt | tokens | tok/s | accept | measured mean (DEMO_REQUEST_RECOMMENDATIONS, talon2, 10 runs) |
|---|---|---|---|---|---|
| 1 | even_odd_palindrome | 256 | 277.44 | 7.758 | 281 @ 7.76 |
| 2 | maximum | 256 | 275.30 | 7.758 | 273 @ 7.76 |
| 3 | remove_vowels | 166 (stop) | 285.52 | 7.905 | 271 @ 7.90 |
| 4 | pluck | 256 | 268.29 | 7.758 | 271 @ 7.76 |
| 5 | max_fill | 256 | 234.63 | 7.758 | 270 @ 7.76 |
| 6 | is_sorted | 256 | 269.74 | 7.758 | 270 @ 7.76 |
| 7 | bf | 256 | 272.24 | 7.758 | 270 @ 7.76 |
| 8 | words_in_sentence | 256 | 276.75 | 7.758 | 270 @ 7.76 |
| 9 | make_a_pile | 177 (stop) | 279.51 | 7.696 | 268 @ 7.70 |
| 10 | fib4 | 256 | 269.22 | 7.529 | 266 @ 7.53 |
- Reading against the records:
- Accept and output lengths match the talon2 per-prompt records exactly: same accept to the third decimal, same stop lengths 166 and 177.
- tok/s is within ±5% of the per-prompt means, except
max_fillat 234.6 (−13%, one request; the cause was not checked). - The 10-prompt box1 mean, 269.3, sits above the humaneval-80 benchmarks: talon2 F3t 249.62, and 4-card FPGA + H200 241.24 @ 7.14 vs GPU + EAGLE 251.20 @ 7.13. The set is the 10 fastest of 80, so it is not the typical request.
- Back to Llama at the demo shape:
scripts/4c1/demo/demo_llama_d11_restore.sh, 18:53:33-18:55:03Z. Run dir/mnt/data/eagle4_scratch/4c1_runs/box1_e2b_demo_llama_back_20261110_135333.- Steps:
/admin/shutdown→ c4 discover → switch llama3b (36 s) → arm 15 (accept-latched 15) → golden md 7,2. - Golden:
GOLDEN RECORD-IDENTITY PASS (trees identical 9/9, levels compared 38, record e2b_llama_md7_2 md5 9a1206e9)andGOLDEN GATE PASS by RECORD IDENTITY. - Endpoint started exactly as the 18:10Z launch (
demo_4c1.sh servewith MODE=fpga MODEL=llama3b DEPTH=11 WIDTH=2 VTOK=20 BACKEND=fa3 LOCK_OWNER=box1-4c1-demo DRAFTER_UI=1 MEASURE_ONLY_GOLDEN_DEPTH_UNPROVEN=1); warm in 50 s. - I did not use the web toggle for the return because its single DEPTH sets both the golden md (records exist at md 7,2) and the serve depth, so it would have come back at d7.
- Steps:
- Confirmed at 18:55:16Z:
/healthreports llama3b, warm, fpga, tree w2 d11 VTOK 20.- Manual FPGA chat: 897.84 tok/s @ 7.529.
- Best-set loop: 3/3 at 977.7 tok/s @ 8.83.
- Loop idle; page boots in Manual.
- The H200 holds only the new demo engine (80,336 MiB).
- Change vs the 18:10Z launch: the new run dir's golden.json carries a record-identity PASS stamp; the 18:10Z run had no stamp. The endpoint is still labelled measure-only, as before.
Addendum 19:50-19:58Z: all three modes kept warm, mode-switch loading bar, no "asleep / warming up" text — LIVE 19:57:37Z (1.18 s)
User, verbatim: "do not show the engine was asleep, warming up… (~1–2 min)!!!! show the mode switching with a loading bar so that a soon as the user type its instant!"
Incident first (19:49–19:55Z, not caused by this change, and it shaped it).
- At 19:49:02Z a public viewer switched the FPGA model to Qwen with the web toggle (DEMO tier + switch password).
- The card steps passed, including record identity 9/9.
- Meanwhile a GPU + EAGLE chat lazily started gpuspec (:30019) during the 27B load. The Qwen engine died:
ValueError: Loaded weights leave no GPU memory for the KV cache under --mem-fraction-static=0.55 ... minimum viable 0.6151, EXIT 137 (demo_serve_fpga_qwen27b_w2d7_20261110_144952.log). - The FPGA endpoint was down from 19:50:52Z. My auto-mode classifier refused to let me run the restore ("interfere with workloads"). I reported it to the coordinator, who restored Llama w2 d11 at 19:55:23Z (record identity 9/9).
- At 19:51:57Z I restarted :8099 (1.3 s) with
EAGLE4_DEMO_NO_REAPER=1, so the idle reaper could not kill the two running GPU engines.
What changed (demo_server.py md5 fe00155b…, demo.html md5 66499db4…, new demo_keepwarm.py, serve_demo.sh):
- Keep-warm supervisor (
demo_keepwarm.py). Every 3 s it checks GPU-only (:30017) and GPU + EAGLE (:30019).- An engine that is down is restarted in the background through the server's own path (
ensure_sgl/ensure_gpuspec), one engine at a time. - The mem fraction is sized from the H200 memory free at that moment (static 13 / 12 GB), since SGLang sizes against free memory at start.
- It never starts an engine while the FPGA model switch runs, while the FPGA endpoint process is starting, or after the manual power-off latch. That is the 19:50Z failure mode.
- The lazy launch inside
ensure_sgl/_ensure_proxyrefuses during a switch for the same reason. - The FPGA endpoint is reported only, never started or stopped.
- Progress comes from the engine's own log milestones (process, weights, KV cache, first request).
GET /api/enginesreturns per-mode state;POST /api/engines/attach {mode}does health + a 1-token request and times it.
- An engine that is down is restarted in the background through the server's own path (
- The idle reaper is off by default. The code default is now
EAGLE4_DEMO_NO_REAPER=1, andserve_demo.shexports it too, so a reboot keeps it. The swap script exports it as well. - Liveness check: SGLang's
/healthon :30017 takes 1.00 s, because it runs a generate. Liveness now uses/get_model_info(about 1 ms). This removed a 1 s stall before every GPU-only reply (measured: client TTFT 1,032 ms before, 29–34 ms after). - Text: "asleep", "warming up", "~1–2 min", "~60-120 s" and "the next message wakes it" are gone from both files (grep = 0, and the headless check
bad_text: false). A down engine now reads "Restarting <mode>". The power panel reads "Restarting in the background". - Page: a mode click shows an attach bar, "Switching to GPU + EAGLE", and the message box is disabled. The bar then shows "<mode> ready · N ms" and the box opens. A down engine shows "Restarting <mode>" with the server's real step and progress, polled every 1 s, and the box opens when the engine is back. The page attaches to the selected mode on load.
Engines now (nvidia-smi, 19:58Z):
| mode | GB |
|---|---|
| FPGA endpoint (Llama w2 d11) | 59.5 |
| GPU + EAGLE (:30019, MEM_FRAC 0.22) | 18.5 |
| GPU only (:30017, frac 0.30) | 20.5 |
| Total | 98.5 of 140.4 GiB |
The two GPU engines were already running (started from the page at about 19:48 and 19:50Z); they were not restarted.
Measured on live :8099 after the swap (/api/chat/stream, "Write a Python function that checks whether a string is a palindrome.", 128 tokens, greedy):
| mode | attach (health + 1 token) | client time to first token | server ttft | decode |
|---|---|---|---|---|
| FPGA (4 cards) | 16 ms | 20 ms | 0.011 s | 1,113.9 tok/s @ 8.53 |
| GPU + EAGLE | 22 ms | 25 ms | 0.017 s | 153.4 tok/s @ 2.78 |
| GPU only | 29 ms | 33 ms | 0.027 s | 85.2 tok/s |
- Headless Chrome on the :8098 copy, same code: each mode switch reaches "ready" in 31–50 ms. The first gold block appears in the page 34–44 ms after Send. 0 JS exceptions.
- Screenshots:
reports/results/DEMO_AUTORUN_BOX1_20261110_shots/switch_{gpuspec,gpu,fpga}_{during,ready}.png. - A mock of the supervisor showed: held during a switch; restart launched at frac 0.163 with 80 GB free; progress 0.03 → 0.10 → 0.20 → 0.75 → 1.0 from the log milestones; then attach OK.
- Not tested: a real crash-restart on silicon. I would have had to stop a running engine, and the coordinator froze the engines for the 20:05–20:35Z energy run.
- Auto-run on live: 3 Best prompts at 1,094.4 tok/s @ 8.83; busy, pause and stop all PASS. The energy card is unchanged on the public page. t9 ("GPU mode refused when engine down") is no longer applicable, because the GPU engines are up.
Rollback: bash scripts/4c1/demo/demo_autorun_swap.sh rollback-warm. It restores *.bak_20261110_pre_warm (demo_server.py 0c25a7dc…, demo.html 10e0f757…) and restarts :8099 only. The rollback still runs without the reaper, because the swap script exports EAGLE4_DEMO_NO_REAPER=1. serve_demo.sh.bak_20261110_pre_warm is the pre-change launcher.
Open:
- Qwen on the FPGA with all three engines warm needs about 114 GB free for the 27B start. The toggle frees the demo GPU engines first (its existing allowlisted path), and the supervisor restarts them after the switch, at about 14–20 GB each in the roughly 60 GB left. That sequence is not exercised yet.
serve_demo.shdoes not setEAGLE4_TOGGLE_FLASH_RECORD/LATCHED_DEPTH, so after a reboot the web toggle refuses the E2b cards, as it did before today.
Addendum 20:16-20:18Z: masthead tiles = current facts; design-audit items 2, 5, 6, 8, 10 (demo.html + measured_pair.json, no restart)
- Tiles (
measured_pair.json, plus the same static fallback markup indemo.html). Each tile carries its source as a hover title and as a small line.- 820.20 tok/s: this box, humaneval 80 × 256, w2 d11, accept 6.90. Mean of 827.25 and 813.15, on E2b 0xE4B713E2 + 0x1342; best 15 demo prompts 951.19 @ 8.72. Measured on box1 2026-11-10. Source:
FOURCARD_DESIGN_20261016/BOX1_E2B_D11_20261110.md:19,82. - 883.12 tok/s: record, labelled talon2 / other cards. Mean of 882.38 and 883.87, @ 6.90, d11 fa3, F3t 0x13F9 + 0x1342. Measured on talon2 2026-11-09. Source:
F3T_CONFIG_SWEEP_20261109.md:12,80,83. - 269.3 tok/s: Qwen on this box, the 10 best prompts once each, @ 7.74, 18:53Z today (this report).
- The old tiles were 241.2 Qwen 10-23, 3.95×, and 860.8 "not the images flashed now". 0 matches remain on the rendered page.
- 820.20 tok/s: this box, humaneval 80 × 256, w2 d11, accept 6.90. Mean of 827.25 and 813.15, on E2b 0xE4B713E2 + 0x1342; best 15 demo prompts 951.19 @ 8.72. Measured on box1 2026-11-10. Source:
- 870.10 vs 700.71 not used. 870.10 is verified as the FPGA cell d15 V20 fa4 @ 7.12, 2,754 steps (
F3T_CONFIG_SWEEP_20261109.md:17,60). 700.71 exists only in the HTML pageFPGA_VS_H200_20261110/index.html; it is in no markdown, TSV or JSON source. It also does not match the GPU-only d15 V20 fa3 738.63 / 740.44 in4C1_DELIVERY_TRACKER.md:1591, which may be a different backend (fa3 vs fa4). Unverified, so it is left off. - One date: "Figures updated 2026-11-10 20:17Z". Each measurement keeps its own true date; the talon2 record is from 11-09 and says so.
- Audit items applied:
- #5:
.rowis now a grid, so labels wrap instead of values. - #6: "Sensors read at HH:MM:SSZ".
- #8: H200 idle line "Idle; N GB held by the three serving engines".
- #10: at ≤640 px the chat head is tighter, and the engine note and Max-reply selector are hidden.
- #2 is the date fix above.
- #5:
- Render check: at 1280 and 390 px against live :8099. Scroll width 1265 / 390, so no horizontal scroll; 0 JS exceptions. Screenshots:
DEMO_AUTORUN_BOX1_20261110_shots/tiles_w{1280,390}.png. - Rollback (no restart):
cd reports/arch_site && cp demo.html.bak_20261110_pre_tiles demo.html && cp measured_pair.json.bak_20261110_pre_tiles measured_pair.json.