You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.
build data / card back
- Build ID
- maze_claude_opus
- Model
- Claude Opus 4.8
- Creator
- Anthropic
- Hardware
- Anthropic API
- Runtime
- Claude Code subagent, Opus 4.8, single-shot
- Quant/config
- frontier API
- Technique
- single-shot frontier control build
- Speed
- single-shot, one agent per game
- Variant
- MAZERUNNER control (gold-standard baseline)
- Team
- 1
- Merge top
- 1
- Minutes
- 5.0
- Score
- 7.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 29264
- Final bytes
- 29264
- Wall time
- 300.0 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_claude_opus_b70_control
- Model
- Claude Opus 4.8
- Creator
- Anthropic
- Hardware
- Anthropic API
- Runtime
- Claude Opus 4.8 single-shot B70 control
- Quant/config
- frontier API
- Technique
- frontier control, one agent per game
- Speed
- not recorded
- Variant
- MAZERUNNER B70 control
- Report
- benchmarks/B70/OPUS_CONTROL_B70.md
- Code quality
- 47/50
- Runtime validator
- teamwork/validate_game.js ok
- Chars
- 29,264
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_gpt_5_5_xhigh
- Model
- GPT-5.5 xhigh
- Creator
- OpenAI
- Hardware
- OpenAI API
- Runtime
- Codex subagent, gpt-5.5, reasoning_effort=xhigh
- Quant/config
- frontier API
- Technique
- single xhigh subagent build
- Speed
- 246 s build wall
- Variant
- Maze xhigh eval
- Team
- 1
- Merge top
- 1
- Minutes
- 4.1
- Score
- 7.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 27964
- Final bytes
- 27964
- Wall time
- 246.0 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_deepseek_v4_pro
- Model
- DeepSeek V4 Pro
- Creator
- DeepSeek
- Hardware
- DeepSeek API
- Runtime
- OpenCode agent, deepseek-v4-pro, thinking mode
- Quant/config
- thinking mode
- Technique
- single agent build with thinking
- Speed
- 150 s build wall
- Variant
- Maze deepseek eval
- Team
- 1
- Merge top
- 1
- Minutes
- 2.5
- Score
- 7.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 24004
- Final bytes
- 24004
- Wall time
- 150.0 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_laguna_xs21_q4_b70
- Model
- Laguna XS 2.1
- Creator
- Poolside / Laguna
- Hardware
- Intel Arc Pro B70
- Runtime
- Laguna XS 2.1 Q4_K_M GGUF, llama.cpp SYCL, -np 6 -c 262144
- Quant/config
- Q4_K_M GGUF
- Technique
- 6-agent B70 teamwork production loop, merge_top=2
- Speed
- 2 rounds, 1805.5 s wall
- Variant
- Laguna XS 2.1 Q4_K_M B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 61.0
- Assertions
- 6/7
- Rounds
- 2
- Seed bytes
- 13816
- Final bytes
- 18440
- Wall time
- 1,805.5 s
- Report
- benchmarks/B70/LAGUNA_XS21_LIVE_EVALS.md
- Runtime validator
- teamwork/validate_game.js ok
- Chars
- 18,440
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_laguna_01
- Model
- Laguna XS 2.1
- Creator
- Poolside / Laguna
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- OpenCode on Atlas via local Ollama
- Quant/config
- Q4_K_M GGUF
- Technique
- 1-agent fleet sample
- Speed
- benchmarked Pareto knee
- Variant
- v2
- Correction
- Preserved after removing mislabeled Laguna v1 import.
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_nex2_teamwork
- Model
- Nex-N2-mini
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- NVFP4 GGUF (s-batman), llama.cpp
- Quant/config
- NVFP4 GGUF
- Technique
- 3-agent teamwork production loop
- Speed
- 62 t/s
- Variant
- teamwork eval
- Team
- 3
- Merge top
- 2
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 29532
- Final bytes
- 33629
- Wall time
- 1,209.5 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_nex2_loop_hour
- Model
- Nex-N2-mini
- Creator
- NEX2 / Hydra
- Hardware
- Turbo via Hydra
- Runtime
- Angel one-hour Nex2 loop; corrected single-file HTML artifact sent through Hydra
- Quant/config
- NVFP4 GGUF
- Technique
- one-hour Hydra loop handoff
- Speed
- 3600 s loop wall
- Variant
- Hydra Salvage Run
- Team
- nex2 hydra loop handoff
- Minutes
- 60.0
- Rounds
- 1
- Seed bytes
- 0
- Final bytes
- 19901
- Wall time
- 3,600.0 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_ornith_aeon_teamwork
- Model
- Ornith-1.0-35B-AEON-Ultimate-Uncensored-NVFP4
- Creator
- AEON-7
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- AEON Ornith + Qwen build configuration
- Quant/config
- NVFP4
- Technique
- 16-agent AEON teamwork production loop over Ornith/Qwen builds
- Speed
- 58/47 t/s
- Variant
- AEON Ornith/Qwen eval
- Team
- 16
- Merge top
- 6
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 4
- Seed bytes
- 16797
- Final bytes
- 18347
- Wall time
- 1,449.0 s
- Hugging Face
- https://huggingface.co/AEON-7/Qwen3.6-27B-AEON-Ultimate-Uncensored-Multimodal-NVFP4-MTP-XS
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v1
- Build ID
- maze_ornith_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v5
- Build ID
- maze_ornith_04
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v2
- Build ID
- maze_ornith_01
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_step37_teamwork
- Model
- StepFun Step-3.7-Flash
- Creator
- StepFun
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- Step-3.7-Flash UD-IQ4_NL GGUF + Q8 MTP draft, llama.cpp, reasoning on
- Quant/config
- UD-IQ4_NL GGUF
- Technique
- 3-agent teamwork production loop
- Speed
- 33.6 t/s aggregate @ team 3
- Variant
- Step37 teamwork eval
- Team
- 3
- Merge top
- 2
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 29713
- Final bytes
- 35956
- Wall time
- 3,380.8 s
- Playability asserts
- 7/7
- Playable
- yes
- Build wall
- 3,380.8 s
- Chars
- 35,956
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_glm_5_2_opencode
- Model
- GLM-5.2
- Creator
- Zhipu AI
- Hardware
- API
- Runtime
- OpenCode single agent, thinking mode
- Quant/config
- thinking mode
- Technique
- single agent build with thinking
- Speed
- not recorded
- Variant
- GLM-5.2 OpenCode eval
- Chars
- 24,886
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- GLM-5.2
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- OpenCode single agent
- Quant/config
- thinking mode
- Technique
- 1-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v1
- Build ID
- maze_glm-5-2_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- MOA:LONGCAT
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- Longcat Studios multi-persona MOA
- Quant/config
- multi-model orchestration
- Technique
- 6-agent MOA improve loop
- Speed
- PR artifact; no throughput sweep recorded
- Version
- v1
- Build ID
- maze_moa_longcat_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_b70_stock
- Model
- AgentWorld-35B-A3B
- Creator
- AgentWorld
- Hardware
- Intel Arc Pro B70
- Runtime
- stock llama.cpp-sycl-moe-clean @ 885e3e325, f16 KV, DNN on, -b 2048 -ub 512
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent B70 stock baseline teamwork production loop
- Speed
- stock baseline; see benchmarks/B70/TURBO_VS_STOCK_B70.md
- Variant
- B70 stock baseline
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 17852
- Final bytes
- 29933
- Wall time
- 2,044.4 s
- Report
- benchmarks/B70/TURBO_VS_STOCK_B70.md
- Stock rounds
- 2
- Stock wall
- 1,966 s
- Playability asserts
- 5/6
- Validator
- teamwork/validate_game.js ok
- Chars
- 29,933
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_b70_live
- Model
- AgentWorld-35B-A3B
- Creator
- Qwen / AgentWorld
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3_5_moe, q8_0 KV, live -np 6/-c 262144 teamwork
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent live B70 teamwork production loop
- Speed
- 223.95 t/s @ 32-agent live tool fleet
- Variant
- B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 17089
- Final bytes
- 27483
- Wall time
- 1,038.1 s
- Report
- benchmarks/B70/AGENTWORLD_LIVE_EVALS.md
- Quality /50
- 40
- Playability asserts
- 7/7
- Playable
- yes
- Validator
- teamwork/validate_game.js ok
- Build wall
- 1,038.1 s
- Chars
- 27,483
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_b70_q5
- Model
- AgentWorld-35B-A3B
- Creator
- Qwen / AgentWorld
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen35moe, q8_0 KV, -np 6/-c 131072 teamwork
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent B70 quant comparison teamwork loop
- Speed
- team 6 / merge-top 2 / 15-min
- Variant
- B70 Q5_K_M quant eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 19019
- Final bytes
- 24135
- Wall time
- 1,105.0 s
- Report
- benchmarks/B70/QUANT_GAMES_B70.md
- Quality /50
- 40
- Playability asserts
- 7/7
- Playable
- yes
- Validator
- teamwork/validate_game.js ok
- Build wall
- 1,105.0 s
- Chars
- 24,135
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_b70_q6
- Model
- AgentWorld-35B-A3B
- Creator
- Qwen / AgentWorld
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q6_K qwen35moe, q8_0 KV, -np 6/-c 131072 teamwork
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent B70 quant comparison teamwork loop
- Speed
- team 6 / merge-top 2 / 15-min
- Variant
- B70 Q6_K quant eval run 1
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 17329
- Final bytes
- 23030
- Wall time
- 1,816.9 s
- Report
- benchmarks/B70/QUANT_GAMES_B70.md
- Quality /50
- 40
- Playability asserts
- 7/7
- Playable
- yes
- Validator
- teamwork/validate_game.js ok
- Build wall
- 1,816.9 s
- Chars
- 23,030
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_b70_q6b
- Model
- AgentWorld-35B-A3B
- Creator
- Qwen / AgentWorld
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q6_K qwen35moe, q8_0 KV, -np 6/-c 131072 teamwork
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent B70 quant comparison teamwork loop
- Speed
- team 6 / merge-top 2 / 15-min
- Variant
- B70 Q6_K quant eval run 2
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 19138
- Final bytes
- 21541
- Wall time
- 1,292.4 s
- Report
- benchmarks/B70/QUANT_GAMES_B70.md
- Quality /50
- 40
- Playability asserts
- 7/7
- Playable
- yes
- Validator
- teamwork/validate_game.js ok
- Build wall
- 1,292.4 s
- Chars
- 21,541
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_longcat_2_chain3
- Model
- Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
- Creator
- Meituan
- Hardware
- Meituan hosted API
- Runtime
- LongCat hosted OpenAI-compatible API, three sequential code-output calls
- Quant/config
- FP8 (Meituan)
- Technique
- 3-call hosted SOTA chain: draft -> repair -> integrate
- Speed
- 338.6 s wall
- Variant
- LongCat chain3 Maze
- Condition
- src/teamwork/longcat_2/condition.txt
- Raw responses
- src/teamwork/longcat_2/raw/maze_chain3_stage1.json, stage2.json, stage3.json
- Published stage
- stage1; later stages hit length cap
- Static checks
- canvas/script/RAF/keyboard/closed HTML
- Runtime validator
- teamwork/validate_game.js ok
- Chars
- 22,588
- Patch
- initialized level before first render
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_longcat_2_one
- Model
- Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
- Creator
- Meituan
- Hardware
- Meituan hosted API
- Runtime
- LongCat hosted OpenAI-compatible API, single call, enable_thinking=false for code output
- Quant/config
- FP8 (Meituan)
- Technique
- one-shot hosted SOTA API generation
- Speed
- 75.1 s wall
- Variant
- LongCat one-shot Maze
- Condition
- src/teamwork/longcat_2/condition.txt
- Raw response
- src/teamwork/longcat_2/raw/maze_one_code.json
- Finish reason
- stop
- Completion tokens
- 5,189
- Static checks
- canvas/script/RAF/keyboard/closed HTML
- Runtime validator
- teamwork/validate_game.js ok
- Chars
- 14,202
- Patch
- fixed malformed rectHitsTile loop
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_gemma4_nvfp4_current_teamwork
- Model
- Gemma-4-26B-A4B NVFP4 current plain vLLM
- Creator
- NVIDIA / Gemma
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- plain vLLM, served model gemma4, max_model_len=32768, max_num_seqs=48, no DFlash
- Quant/config
- NVFP4
- Technique
- 5-agent teamwork production loop, merge_top=2
- Speed
- 785.9 tok/s @ 48-agent throughput sweep; game build used team 5
- Variant
- current plain vLLM eval
- Team
- 5
- Merge top
- 2
- Minutes
- 20.0
- Score
- 61.0
- Assertions
- 6/7
- Rounds
- 3
- Seed bytes
- 9784
- Final bytes
- 17401
- Wall time
- 1,663.0 s
- Run directory
- logs/gemma4-nvfp4-current-agentic-arcade-20260707T165442Z
- Pareto CSV
- src/benchmarks/results_throughput_gemma4_nvfp4_current.csv
- Runtime validator
- teamwork/validate_game.js ok
- Context calibration
- team 5 from 32k window, pad 1.10
- Seed retries
- 2 failed Maze seeds before accepted seed
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_nemotron_labs_3_puzzle_75b_a9b_nvfp4_teamwork
- Model
- NVIDIA-Nemotron-Labs-3-Puzzle-75B-A9B-NVFP4
- Creator
- NVIDIA
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- Official NVFP4/FP8 ModelOpt safetensors, vLLM 0.23.0, max_model_len=8192, MTP speculative decode n=1, max_num_seqs=32, kv_cache_memory_bytes=16G, enforce_eager
- Quant/config
- NVFP4 + FP8 ModelOpt safetensors
- Technique
- 1-agent 20-minute teamwork harness; valid seed preserved, improvement candidates rejected under validator
- Speed
- 319.8 tok/s @ 32-agent fixed-token sweep; game build used team 1 from 8k context calibration
- Variant
- Nemotron Puzzle 75B Spark eval
- Team
- 1
- Merge top
- 1
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 271
- Seed bytes
- 14641
- Final bytes
- 14641
- Wall time
- 1,201.4 s
- Playability asserts
- 7/7
- Playable
- yes
- Build wall
- 1,201.4 s
- Chars
- 14,641
- Seed retries
- 2
- Run directory
- logs/nemotron-labs-3-puzzle-75b-a9b-nvfp4-agentic-arcade-20260708T023643Z
- Pareto CSV
- src/benchmarks/results_throughput_nemotron_labs_3_puzzle_75b_a9b_nvfp4.csv
- Runtime validator
- teamwork/validate_game.js ok
- Context calibration
- team 1 from 8k window, pad 1.10
- Accepted build
- valid seed after two failed seeds; no validator-passing improvement accepted
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Qwen3.6-35B-A3B UD-Q5_K_XL GGUF
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL on Intel Arc Pro B70, 12-slot unified KV
- Quant/config
- UD-Q5_K_XL GGUF
- Technique
- 12-agent live B70 teamwork production loop
- Speed
- 12-slot live teamwork build; see B70 live eval report
- Version
- v1
- Build ID
- maze_qwen36_35b_q5_turbo_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_fable
- Model
- Fable
- Creator
- Fable
- Hardware
- external submission
- Runtime
- single-file HTML artifact from /home/frosty40/fablegames
- Quant/config
- external submission
- Technique
- submitted artifact
- Speed
- not recorded
- Variant
- Fable Maze Shooter
- Source
- /home/frosty40/fablegames/maze game/index.html
- Source bytes
- 29,266
- Validator
- teamwork/validate_game.js ok
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.Bugtown — 31 buggy builds · they load, but the core loop misbehaves
build data / card back
- Model
- AEON QWEN
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- vLLM + z-lab DFlash speculative decode
- Quant/config
- NVFP4 MTP-XS
- Technique
- 8-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v1
- Build ID
- maze_aeon_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- AEON QWEN
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- vLLM + z-lab DFlash speculative decode
- Quant/config
- NVFP4 MTP-XS
- Technique
- 8-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v2
- Build ID
- maze_aeon_01
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v6
- Build ID
- maze_ornith_05
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v4
- Build ID
- maze_ornith_03
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v3
- Build ID
- maze_ornith_02
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_nex2_b70_live
- Model
- Nex-N2-mini
- Creator
- nex-agi base / s-batman NVFP4 GGUF conversion
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3_5_moe, q8_0 KV, live -np 6/-c 262144 teamwork
- Quant/config
- NVFP4 GGUF
- Technique
- 6-agent live B70 teamwork production loop
- Speed
- 224.3 t/s @ 32-agent live tool fleet
- Variant
- B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 22902
- Final bytes
- 30749
- Wall time
- 2,670.2 s
- Quality /50
- 31
- Playability asserts
- 7/7
- Playable
- source-review fail: invisible/unshootable robots
- Build wall
- 2,670.2 s
- Chars
- 30,749
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_gemma_teamwork
- Model
- Gemma-4-26B-A4B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- NVFP4 + DFlash, vLLM
- Quant/config
- NVFP4
- Technique
- 32-agent teamwork production loop
- Speed
- 227 t/s
- Variant
- teamwork eval
- Team
- 32
- Merge top
- 6
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 3
- Seed bytes
- 14968
- Final bytes
- 25689
- Wall time
- 1,316.6 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_b70_solo
- Model
- AgentWorld-35B-A3B
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen35moe
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- Solo
- Variant
- Solo
- Chars
- 11,894
- Playability asserts
- 6/7
- Playable
- yes
- Features
- 1
- Build wall
- 69 s
- Tokens
- 5,668
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agentworld_teamwork
- Model
- AgentWorld-35B-A3B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- official GGUF-NVFP4, llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent teamwork production loop
- Speed
- 50 t/s
- Variant
- teamwork eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 16909
- Final bytes
- 25390
- Wall time
- 1,502.7 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- AgentWorld-35B-A3B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v2
- Build ID
- maze_agentworld_01
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- AgentWorld-35B-A3B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v1
- Build ID
- maze_agentworld_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_aeon_teamwork
- Model
- AEON QWEN
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- MTP-XS + z-lab DFlash drafter, vLLM
- Quant/config
- NVFP4 MTP-XS
- Technique
- 7-agent teamwork production loop
- Speed
- 47 t/s
- Variant
- teamwork eval
- Team
- 7
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 18514
- Final bytes
- 31529
- Wall time
- 1,256.1 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_ornith_b70_failed_seed
- Model
- Frosty Ornith-1.0-35B
- Creator
- Frosty40 / Ornith
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3_5_moe, failed live B70 attempt
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- failed live B70 teamwork attempt
- Variant
- B70 failed attempt
- Playable
- no
- Result
- failed seed: render context bug
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_siq_b70_live
- Model
- SIQ-1-35B
- Creator
- SIQ
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3_5_moe, q8_0 KV, live -np 6/-c 262144 teamwork
- Quant/config
- Q5_K_M qwen35moe
- Technique
- 6-agent live B70 teamwork production loop
- Speed
- 223.7 t/s @ 32-agent live tool fleet
- Variant
- B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 16237
- Final bytes
- 19185
- Wall time
- 1,064.7 s
- Quality /50
- 30
- Playability asserts
- 7/7
- Playable
- source-review fail: frozen player
- Build wall
- 1,064.7 s
- Chars
- 19,185
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_siq_gb10_teamwork
- Model
- SIQ-1-35B
- Creator
- SIQ
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- SIQ-1-35B Q5_K_M imatrix GGUF, llama.cpp, reasoning on
- Quant/config
- Q5_K_M qwen35moe
- Technique
- 7-agent teamwork production loop
- Speed
- ~54 t/s
- Variant
- GB10 teamwork eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 27117
- Final bytes
- 27455
- Wall time
- 1,207.9 s
- Playability asserts
- 7/7
- Playable
- yes
- Build wall
- 1,355.3 s
- Chars
- 21,589
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_quest_b70_live
- Model
- QUEST-30B-RL
- Creator
- Quest / qwen3moe
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3moe, q8_0 KV, live -np 4/-c 131072 teamwork
- Quant/config
- Q5_K_M qwen3moe
- Technique
- 6-agent live B70 teamwork production loop, safe 131k context
- Speed
- 335.5 t/s @ 32-agent live tool fleet
- Variant
- B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 12173
- Final bytes
- 20597
- Wall time
- 3,115.7 s
- Quality /50
- 29
- Playability asserts
- 7/7
- Playable
- source-review fail: overlay never hides
- Build wall
- 3,115.7 s
- Chars
- 20,597
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_ornith_b70_live
- Model
- Frosty Ornith-1.0-35B
- Creator
- Frosty40 / Ornith
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen3_5_moe, q8_0 KV, live -np 6/-c 262144 teamwork
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent live B70 teamwork production loop
- Speed
- 224.9 t/s @ 32-agent live tool fleet
- Variant
- B70 live teamwork eval
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 18820
- Final bytes
- 22724
- Wall time
- 1,078.3 s
- Quality /50
- 34
- Playability asserts
- 7/7
- Playable
- source-review fail: cannot shoot
- Build wall
- 1,078.3 s
- Chars
- 22,724
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_ornith_b70_stock
- Model
- Frosty Ornith-1.0-35B
- Creator
- Frosty40 / Ornith
- Hardware
- Intel Arc Pro B70
- Runtime
- stock llama.cpp-sycl-moe-clean @ 885e3e325, f16 KV, DNN on, -b 2048 -ub 512
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent B70 stock baseline teamwork production loop
- Speed
- stock baseline; see benchmarks/B70/TURBO_VS_STOCK_B70.md
- Variant
- B70 stock baseline
- Team
- 6
- Merge top
- 2
- Minutes
- 15.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 1
- Seed bytes
- 19692
- Final bytes
- 19692
- Wall time
- 989.8 s
- Report
- benchmarks/B70/TURBO_VS_STOCK_B70.md
- Stock rounds
- 1
- Stock wall
- 749 s
- Playability asserts
- 6/6
- Validator
- teamwork/validate_game.js fail: Cannot read properties of undefined (reading '0')
- Playable
- no; runtime validator failure
- Chars
- 19,692
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_leanstral_119b_nvfp4
- Model
- Leanstral-1.5-119B-A6B GGUF-NVFP4
- Creator
- Mistral AI base / Frosty40 GGUF-NVFP4 conversion
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- GGUF-NVFP4, llama.cpp local OpenAI-compatible server, ctx=32768, f16 KV
- Quant/config
- GGUF-NVFP4
- Technique
- single local model run with validator-guided repair loop
- Speed
- 1.26 min build wall; repo-validator accepted round observed 49.41 tok/s decode
- Variant
- Leanstral NVFP4 Robot Maze eval
- Team
- 1
- Merge top
- 1
- Minutes
- 1.26
- Score
- 8.0
- Assertions
- 8/11
- Rounds
- 1
- Seed bytes
- 9303
- Final bytes
- 9303
- Wall time
- 75.8 s
- Report
- benchmarks/LEANSTRAL_119B_NVFP4_AGENTIC_ARCADE_20260703.md
- AgentMail
- 19f2a482f2d7a2b3
- Validator
- teamwork/validate_game.js ok
- Browser interaction
- failed; no canvas change after input
- Playable
- no; browser interaction failed
- Build wall
- 75.8 s
- Chars
- 9,303
- Runtime context
- 32,768 tokens
- Trained context
- 1,048,576 tokens
- GGUF SHA256
- 4668fd2a6d2764de250489852230e96238eb5c0d7495866eb3b9c6c4fac5c7da
- DSpark
- not used
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- AEON QWEN
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- vLLM + z-lab DFlash speculative decode
- Quant/config
- NVFP4 MTP-XS
- Technique
- 8-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v3
- Build ID
- maze_aeon_02
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_agents_a1_teamwork
- Model
- InternScience/Agents-A1 (35B MoE, agentic)
- Creator
- InternScience
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- BF16 safetensors, vLLM 0.23.0, BF16, FlashInfer CUTLASS MoE
- Quant/config
- BF16 (unquantized)
- Technique
- 6-agent teamwork production loop, max_tokens=32768, merge_top=3
- Speed
- 348.9 tok/s @ 32-agent throughput sweep; game build used team 6
- Variant
- Agents-A1 BF16 Maze eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 14,698
- Final bytes
- 14,698
- Wall time
- 1,678.5 s
- Playability asserts
- 7/7
- Playable
- yes
- Chars
- 14,698
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- AgentWorld-35B-A3B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 32-agent fleet sample
- Speed
- benchmarked Pareto knee
- Version
- v3
- Build ID
- maze_agentworld_02
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_b70_crewai_n12
- Model
- AgentWorld-35B-A3B
- Hardware
- Intel Arc Pro B70
- Runtime
- llama.cpp SYCL, Q5_K_M qwen35moe
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- CrewAI N=12
- Variant
- CrewAI N=12
- Chars
- 24,923
- Playability asserts
- 7/7
- Playable
- yes
- Features
- 1
- Build wall
- 416 s
- Tokens
- 48,036
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_gpt_5_6_sol
- Model
- GPT-5.6 Sol
- Creator
- OpenAI
- Hardware
- OpenAI API via Codex Desktop
- Runtime
- Codex Desktop, gpt-5.6-sol, isolated one-shot generation
- Quant/config
- frontier API
- Technique
- independent one-shot model output
- Speed
- not recorded
- Variant
- GPT-5.6 Sol maze-shooter one-shot
- Source
- /home/frosty40/robot-filled-maze-shooter/index.html
- Source bytes
- 41,620
- SHA-256
- 680897bc5ad4cc796fc8896e3c893513e78e24637755ff8a74d194d0e4d55226
- Validator
- teamwork/validate_game.js ok
- Provenance session
- 019f4c5e-66f6-7c40-97b5-4ba3befd183b
- Output relation
- Independent GPT-5.6 Sol output; not derived from the Terra artifact
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_gpt_5_6_terra
- Model
- GPT-5.6 Terra
- Creator
- OpenAI
- Hardware
- OpenAI API via Codex Desktop
- Runtime
- Codex Desktop, gpt-5.6-terra, isolated one-shot generation
- Quant/config
- frontier API
- Technique
- independent one-shot model output
- Speed
- not recorded
- Variant
- GPT-5.6 Terra maze-shooter one-shot
- Source
- /home/frosty40/agentic-arena/robot-filled-maze-shooter/index.html
- Source bytes
- 32,655
- SHA-256
- 12857b1b79f14faea469cde2fe1b060bb376cb41d6c221f48baf020c2c694d48
- Validator
- teamwork/validate_game.js ok
- Provenance session
- 019f4a96-c8c5-7641-b314-db81307dfa1e
- Output relation
- Independent GPT-5.6 Terra output; not derived from the Sol artifact
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- MoA:AngelX
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- AngelX MOA improve loop
- Quant/config
- multi-model orchestration
- Technique
- 9-agent MOA improve loop
- Speed
- PR artifact; no throughput sweep recorded
- Version
- v1
- Build ID
- maze_moa-angelx_00
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Model
- MoA:AngelX
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- AngelX MOA improve loop
- Quant/config
- multi-model orchestration
- Technique
- 9-agent MOA improve loop
- Speed
- PR artifact; no throughput sweep recorded
- Version
- v2
- Build ID
- maze_moa-angelx_01
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_nemotron3_super_teamwork
- Model
- NVIDIA Nemotron-3-Super-120B-A12B-NVFP4
- Creator
- NVIDIA
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- Official NVFP4 safetensors, vLLM 0.23.0, max_model_len=8192, max_num_seqs=1, kv_cache_memory_bytes=4G, enforce_eager
- Quant/config
- NVFP4 safetensors
- Technique
- 1-agent 20-minute teamwork harness; improvement candidates rejected under 8k-context condition
- Speed
- 13.9 tok/s single-agent decode scout
- Variant
- Nemotron 3 Super Spark eval
- Team
- 1
- Merge top
- 1
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 239
- Seed bytes
- 11632
- Final bytes
- 11632
- Wall time
- 1,202.8 s
- Playability asserts
- 7/7
- Playable
- yes
- Build wall
- 1,202.8 s
- Chars
- 11,632
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_ornith_teamwork
- Model
- Frosty Ornith-1.0-35B
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- official GGUF-NVFP4, llama.cpp
- Quant/config
- GGUF-NVFP4 (qwen35moe)
- Technique
- 6-agent teamwork production loop
- Speed
- 58 t/s
- Variant
- teamwork eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 19385
- Final bytes
- 26061
- Wall time
- 1,486.2 s
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_qwen36_35b_nvfp4_teamwork
- Model
- nvidia/Qwen3.6-35B-A3B-NVFP4
- Creator
- NVIDIA
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- NVFP4 quantized safetensors, vLLM 0.23.0, FlashInfer CUTLASS MoE, reasoning-parser qwen3
- Quant/config
- NVFP4 (W4A16) + FP8 attn
- Technique
- 6-agent teamwork production loop, max_tokens=32768, merge_top=3
- Speed
- 660.3 tok/s @ 32-agent throughput sweep; game build used team 6
- Variant
- Qwen3.6-35B NVFP4 Maze eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 3
- Seed bytes
- 17,654
- Final bytes
- 33,956
- Wall time
- 1,511 s
- Playability asserts
- 7/7
- Playable
- yes
- Chars
- 33,956
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.build data / card back
- Build ID
- maze_qwen3_coder_30b_bf16_teamwork
- Model
- Qwen3-Coder-30B-A3B-Instruct BF16
- Creator
- Qwen
- Hardware
- DGX Spark / NVIDIA GB10
- Runtime
- Official BF16 safetensors, vLLM 0.23.0, max_model_len=131072, max_num_seqs=4, no REAP/no DFlash/no drafter/no quantized derivative
- Quant/config
- BF16 safetensors
- Technique
- 6-agent teamwork production loop, max_tokens=90000, merge_top=3
- Speed
- 344.2 tok/s @ 32-agent 32k throughput sweep; game build used team 6 long-context queue
- Variant
- Qwen3 Coder BF16 long-context teamwork eval
- Team
- 6
- Merge top
- 3
- Minutes
- 20.0
- Score
- 71.0
- Assertions
- 7/7
- Rounds
- 2
- Seed bytes
- 16673
- Final bytes
- 31459
- Wall time
- 2,235.6 s
- Playability asserts
- 7/7
- Playable
- yes
- Build wall
- 2,235.6 s
- Chars
- 31,459
back of cartridge · evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.Build inventory
| # | Model | GPU/card | Technique | Variant |
|---|---|---|---|---|
| 1 | AEON QWEN | DGX Spark / NVIDIA GB10 | 8-agent fleet sample | v1 |
| 2 | AEON QWEN | DGX Spark / NVIDIA GB10 | 8-agent fleet sample | v2 |
| 3 | AEON QWEN | DGX Spark / NVIDIA GB10 | 8-agent fleet sample | v3 |
| 4 | AEON QWEN | DGX Spark / NVIDIA GB10 | 7-agent teamwork production loop | teamwork eval |
| 5 | Agents-A1 | DGX Spark / NVIDIA GB10 | 6-agent teamwork production loop, max_tokens=32768, merge_top=3 | Agents-A1 BF16 Maze eval |
| 6 | AgentWorld-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v1 |
| 7 | AgentWorld-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v2 |
| 8 | AgentWorld-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v3 |
| 9 | AgentWorld-35B | Intel Arc Pro B70 | 6-agent live B70 teamwork production loop | B70 live teamwork eval |
| 10 | AgentWorld-35B | Intel Arc Pro B70 | 6-agent B70 quant comparison teamwork loop | B70 Q5_K_M quant eval |
| 11 | AgentWorld-35B | Intel Arc Pro B70 | 6-agent B70 quant comparison teamwork loop | B70 Q6_K quant eval run 1 |
| 12 | AgentWorld-35B | Intel Arc Pro B70 | 6-agent B70 quant comparison teamwork loop | B70 Q6_K quant eval run 2 |
| 13 | AgentWorld-35B | Intel Arc Pro B70 | 6-agent B70 stock baseline teamwork production loop | B70 stock baseline |
| 14 | AgentWorld-35B | DGX Spark / NVIDIA GB10 | 6-agent teamwork production loop | teamwork eval |
| 15 | AgentWorld-35B | Intel Arc Pro B70 | CrewAI N=12 | CrewAI N=12 |
| 16 | AgentWorld-35B | Intel Arc Pro B70 | Solo | Solo |
| 17 | Claude Opus 4.8 | Anthropic API | single-shot frontier control build | MAZERUNNER control (gold-standard baseline) |
| 18 | Claude Opus 4.8 | Anthropic API | frontier control, one agent per game | MAZERUNNER B70 control |
| 19 | DeepSeek V4 Pro | DeepSeek API | single agent build with thinking | Maze deepseek eval |
| 20 | Fable | external submission | submitted artifact | Fable Maze Shooter |
| 21 | Gemma-4 current | DGX Spark / NVIDIA GB10 | 5-agent teamwork production loop, merge_top=2 | current plain vLLM eval |
| 22 | Gemma-4-26B | DGX Spark / NVIDIA GB10 | 32-agent teamwork production loop | teamwork eval |
| 23 | GLM-5.2 | DGX Spark / NVIDIA GB10 | 1-agent fleet sample | v1 |
| 24 | GLM-5.2 | API | single agent build with thinking | GLM-5.2 OpenCode eval |
| 25 | GPT-5.5 xhigh | OpenAI API | single xhigh subagent build | Maze xhigh eval |
| 26 | GPT-5.6 Sol | OpenAI API via Codex Desktop | independent one-shot model output | GPT-5.6 Sol maze-shooter one-shot |
| 27 | GPT-5.6 Terra | OpenAI API via Codex Desktop | independent one-shot model output | GPT-5.6 Terra maze-shooter one-shot |
| 28 | Laguna XS 2.1 | DGX Spark / NVIDIA GB10 | 1-agent fleet sample | v2 |
| 29 | Laguna XS 2.1 | Intel Arc Pro B70 | 6-agent B70 teamwork production loop, merge_top=2 | Laguna XS 2.1 Q4_K_M B70 live teamwork eval |
| 30 | Leanstral NVFP4 | DGX Spark / NVIDIA GB10 | single local model run with validator-guided repair loop | Leanstral NVFP4 Robot Maze eval |
| 31 | LongCat-2.0 | Meituan hosted API | 3-call hosted SOTA chain: draft -> repair -> integrate | LongCat chain3 Maze |
| 32 | LongCat-2.0 | Meituan hosted API | one-shot hosted SOTA API generation | LongCat one-shot Maze |
| 33 | MoA:AngelX | DGX Spark / NVIDIA GB10 | 9-agent MOA improve loop | v1 |
| 34 | MoA:AngelX | DGX Spark / NVIDIA GB10 | 9-agent MOA improve loop | v2 |
| 35 | MOA:LONGCAT | DGX Spark / NVIDIA GB10 | 6-agent MOA improve loop | v1 |
| 36 | Nemotron 3 Super | DGX Spark / NVIDIA GB10 | 1-agent 20-minute teamwork harness; improvement candidates rejected under 8k-context condition | Nemotron 3 Super Spark eval |
| 37 | Nemotron Puzzle 75B | DGX Spark / NVIDIA GB10 | 1-agent 20-minute teamwork harness; valid seed preserved, improvement candidates rejected under validator | Nemotron Puzzle 75B Spark eval |
| 38 | NEX2 | Intel Arc Pro B70 | 6-agent live B70 teamwork production loop | B70 live teamwork eval |
| 39 | NEX2 | Turbo via Hydra | one-hour Hydra loop handoff | Hydra Salvage Run |
| 40 | NEX2 | DGX Spark / NVIDIA GB10 | 3-agent teamwork production loop | teamwork eval |
| 41 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v1 |
| 42 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v2 |
| 43 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v3 |
| 44 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v4 |
| 45 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v5 |
| 46 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 32-agent fleet sample | v6 |
| 47 | Ornith-AEON | DGX Spark / NVIDIA GB10 | 16-agent AEON teamwork production loop over Ornith/Qwen builds | AEON Ornith/Qwen eval |
| 48 | Frosty Ornith-35B | Intel Arc Pro B70 | failed live B70 teamwork attempt | B70 failed attempt |
| 49 | Frosty Ornith-35B | Intel Arc Pro B70 | 6-agent live B70 teamwork production loop | B70 live teamwork eval |
| 50 | Frosty Ornith-35B | Intel Arc Pro B70 | 6-agent B70 stock baseline teamwork production loop | B70 stock baseline |
| 51 | Frosty Ornith-35B | DGX Spark / NVIDIA GB10 | 6-agent teamwork production loop | teamwork eval |
| 52 | Quest Turbo | Intel Arc Pro B70 | 6-agent live B70 teamwork production loop, safe 131k context | B70 live teamwork eval |
| 53 | Qwen3.6-35B NVFP4 | DGX Spark / NVIDIA GB10 | 6-agent teamwork production loop, max_tokens=32768, merge_top=3 | Qwen3.6-35B NVFP4 Maze eval |
| 54 | Qwen3.6-35B Q5 Turbo | Intel Arc Pro B70 | 12-agent live B70 teamwork production loop | v1 |
| 55 | Qwen3 Coder 30B | DGX Spark / NVIDIA GB10 | 6-agent teamwork production loop, max_tokens=90000, merge_top=3 | Qwen3 Coder BF16 long-context teamwork eval |
| 56 | SIQ-1-35B | Intel Arc Pro B70 | 6-agent live B70 teamwork production loop | B70 live teamwork eval |
| 57 | SIQ-1-35B | DGX Spark / NVIDIA GB10 | 7-agent teamwork production loop | GB10 teamwork eval |
| 58 | StepFun Step-3.7 | DGX Spark / NVIDIA GB10 | 3-agent teamwork production loop | Step37 teamwork eval |
Evaluation prompt
You are an expert front-end game engineer specializing in original, playable HTML5
arcade-style browser games. Produce a SINGLE FILE (index.html)
implementation of a Robot-Filled Maze Shooter the user can paste into a browser tab
and play immediately.
GAME SPEC:
- Title: Robot-Filled Maze Shooter (original homage, no IP)
- Core mechanic: top-down maze; shoot robots without touching walls.
- Goal / win condition: exit through doorway to next room.
TECH REQUIREMENTS:
- Single file: <!doctype html> + inline <style> + inline <script>.
- HTML5 <canvas> 2D with a requestAnimationFrame game loop.
- No external dependencies (no CDN, npm, images, audio files). Sprites generated in code;
SFX synthesized via Web Audio API.
- Keyboard controls (arrows/WASD, Space primary, Shift/Z/X secondary), controls overlay
on the first frame; pixel-perfect playfield with image-rendering: pixelated.
GAMEPLAY:
- Lives + score + level/wave HUD strip; start screen ("PRESS SPACE TO START"); game-over
screen with restart. Faithful loop: input -> physics -> enemy AI -> collision -> render -> HUD.
Return ONE complete document with <canvas id="game">, inline <style>, and one <script> block.
No prose around the code.Detailed benchmark tables remain on Benchmarks. B70 cross-model tables and figures are at Benchmarks #B70.
