# AgentWorld-35B-A3B — live fleet bench + teamwork games (B70 Turbo)

Model: **Qwen-AgentWorld-35B-A3B** (arch `qwen3_5_moe`, 35B / ~3B active), **Q5_K_M**, llama.cpp SYCL on a
single **Intel Arc Pro B70** (30.3 GiB), `llama-server`. Ship config `-ngl 99 -fa on -ctk/-ctv q8_0
-b 8192 -ub 4096`, `GGML_SYCL_DISABLE_DNN=1`, `--jinja`. GGUF
`/mnt/data2tb/agentworld/agentworld-35b-a3b-Q5_K_M.gguf`.

Run date **2026-06-30 (UTC)**. Served on **:8092** (bench `-np 32 -c 131072`; games `-np 6 -c 262144`).
Artifacts under `results/live_evals/agentworld/`. This is AgentWorld's **first dedicated live-evals run**
through the unified driver — prior cross-model numbers were cross-referenced ("benched earlier") from the
older shallow `agent_bench`; these are measured first-class here.

## 1. Live agent-fleet bench, `-np 32 -c 131072` (real concurrent requests)

Real OpenAI-API requests fired simultaneously through the live server (`concurrent_agents.py`).
Aggregate decode = sum(generated tokens) / batch wall-clock; per-agent = mean server-side decode t/s one
agent sees. Thinking ON (chat-template default); 256-token generations.

| class | prompt_n | agents | aggregate decode t/s | per-agent t/s | prefill t/s |
|---|---:|---:|---:|---:|---:|
| tool | 125 | 1  | 62.59  | 82.2  | 132.8 |
| tool | 125 | 8  | 141.49 | 19.64 | 93.9  |
| tool | 125 | 16 | 163.35 | 11.24 | 57.9  |
| **tool** | 125 | **32** | **223.95** | 7.85 | 32.9 |
| structured | 443 | 32 | 169.44 | 6.79 | 43.0 |
| novel | 775 | 32 | 138.35 | 5.80 | 55.3 |

**Headline:** at 32 concurrent agents AgentWorld sustains **138–224 t/s aggregate** decode (vs ~63 agg /
82 per-agent for a single agent) — a **2.2–3.6× total-throughput gain** from batching, per-agent landing
at 5.8–7.9 t/s (fine for autonomous/background fleets). These match the `qwen3_5_moe` family to within
run-noise (the four finetunes share topology + quant + serve, so raw decode t/s is identical — finetuning
does not move throughput).

## 2. Teamwork build games (frogger + maze)

Canonical `agentic-arcade/teamwork` harness on `:8092` at **team 6 / merge-top 2 / 15-min** wall-clock,
thinking OFF, served `-np 6 -c 262144`. Lead seeds a complete game; each round 6 workers each return a
complete improved build; a merger fuses blackboard + top-2; a never-regress guard (jsdom runtime
validation) only adopts builds that still run.

| game | rounds | winner | final bytes | jsdom valid | assertions | notes |
|---|---:|---|---:|:--:|:--:|---|
| **frogger** | 1 | merged | 40,439 | ✅ | 6/6 | 6/6 workers valid; clean first pass |
| **maze** | 1 | merged | 27,483 | ✅ | 7/7 | 6/6 workers valid; clean first pass |

Both games built cleanly on the first pass (no failed seeds / reseeds this run).

## 3. Code-quality eval (Claude Opus 4.8 judge, /50 rubric)

Judge reads each game's actual source against the fixed rubric (each dimension /10): **Completeness**
(required features really implemented) · **Correctness** (runs *and plays* correctly) · **Structure**
(organization/readability) · **Robustness** (edge cases, resets) · **Polish** (audio/anim/visual/UX).

| game | chars | **/50** | Comp | Corr | Struct | Robust | Polish |
|---|---:|---:|:--:|:--:|:--:|:--:|:--:|
| **Frogger** | 40,439 | **31** | 9 | 3 | 8 | 4 | 7 |
| **Maze** | 27,483 | **40** | 9 | 8 | 8 | 7 | 8 |

### Maze — 40/50 (Robo-Maze Shooter)

A genuinely **working, winnable** maze shooter — consistent with AgentWorld being the only model to ship a
working maze in the 2026-06-29 cross-model study. Hand-designed 20×15 layout; **flood-fill confirms full
connectivity** (all 137 floor tiles reachable from the player start; exit + all 3 enemy spawns reachable).
Enemies are created with real `w`/`h` (24×24) so AABB collision works both ways — **bullets kill robots and
robots damage the player** (this is exactly the `radius`-undefined / NaN-collision bug that broke
Ornith's and NEX2's earlier mazes; AgentWorld avoids it). The **exit door is functional** (`getDoorPos()`
→ `checkCollision(player, door)` → `wave++` / `loadLevel`), so the level is winnable by reaching the green
door. Power-ups (speed/shield/spread), shield-absorbs-hit, screen-shake + flash, particles, and Web-Audio
SFX (shoot/explosion/levelup/powerup) all wired and balanced.

**Minor only:** enemies never shoot (contact-damage only — a difficulty simplification, not a bug); the
diagonal-normalize block is dead code (movement uses an `else-if` chain, so `dx`/`dy` are never both
nonzero). Nothing breaks playability.

### Frogger — 31/50 (this build is unwinnable; two validator-invisible blockers)

Feature-complete and well-presented on the surface — lerp grid movement, three vehicle types (car/truck/bus)
with distinct rendering, logs + turtles, 5 safe zones, 2 levels, lives/score HUD, menu/over/victory/
transition states, death + completion particles (drawn *after* the background, so they're visible), BGM +
SFX. It passes jsdom, passes 6/6 assertions, and scores 61 on the harness's internal heuristic — **yet it
cannot be played to completion**, via two independent bugs that only source/logic review catches:

1. **The river is uncrossable (row-6 death strip).** The drown band is `frog.y >= GRID*6 && <= GRID*9`
   (rows 6–9), but floats are placed only on rows 7,8,9 — and the `<= GRID*9` bound *excludes* row 9's
   float (y=380). When the frog hops up to **row 6 (y=260)** there is no float in-band, so it always drowns.
   Moves are one grid row at a time, so row 6 cannot be skipped → the river can never be crossed → the frog
   never even reaches the road. *(Numerically verified.)*
2. **The center safe zone is unreachable.** Frog x-positions are ≡20 (mod 40); the middle zone sits at
   x=400, so the nearest reachable columns (380/420) are each exactly 20 px away and the slot check is
   strict `< GRID/2` (=20). At most **4 of 5** slots can ever fill → `levelCompletedSlots >= totalSlots`
   is never true → the level can't complete even if the river were crossable. *(Numerically verified.)*

Completeness/Structure/Polish are real (hence 9/8/7), but a doubly-dead win path caps Correctness at 3 and
Robustness at 4.

### Takeaway

AgentWorld's **maze capability is consistently strong** (40 here, 41 in the prior study — a working,
connected, winnable shooter with a functional exit). Its **frogger this run regressed to a broken build**
(31 vs 42 prior) — the teamwork build is stochastic, and the never-regress guard only enforces *runnable +
static-gate-passing*, not *playable*. This run is itself a fresh, clean example of that gap: a frogger that
loads, validates, passes every assertion, and is still impossible to win.

## Reproduce
```bash
SKIP_BENCH=0 bash /home/frosty40/qworld_turbo/bench/run_live_evals.sh \
  /mnt/data2tb/agentworld/agentworld-35b-a3b-Q5_K_M.gguf agentworld-35b-a3b-turbo agentworld 8092
# validator: NODE_PATH=/home/frosty40/.cache/teamwork-validator/node_modules node \
#   /home/frosty40/agentic-arcade/teamwork/validate_game.js <game.html>
```