Road Hopper · Agentic Arcade

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:froggai_claude_opusClaude Opus 4.8creator:AnthropicAnthropic APIsingle-shot frontier control build

fullscreen

build data / card back

Build ID: froggai_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: FroggAI control (gold-standard baseline)
Team: 1
Merge top: 1
Minutes: 5.0
Score: 7.0
Assertions: 7/7
Rounds: 1
Seed bytes: 25729
Final bytes: 25729
Wall time: 300.0 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:froggai_deepseek_v4_proDeepSeek V4 Procreator:DeepSeekDeepSeek APIsingle agent build with thinking

fullscreen

build data / card back

Build ID: froggai_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: 120 s build wall
Variant: FroggAI deepseek eval
Team: 1
Merge top: 1
Minutes: 2.0
Score: 7.0
Assertions: 7/7
Rounds: 1
Seed bytes: 17900
Final bytes: 17900
Wall time: 120.0 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:froggai_gpt_5_5_xhighGPT-5.5 xhighcreator:OpenAIOpenAI APIsingle xhigh subagent build

fullscreen

build data / card back

Build ID: froggai_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: 210 s build wall
Variant: FroggAI xhigh eval
Team: 1
Merge top: 1
Minutes: 3.5
Score: 7.0
Assertions: 7/7
Rounds: 1
Seed bytes: 22295
Final bytes: 22295
Wall time: 210.0 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_aeon_teamworkAEON QWENDGX Spark / NVIDIA GB107-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 3
Seed bytes: 14618
Final bytes: 30282
Wall time: 1,753.4 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_teamworkAgentWorld-35BDGX Spark / NVIDIA GB106-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 19058
Final bytes: 19263
Wall time: 1,607.5 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_b70_crewai_n12AgentWorld-35BIntel Arc Pro B70CrewAI N=12

fullscreen

build data / card back

Build ID: road_hopper_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: 23,809
Playability asserts: 7/7
Playable: yes
Features: 2
Build wall: 396 s
Tokens: 47,065

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_b70_soloAgentWorld-35BIntel Arc Pro B70Solo

fullscreen

build data / card back

Build ID: road_hopper_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: 17,970
Playability asserts: 7/7
Playable: yes
Features: 1
Build wall: 87 s
Tokens: 6,470

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_nex2_teamworkNEX2DGX Spark / NVIDIA GB103-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 3
Seed bytes: 19420
Final bytes: 27910
Wall time: 1,863.3 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_ornith_aeon_teamworkOrnith-AEONcreator:AEON-7DGX Spark / NVIDIA GB1016-agent AEON teamwork production loop over Ornith/Qwen builds

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 4
Seed bytes: 13189
Final bytes: 32004
Wall time: 1,594.3 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 game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_ornith_teamworkFrosty Ornith-35BDGX Spark / NVIDIA GB106-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 3
Seed bytes: 15443
Final bytes: 19869
Wall time: 1,784.4 s

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_aeon_00AEON QWENDGX Spark / NVIDIA GB108-agent fleet sample

fullscreen

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: road-hopper_aeon_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_agentworld_00AgentWorld-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_agentworld_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_agentworld_01AgentWorld-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_agentworld_01

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_agentworld_02AgentWorld-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_agentworld_02

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_glm-5-2_00GLM-5.2DGX Spark / NVIDIA GB101-agent fleet sample

fullscreen

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: road-hopper_glm-5-2_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_moa-angelx_00MoA:AngelXDGX Spark / NVIDIA GB109-agent MOA improve loop

fullscreen

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: road-hopper_moa-angelx_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_moa-angelx_01MoA:AngelXDGX Spark / NVIDIA GB109-agent MOA improve loop

fullscreen

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: road-hopper_moa-angelx_01

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_moa-angelx_02MoA:AngelXDGX Spark / NVIDIA GB109-agent MOA improve loop

fullscreen

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: v3
Build ID: road-hopper_moa-angelx_02

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_ornith_00Frosty Ornith-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_ornith_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_ornith_03Frosty Ornith-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_ornith_03

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_qwen36_35b_q5_turbo_00Qwen3.6-35B Q5 TurboIntel Arc Pro B7012-agent live B70 teamwork production loop

fullscreen

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: road-hopper_qwen36_35b_q5_turbo_00

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agents_a1_teamworkAgents-A1creator:InternScienceDGX Spark / NVIDIA GB106-agent teamwork production loop, max_tokens=32768, merge_top=3

fullscreen

build data / card back

Build ID: road_hopper_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 Road Hopper eval
Team: 6
Merge top: 3
Minutes: 20.0
Score: 61.0
Assertions: 6/6
Rounds: 2
Seed bytes: 14,065
Final bytes: 17,553
Wall time: 1,436.5 s
Playability asserts: 6/6
Playable: yes
Chars: 17,553

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_b70_liveAgentWorld-35Bcreator:Qwen / AgentWorldIntel Arc Pro B706-agent live B70 teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 29587
Final bytes: 40439
Wall time: 1,262.7 s
Report: benchmarks/B70/AGENTWORLD_LIVE_EVALS.md
Quality /50: 31
Playability asserts: 6/6
Playable: source-review fail: unwinnable
Validator: teamwork/validate_game.js ok
Build wall: 1,262.7 s
Chars: 40,439

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_b70_q5AgentWorld-35Bcreator:Qwen / AgentWorldIntel Arc Pro B706-agent B70 quant comparison teamwork loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 21260
Final bytes: 19345
Wall time: 908.4 s
Report: benchmarks/B70/QUANT_GAMES_B70.md
Quality /50: 34
Playability asserts: 6/6
Playable: yes
Validator: teamwork/validate_game.js ok
Build wall: 908.4 s
Chars: 19,345

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_b70_q6AgentWorld-35Bcreator:Qwen / AgentWorldIntel Arc Pro B706-agent B70 quant comparison teamwork loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 14497
Final bytes: 15227
Wall time: 971.3 s
Report: benchmarks/B70/QUANT_GAMES_B70.md
Quality /50: 34
Playability asserts: 6/6
Playable: yes
Validator: teamwork/validate_game.js ok
Build wall: 971.3 s
Chars: 15,227

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_b70_q6bAgentWorld-35Bcreator:Qwen / AgentWorldIntel Arc Pro B706-agent B70 quant comparison teamwork loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 2
Seed bytes: 21386
Final bytes: 27993
Wall time: 1,598.6 s
Report: benchmarks/B70/QUANT_GAMES_B70.md
Quality /50: 35
Playability asserts: 6/6
Playable: yes
Validator: teamwork/validate_game.js ok
Build wall: 1,598.6 s
Chars: 27,993

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_agentworld_b70_stockAgentWorld-35Bcreator:AgentWorldIntel Arc Pro B706-agent B70 stock baseline teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 2
Seed bytes: 21226
Final bytes: 27520
Wall time: 1,834.2 s
Report: benchmarks/B70/TURBO_VS_STOCK_B70.md
Stock rounds: 2
Stock wall: 1,742 s
Playability asserts: 6/6
Validator: teamwork/validate_game.js ok
Chars: 27,520

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_claude_opus_b70_controlClaude Opus 4.8creator:AnthropicAnthropic APIfrontier control, one agent per game

fullscreen

build data / card back

Build ID: road_hopper_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: FROGGAI B70 control
Report: benchmarks/B70/OPUS_CONTROL_B70.md
Code quality: 47/50
Runtime validator: teamwork/validate_game.js ok
Chars: 25,729

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_fableFablecreator:Fableexternal submissionsubmitted artifact

fullscreen

build data / card back

Build ID: road_hopper_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 Road Hopper
Source: /home/frosty40/fablegames/frogai/frogger.html
Source bytes: 19,840
Validator: teamwork/validate_game.js ok

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_gemma4_nvfp4_current_teamworkGemma-4 currentcreator:NVIDIA / GemmaDGX Spark / NVIDIA GB105-agent teamwork production loop, merge_top=2

fullscreen

build data / card back

Build ID: road_hopper_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/6
Rounds: 4
Seed bytes: 8479
Final bytes: 15000
Wall time: 1,604.1 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

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_glm_5_2_opencodeGLM-5.2creator:Zhipu AIAPIsingle agent build with thinking

fullscreen

build data / card back

Build ID: road_hopper_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: 25,998

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_gpt_5_6_solGPT-5.6 Solcreator:OpenAIOpenAI API via Codex Desktopindependent one-shot model output

fullscreen

build data / card back

Build ID: road_hopper_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 road-and-river one-shot
Source: /home/frosty40/road-river-crossing/index.html
Source bytes: 37,440
SHA-256: 2bfe0e399730a48948f2697eb2ad2e8c574542a74a1abfb8c43e62da49bda2e5
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 game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_gpt_5_6_terraGPT-5.6 Terracreator:OpenAIOpenAI API via Codex Desktopindependent one-shot model output

fullscreen

build data / card back

Build ID: road_hopper_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 road-and-river one-shot
Source: /home/frosty40/agentic-arena/road-river-crossing/index.html
Source bytes: 23,532
SHA-256: 13950aa402de4f04bc44d1424b7be6bbbfca6fc333e00125cc64e2443f1e1818
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 game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_laguna_xs21_q4_b70Laguna XS 2.1creator:Poolside / LagunaIntel Arc Pro B706-agent B70 teamwork production loop, merge_top=2

fullscreen

build data / card back

Build ID: road_hopper_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, 1362.1 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/6
Rounds: 2
Seed bytes: 11293
Final bytes: 14196
Wall time: 1,362.1 s
Report: benchmarks/B70/LAGUNA_XS21_LIVE_EVALS.md
Runtime validator: teamwork/validate_game.js ok
Chars: 14,196

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_leanstral_119b_nvfp4Leanstral NVFP4creator:Mistral AI base / Frosty40 GGUF-NVFP4 conversionDGX Spark / NVIDIA GB10single local model run with validator-guided repair loop

fullscreen

build data / card back

Build ID: road_hopper_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: 3.81 min build wall; repo-validator accepted round observed 45.20 tok/s decode
Variant: Leanstral NVFP4 Road Hopper eval
Team: 1
Merge top: 1
Minutes: 3.81
Score: 10.0
Assertions: 8/11
Rounds: 4
Seed bytes: 7091
Final bytes: 6821
Wall time: 228.5 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: 228.5 s
Chars: 6,821
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 game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_chain3LongCat-2.0creator:MeituanMeituan hosted API3-call hosted SOTA chain: draft -> repair -> integrate

fullscreen

build data / card back

Build ID: road_hopper_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: 326.4 s wall
Variant: LongCat chain3 Road Hopper
Condition: src/teamwork/longcat_2/condition.txt
Raw responses: src/teamwork/longcat_2/raw/frogger_chain3_stage1.json, stage2.json, stage3.json
Published stage: stage2; stage3 hit length cap
Static checks: canvas/script/RAF/keyboard/closed HTML
Runtime validator: not run: jsdom missing
Chars: 21,905

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_frog_crossLongCat-2.0creator:MeituanMeituan hosted APIhosted style-variant generation

fullscreen

build data / card back

Build ID: road_hopper_longcat_2_frog_cross
Model: Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
Creator: Meituan
Hardware: Meituan hosted API
Runtime: LongCat hosted run artifact from Ubuntu Atlas /home/frosty40/test
Quant/config: FP8 (Meituan)
Technique: hosted style-variant generation
Speed: not recorded
Variant: Classic pixel-art Frogger style
Source: Ubuntu Atlas /home/frosty40/test/frog_cross.html
Source bytes: 24,428
Runtime validator: teamwork/validate_game.js ok

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_frog_noirLongCat-2.0creator:MeituanMeituan hosted APIhosted style-variant generation

fullscreen

build data / card back

Build ID: road_hopper_longcat_2_frog_noir
Model: Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
Creator: Meituan
Hardware: Meituan hosted API
Runtime: LongCat hosted run artifact from Ubuntu Atlas /home/frosty40/test
Quant/config: FP8 (Meituan)
Technique: hosted style-variant generation
Speed: not recorded
Variant: Noir rain skyline lantern-glow
Source: Ubuntu Atlas /home/frosty40/test/frog_noir.html
Source bytes: 34,567
Runtime validator: teamwork/validate_game.js ok

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_frog_terminalLongCat-2.0creator:MeituanMeituan hosted APIhosted style-variant generation

fullscreen

build data / card back

Build ID: road_hopper_longcat_2_frog_terminal
Model: Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
Creator: Meituan
Hardware: Meituan hosted API
Runtime: LongCat hosted run artifact from Ubuntu Atlas /home/frosty40/test
Quant/config: FP8 (Meituan)
Technique: hosted style-variant generation
Speed: not recorded
Variant: Terminal ASCII green-on-black
Source: Ubuntu Atlas /home/frosty40/test/frog_terminal.html
Source bytes: 25,573
Runtime validator: teamwork/validate_game.js ok

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_neon_crossLongCat-2.0creator:MeituanMeituan hosted APIhosted style-variant generation

fullscreen

build data / card back

Build ID: road_hopper_longcat_2_neon_cross
Model: Meituan LongCat-2.0 (1.6T MoE, 1M ctx)
Creator: Meituan
Hardware: Meituan hosted API
Runtime: LongCat hosted run artifact from Ubuntu Atlas /home/frosty40/test
Quant/config: FP8 (Meituan)
Technique: hosted style-variant generation
Speed: not recorded
Variant: Synthwave neon
Source: Ubuntu Atlas /home/frosty40/test/neon_cross.html
Source bytes: 28,224
Runtime validator: teamwork/validate_game.js ok
Patch: X.sin typo changed to Math.sin

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_longcat_2_oneLongCat-2.0creator:MeituanMeituan hosted APIone-shot hosted SOTA API generation

fullscreen

build data / card back

Build ID: road_hopper_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: 99.3 s wall
Variant: LongCat one-shot Road Hopper
Condition: src/teamwork/longcat_2/condition.txt
Raw response: src/teamwork/longcat_2/raw/frogger_one_code.json
Finish reason: stop
Completion tokens: 6,625
Static checks: canvas/script/RAF/keyboard/closed HTML
Runtime validator: not run: jsdom missing
Chars: 19,252

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_nemotron3_super_teamworkNemotron 3 Supercreator:NVIDIADGX Spark / NVIDIA GB101-agent 20-minute teamwork harness; improvement candidates rejected under 8k-context condition

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 200
Seed bytes: 14593
Final bytes: 14593
Wall time: 1,200.7 s
Playability asserts: 6/6
Playable: yes
Build wall: 1,200.7 s
Chars: 14,593

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_nemotron_labs_3_puzzle_75b_a9b_nvfp4_teamworkNemotron Puzzle 75Bcreator:NVIDIADGX Spark / NVIDIA GB101-agent 20-minute teamwork harness; valid seed preserved, improvement candidates rejected under validator

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 379
Seed bytes: 14226
Final bytes: 14226
Wall time: 1,200.9 s
Playability asserts: 6/6
Playable: yes
Build wall: 1,200.9 s
Chars: 14,226
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; no validator-passing improvement accepted

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_nex2_b70_liveNEX2creator:nex-agi base / s-batman NVFP4 GGUF conversionIntel Arc Pro B706-agent live B70 teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 23132
Final bytes: 28146
Wall time: 1,316.8 s
Quality /50: 37
Playability asserts: 6/6
Playable: yes
Build wall: 1,316.8 s
Chars: 28,146

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_ornith_b70_liveFrosty Ornith-35Bcreator:Frosty40 / OrnithIntel Arc Pro B706-agent live B70 teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 2
Seed bytes: 19901
Final bytes: 29268
Wall time: 1,694.6 s
Quality /50: 33
Playability asserts: 6/6
Playable: source-review fail: unwinnable
Build wall: 1,694.6 s
Chars: 29,268

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_ornith_b70_stockFrosty Ornith-35Bcreator:Frosty40 / OrnithIntel Arc Pro B706-agent B70 stock baseline teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 2
Seed bytes: 16043
Final bytes: 17891
Wall time: 1,081.7 s
Report: benchmarks/B70/TURBO_VS_STOCK_B70.md
Stock rounds: 2
Stock wall: 1,015 s
Playability asserts: 6/6
Validator: teamwork/validate_game.js ok
Chars: 17,891

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_qwen36_35b_base_teamworkQwen3.6-35B Basecreator:QwenDGX Spark / NVIDIA GB106-agent teamwork production loop, max_tokens=8192, merge_top=1

fullscreen

build data / card back

Build ID: road_hopper_qwen36_35b_base_teamwork
Model: Qwen3.6-35B-A3B UD-Q6_K GGUF
Creator: Qwen
Hardware: DGX Spark / NVIDIA GB10
Runtime: Qwen3.6-35B-A3B UD-Q6_K GGUF, llama.cpp-qwen36, -np 6, -c 98304, q8 KV, FlashAttention
Quant/config: UD-Q6_K GGUF
Technique: 6-agent teamwork production loop, max_tokens=8192, merge_top=1
Speed: 244.6 tok/s @ 32-agent throughput sweep; game build used team 6
Variant: Qwen3.6 base GGUF Road Hopper scout
Condition: src/teamwork/qwen36-base/condition.txt
Chars: 14,066

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_qwen36_35b_nvfp4_teamworkQwen3.6-35B NVFP4creator:NVIDIADGX Spark / NVIDIA GB106-agent teamwork production loop, max_tokens=32768, merge_top=3

fullscreen

build data / card back

Build ID: road_hopper_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 Road Hopper eval
Team: 6
Merge top: 3
Minutes: 20.0
Score: 61.0
Assertions: 6/6
Rounds: 4
Seed bytes: 13,798
Final bytes: 22,116
Wall time: 1,265 s
Playability asserts: 6/6
Playable: yes
Chars: 22,116

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_qwen3_coder_30b_bf16_teamworkQwen3 Coder 30Bcreator:QwenDGX Spark / NVIDIA GB106-agent teamwork production loop, max_tokens=90000, merge_top=3

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 25510
Final bytes: 31115
Wall time: 1,326.8 s
Playability asserts: 6/6
Playable: yes
Build wall: 1,326.8 s
Chars: 31,115

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_siq_b70_liveSIQ-1-35Bcreator:SIQIntel Arc Pro B706-agent live B70 teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 40189
Final bytes: 40828
Wall time: 2,480.9 s
Quality /50: 42
Playability asserts: 6/6
Playable: yes
Build wall: 2,480.9 s
Chars: 40,828

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_siq_gb10_teamworkSIQ-1-35Bcreator:SIQDGX Spark / NVIDIA GB107-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 27989
Final bytes: 27866
Wall time: 1,242.2 s
Playability asserts: 6/6
Playable: yes
Build wall: 1,367.1 s
Chars: 29,542

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_step37_teamworkStepFun Step-3.7creator:StepFunDGX Spark / NVIDIA GB103-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 1
Seed bytes: 18073
Final bytes: 22332
Wall time: 3,284.3 s
Playability asserts: 6/6
Playable: yes
Build wall: 3,284.3 s
Chars: 22,332

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

Broken builds (6)

id:road_hopper_b70_crewai_n6AgentWorld-35BIntel Arc Pro B70CrewAI N=6

fullscreen

build data / card back

Build ID: road_hopper_b70_crewai_n6
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=6
Variant: CrewAI N=6
Chars: 13,684
Playability asserts: 7/7
Playable: yes
Features: 0
Build wall: 232 s
Tokens: 28,668
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road_hopper_gemma_teamworkGemma-4-26BDGX Spark / NVIDIA GB1032-agent teamwork production loop

fullscreen

build data / card back

Build ID: road_hopper_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: 61.0
Assertions: 6/6
Rounds: 4
Seed bytes: 9970
Final bytes: 20978
Wall time: 1,506.2 s
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_aeon_01AEON QWENDGX Spark / NVIDIA GB108-agent fleet sample

fullscreen

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: road-hopper_aeon_01
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_aeon_02AEON QWENDGX Spark / NVIDIA GB108-agent fleet sample

fullscreen

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: road-hopper_aeon_02
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_ornith_01Frosty Ornith-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_ornith_01
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

id:road-hopper_ornith_02Frosty Ornith-35BDGX Spark / NVIDIA GB1032-agent fleet sample

fullscreen

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: road-hopper_ornith_02
Result: BROKEN BUILD
Failure card: cyberdeath placeholder

back of cartridge · evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

Build inventory

#	Model	GPU/card	Technique	Variant
1	Claude Opus 4.8	Anthropic API	single-shot frontier control build	FroggAI control (gold-standard baseline)
2	DeepSeek V4 Pro	DeepSeek API	single agent build with thinking	FroggAI deepseek eval
3	GPT-5.5 xhigh	OpenAI API	single xhigh subagent build	FroggAI xhigh eval
4	AEON QWEN	DGX Spark / NVIDIA GB10	7-agent teamwork production loop	teamwork eval
5	AgentWorld-35B	DGX Spark / NVIDIA GB10	6-agent teamwork production loop	teamwork eval
6	AgentWorld-35B	Intel Arc Pro B70	CrewAI N=12	CrewAI N=12
7	AgentWorld-35B	Intel Arc Pro B70	Solo	Solo
8	NEX2	DGX Spark / NVIDIA GB10	3-agent teamwork production loop	teamwork eval
9	Ornith-AEON	DGX Spark / NVIDIA GB10	16-agent AEON teamwork production loop over Ornith/Qwen builds	AEON Ornith/Qwen eval
10	Frosty Ornith-35B	DGX Spark / NVIDIA GB10	6-agent teamwork production loop	teamwork eval
11	AEON QWEN	DGX Spark / NVIDIA GB10	8-agent fleet sample	v1
12	AgentWorld-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v1
13	AgentWorld-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v2
14	AgentWorld-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v3
15	GLM-5.2	DGX Spark / NVIDIA GB10	1-agent fleet sample	v1
16	MoA:AngelX	DGX Spark / NVIDIA GB10	9-agent MOA improve loop	v1
17	MoA:AngelX	DGX Spark / NVIDIA GB10	9-agent MOA improve loop	v2
18	MoA:AngelX	DGX Spark / NVIDIA GB10	9-agent MOA improve loop	v3
19	Frosty Ornith-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v1
20	Frosty Ornith-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v4
21	Qwen3.6-35B Q5 Turbo	Intel Arc Pro B70	12-agent live B70 teamwork production loop	v1
22	Agents-A1	DGX Spark / NVIDIA GB10	6-agent teamwork production loop, max_tokens=32768, merge_top=3	Agents-A1 BF16 Road Hopper eval
23	AgentWorld-35B	Intel Arc Pro B70	6-agent live B70 teamwork production loop	B70 live teamwork eval
24	AgentWorld-35B	Intel Arc Pro B70	6-agent B70 quant comparison teamwork loop	B70 Q5_K_M quant eval
25	AgentWorld-35B	Intel Arc Pro B70	6-agent B70 quant comparison teamwork loop	B70 Q6_K quant eval run 1
26	AgentWorld-35B	Intel Arc Pro B70	6-agent B70 quant comparison teamwork loop	B70 Q6_K quant eval run 2
27	AgentWorld-35B	Intel Arc Pro B70	6-agent B70 stock baseline teamwork production loop	B70 stock baseline
28	Claude Opus 4.8	Anthropic API	frontier control, one agent per game	FROGGAI B70 control
29	Fable	external submission	submitted artifact	Fable Road Hopper
30	Gemma-4 current	DGX Spark / NVIDIA GB10	5-agent teamwork production loop, merge_top=2	current plain vLLM eval
31	GLM-5.2	API	single agent build with thinking	GLM-5.2 OpenCode eval
32	GPT-5.6 Sol	OpenAI API via Codex Desktop	independent one-shot model output	GPT-5.6 Sol road-and-river one-shot
33	GPT-5.6 Terra	OpenAI API via Codex Desktop	independent one-shot model output	GPT-5.6 Terra road-and-river one-shot
34	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
35	Leanstral NVFP4	DGX Spark / NVIDIA GB10	single local model run with validator-guided repair loop	Leanstral NVFP4 Road Hopper eval
36	LongCat-2.0	Meituan hosted API	3-call hosted SOTA chain: draft -> repair -> integrate	LongCat chain3 Road Hopper
37	LongCat-2.0	Meituan hosted API	hosted style-variant generation	Classic pixel-art Frogger style
38	LongCat-2.0	Meituan hosted API	hosted style-variant generation	Noir rain skyline lantern-glow
39	LongCat-2.0	Meituan hosted API	hosted style-variant generation	Terminal ASCII green-on-black
40	LongCat-2.0	Meituan hosted API	hosted style-variant generation	Synthwave neon
41	LongCat-2.0	Meituan hosted API	one-shot hosted SOTA API generation	LongCat one-shot Road Hopper
42	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
43	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
44	NEX2	Intel Arc Pro B70	6-agent live B70 teamwork production loop	B70 live teamwork eval
45	Frosty Ornith-35B	Intel Arc Pro B70	6-agent live B70 teamwork production loop	B70 live teamwork eval
46	Frosty Ornith-35B	Intel Arc Pro B70	6-agent B70 stock baseline teamwork production loop	B70 stock baseline
47	Qwen3.6-35B Base	DGX Spark / NVIDIA GB10	6-agent teamwork production loop, max_tokens=8192, merge_top=1	Qwen3.6 base GGUF Road Hopper scout
48	Qwen3.6-35B NVFP4	DGX Spark / NVIDIA GB10	6-agent teamwork production loop, max_tokens=32768, merge_top=3	Qwen3.6-35B NVFP4 Road Hopper eval
49	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
50	SIQ-1-35B	Intel Arc Pro B70	6-agent live B70 teamwork production loop	B70 live teamwork eval
51	SIQ-1-35B	DGX Spark / NVIDIA GB10	7-agent teamwork production loop	GB10 teamwork eval
52	StepFun Step-3.7	DGX Spark / NVIDIA GB10	3-agent teamwork production loop	Step37 teamwork eval
53	AgentWorld-35B	Intel Arc Pro B70	CrewAI N=6	CrewAI N=6 · broken
54	Gemma-4-26B	DGX Spark / NVIDIA GB10	32-agent teamwork production loop	teamwork eval · broken
55	AEON QWEN	DGX Spark / NVIDIA GB10	8-agent fleet sample	v2 · broken
56	AEON QWEN	DGX Spark / NVIDIA GB10	8-agent fleet sample	v3 · broken
57	Frosty Ornith-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v2 · broken
58	Frosty Ornith-35B	DGX Spark / NVIDIA GB10	32-agent fleet sample	v3 · broken

Evaluation prompt

You are an expert game developer. Build a COMPLETE, fully playable browser game:
a road-and-river crossing action game, as a single self-contained HTML file using vanilla
JavaScript and the HTML5 Canvas API. No external libraries, no external assets, no network.

Required features:
1. Intro / start menu screen with the title, brief instructions, and a Start control.
2. Core road-crossing gameplay: a small amphibian the player moves with the arrow keys; a road section
   with moving vehicles to dodge (collision = lose a life) and a river section with logs/
   turtles the frog must ride (falling in the water = lose a life); reach the goal row to score.
3. Two distinct levels with increasing difficulty (faster / denser traffic on level 2);
   the game advances from level 1 to level 2 after the first is cleared.
4. Game states: lives and score HUD, a game-over screen, and a game-completion / victory
   screen shown after both levels are finished, with a way to restart.
5. A smooth game loop using requestAnimationFrame, keyboard controls, and collision detection.

Output the ENTIRE game as ONE html code block (HTML + CSS + JS inline) that runs by saving
it as a single .html file and opening it in a browser.

Detailed benchmark tables remain on Benchmarks. B70 cross-model tables and figures are at Benchmarks #B70.