--- license: other tags: - evaluation - agentic-sft --- # EvoGame evaluation results Scores and generated games for the three-stage agentic-SFT ablation on Qwen3.8-27B. ## Contents - `scores/` — 15 JSON files: 5 arms × 3 judged passes - `games_s2new.tar.gz`, `games_s3new.tar.gz` — the generated game trees for the reweighted stage-2 and stage-3 arms, including `dist/` builds ## Round 2 (v2): 2 web + 2 Godot held-out briefs Four briefs, none of which appear in any training set: - **web** — `platformer-friction-D2-002`, `topdown-collect-D1-001` - **Godot** — `metroidvania-aurora-archive`, `rhythm-bakery-ballet` Generation runs on a single H100 with the arm's adapter merged into the base weights and served by vLLM; the same model answers both the agent turns and the design reasoning. Web games are built by the OpenGame harness, Godot games by qwen-code, both from a fixed asset library. Scoring is in two halves: - **web** — BUILD gate (a headless browser must load `dist/index.html`), then a vision judge scores auto-derived requirements over **3 passes**; the reported number is the mean of the valid passes. - **Godot** — the gamecraft-bench verifier: a build gate, then each task's demo traces are replayed under Xvfb and the recording is scored against a fixed rubric (BUILD × weighted mechanics / depth / visuals / art). Judge: `openai/gpt-5.5` via OpenRouter for both. ### The scoring environment decides the scores Six environment faults each produced a confident-looking **0.0** rather than an error, and all are fixed in the harness used for these results: the OpenAI SDK's default HTTP client cannot reach OpenRouter from this box (TLS alert) and needs a plain `httpx.Client`; the Godot build gate hard-codes `/workspace/game` and needs a private mount namespace; software GL needs a longer settle and a writable Mesa shader cache or frames show only the splash; the default X display range is occupied; the web scorer's ffmpeg timeouts are too short for long replays; and a 2048-token judge cap truncates the response. **A seventh fault invalidated a whole round of scoring.** The dev box container is capped at **8 CPUs** (`cpu.cfs_quota_us` = 800000 / period 100000) while `nproc` reports 256, and that quota is shared with another tenant: measured 95% of CFS periods throttled, and a single-threaded loop getting 6% CPU per wall second. Under that starvation Godot renders at **~1 real fps**, so a 14 s demo covers 1-2 s of game time. An autoload input probe confirmed the inputs *did* arrive and the game *did* switch out of its title state — the recording simply ended before the screen was redrawn, which scores a working game near zero and penalises exactly those games that open on a title screen. Browser replays are starved the same way. Round-2 scores are therefore produced with the replay/capture half moved to a pod with **dedicated CPUs** (no API key present) and only the judging half run locally, where CPU starvation cannot affect the result. The effect is large and one-sided: S2's metroidvania went 0.114 → 0.439 and S1 baseline's Godot mean 0.343 → 0.510 on identical games, judge and rubric. Pass-to-pass spread on the web side fell from ~0.14 to ~0.03, which is the real tell that the earlier numbers were capture noise rather than judge noise. ### Round 2 results | arm | platformer (web) | topdown (web) | metroidvania (Godot) | rhythm (Godot) | mean | |---|---|---|---|---|---| | S1 split | 0.407 | 0.422 | 0.524 | **0.589** | **0.486** | | S1 baseline | 0.406 | **0.475** | 0.511 | 0.509 | 0.475 | | S2 gen+plan | 0.030 | **0.528** | 0.439 | 0.396 | 0.348 | | S3 gen+plan+repair | 0.000 | 0.356 | 0.404 | 0.541 | 0.325 | Web cells are the mean of three judged passes; Godot cells are one rubric pass. Every build that booted was scored with no judge errors. **The two S1 arms are tied** — 0.486 vs 0.475 over four games is inside this benchmark's noise, and their platformer scores match to three decimals. **Neither stage 2 nor stage 3 improves on stage 1 here**, which is what round 1 also found. Both later stages are dragged down by a single dead game rather than uniform weakness: S2's platformer renders an empty canvas after its level scene starts (0.030) while its top-down game is the best web result in the table (0.528); S3's platformer fails the build gate outright with `this.gateZone.body.setAllowGravity is not a function` (0.000). With two briefs per engine, one dead game moves an arm's mean by about 0.1, so these orderings should not be read as settled. Two things make S3 additionally hard to compare: its repair rows were distilled from a different teacher (`z-ai/glm-5.3-flash`), and it is far more expensive per game — 9,151 s and 5,383 s of web generation against S1 split's 1,682 s and 2,193 s, with its Godot metroidvania cut off by the 2-hour agent cap (`rc=55`), the only game in the round to hit a budget limit. Judge variance is small by comparison: the same rhythm capture judged twice scored 0.530 and 0.541. ### Godot demo length is part of what is being measured Each arm writes its own demo traces, and they differ a lot in length — per demo, S1 split runs 14-20 s, S2 5-14 s, S1 baseline 2.3-10 s (totals across all demos: 107 s / 90 s, 78 s / 48 s, 32 s / 43 s for metroidvania / rhythm). The rubric caps a demo at 20 s, so nothing was truncated; the models simply authored shorter playthroughs. Frames are sampled at a fixed cadence, so a short demo shows the judge proportionally less gameplay, and evidence-heavy requirements score low when a mechanic is never exercised on camera. A Godot score therefore reflects both the game and how thoroughly that arm demonstrates it. ## Round 1 protocol Three briefs with **zero overlap** with any training set: `platformer-thunder-valkyrie`, `puzzle-circuit-wizard`, `roguelike-breach-tactics`. Every arm generated through the same agent harness at identical settings — smoke disabled (its built-in loop is a *repair* loop and would turn a generation comparison into a repair one), 16k output cap, 6 continuation nudges, 1-hour request timeout — served by vLLM on a single H100 with the adapter merged into the base weights. Scoring is two-stage: 1. **BUILD gate.** A headless browser must load `dist/index.html`. This is what most of the signal turns out to be. 2. **Rubric.** A vision model scores auto-derived requirements across Core Mechanics, Content Depth, Functional Visuals, Presentation & Art, over three passes. ## Two exclusions that matter - **A failed judge call is retried three times, then dropped — never averaged as zero.** Scoring one as 0.0 once moved an arm from 0.337 to 0.211, larger than any effect being measured. Judge errors ran 3 of 33 rows here. - **A game with no `dist/` at all is excluded**, because that means the generation run was stopped by hand — a property of the run, not the model. A `dist/` that exists and fails to boot is the opposite case and is scored **0.0**, which is exactly what the BUILD gate is for. ## Results | model | platformer | puzzle | roguelike | mean* | games that run | |---|---|---|---|---|---| | untuned base | 0.193 | 0.000 | — | 0.077 | 1/2 | | stage-3 v1 | 0.284 | 0.301 | 0.310 | **0.293** | **3/3** | | stage-2 reweighted | 0.000 | 0.334 | — | 0.167 | 1/2 | | stage-3 reweighted, run 1 | 0.000 | 0.000 | — | 0.000 | 0/2 | | stage-3 reweighted, run 2 | 0.597 | 0.000 | — | 0.149 | 1/2 | \* mean over platformer + puzzle, the two briefs every arm completed. Roguelike exists only for stage-3 v1, so it is excluded from every mean. ## The finding that matters **The last two rows are the same adapter, evaluated twice.** Same briefs, same settings, same merged weights. They differ by 0.149 — larger than the gap between any two *different* models in the table. At two comparable briefs this evaluation is noisier than the effect it was built to measure, so the ordering is **unresolved**. An earlier version of this analysis concluded the reweighted stage-3 was clearly worse; that conclusion was withdrawn when the second run landed. ## The recurring bug Most zeros share one cause: the game builds, the browser loads it, and Phaser refuses a second scene registration. ``` Cannot add Scene with duplicate key: CircuitScene ``` The reweighted adapters tend to write: ```ts for (let i = 1; i <= 10; i++) game.scene.add(`CircuitLevel${i}`, CircuitScene); // while CircuitScene.ts does: constructor() { super({ key: 'CircuitScene' }); } ``` Phaser takes the key from the class, not the `add()` call, so every iteration after the first collides. Stage-3 v1, given the identical brief, writes one class per level and boots. Frequency: 3 of 5 games from reweighted adapters; 0 from v1 or base. But the reweighted stage-3's second run wrote the *correct* pattern for its platformer and that game booted on all three passes — so this is a frequent habit, not a deterministic defect. ## Reproducing a score ```bash python run_quality_eval.py --batch --out scores.json --base-port 6100 ``` Requires `QUALITY_JUDGE_BASE_URL`, `QUALITY_JUDGE_API_KEY`, `QUALITY_JUDGE_MODEL`, and a Playwright chromium. `QUALITY_JUDGE_ATTEMPTS=3` enables the retry-then-drop behaviour described above. --- **Pipeline code, reports and scores:** [WenyiWU0111/OpenGame-reproduce · `evogame-sft-pipeline/`](https://github.com/WenyiWU0111/OpenGame-reproduce/tree/d3-mechanic-runtime/evogame-sft-pipeline) · [`evogame-data-pipeline/`](https://github.com/WenyiWU0111/OpenGame-reproduce/tree/d3-mechanic-runtime/evogame-data-pipeline) **Companion repos:** [adapters](https://huggingface.co/dCoder30/evogame-qwen38-adapters) · [training data](https://huggingface.co/datasets/dCoder30/evogame-sft-data) · [eval results](https://huggingface.co/datasets/dCoder30/evogame-eval)