README.md

---
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 <games-dir> --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)