Recursive Game Creator: An Agentic Product-Level Experience-Oriented Game Harness
Jiajun Chen, Haoyu Wu, Mingda Jia, Xihui Liu
A recursive development harness that refines game prototypes into polished experiences using programmatic playtesting and preference-informed feedback.
How can we automate game development so that generated games are not just syntactically correct, but actually fun to play?
Coding agents can generate runnable game code, but functional correctness does not guarantee an engaging player experience. Prototypes often lack the responsive feedback, balanced difficulty, and coherent presentation required for a finished product. Recursive Game Creator organizes development into a closed loop of four roles: a Designer, a Builder, a Coding-Native Player, and an Experience-Oriented Reviewer. The system uses programmatic policies to collect diverse gameplay trajectories, which the Reviewer analyzes to provide targeted feedback for iterative refinement. This approach achieves state-of-the-art performance on GameCraft-Bench and significantly improves task success rates on GameASG-Bench compared to baseline methods.
Paper Primer
The core mechanism is a recursive loop that treats game development as an optimization problem over player experience. The Coding-Native Player acts as a high-frequency tester: it writes and executes code-based policies to interact with the game's programmatic interface, bypassing the latency and visual-interpretation errors of GUI-based agents.
The Reviewer functions as a diagnostic engine: it maps behavioral trajectories and visual evidence to game-specific rubrics, then translates these findings into structured textual feedback. This feedback guides the Designer to update the game's plan, effectively closing the loop between raw code execution and subjective quality.
Recursive Game Creator achieves state-of-the-art performance on standard game development benchmarks.
Evaluation on GameCraft-Bench and GameASG-Bench. An overall score of 77.89 on GameCraft-Bench and a 93.4% mean runtime-check pass rate on GameASG-Bench.
Iterative refinement significantly increases player engagement metrics.
Expert-rated user study comparing Round 1 to Round 3. Average playtime increased from 1.50 to 12.41 minutes, with control and art scores improving from 2 to 8 on a 10-point scale.
Why is a "Coding-Native Player" necessary instead of just using a standard GUI-based agent?
GUI-based agents rely on visual interpretation, which is slow and prone to errors in state recognition. The Coding-Native Player uses programmatic interfaces to access structured state and event information, enabling high-frequency, reproducible testing that is better aligned with the strengths of coding-focused models.
Does this system require human intervention for every round of improvement?
No, the harness is designed for autonomous recursive improvement. While users can supply explicit preferences to guide the process, the Reviewer is capable of inferring preferences and identifying problems automatically based on gameplay trajectories and game-specific rubrics.
This paper shifts the focus of agentic game development from mere functional execution to experience-oriented refinement, providing a scalable framework for evolving prototypes into polished, player-tested software.
Introduction: Beyond Code Correctness
We frame game development as a closed-loop process that optimizes player experience over code correctness.
Recent game‑design agents can generate runnable games, yet correct code alone does not guarantee fun. Player experience hinges on engaging mechanics, appropriate difficulty, coherent presentation, and responsive feedback.
Even a perfectly compiled game can be boring if it fails to deliver the experience players expect.
**Figure 1.** Game examples from Recursive Game Creator. Rows show MOBA, racing, and visual-novel games, each with two paired views. Arrows link the paired panels. Version labels identify earlier-to-later examples from V1 to V2 and V3.
Recursive Game Creator (RGC) closes the loop by letting a Coding‑native Player generate fast, programmatic gameplay trajectories, while an Experience‑oriented Reviewer evaluates them with both quantitative metrics and visual cues. The Designer and Builder then translate reviewer feedback into new game versions, iterating toward higher player satisfaction.
The shift from syntax‑focused agents to experience‑oriented agents enables product‑level game evolution driven by player‑centred feedback.
The Recursive Game Creator Framework
The method defines a closed‑loop harness that iteratively refines a game through Designer, Builder, Player, and Reviewer stages.
RGC treats game creation as a feedback loop: the Designer proposes a plan, the Builder materializes it, the Player tests the result, and the Reviewer judges the experience, sending the verdict back to the Designer.
How does RGC differ from a traditional iterative game‑development pipeline that relies on manual testing?
Traditional pipelines insert a human tester between code changes and design decisions, which introduces latency and subjectivity. RGC replaces the human tester with a coding‑native Player that automatically generates behavioral evidence, and a Reviewer that algorithmically evaluates that evidence, enabling rapid, data‑driven revisions without waiting for a person to play.
The harness is an agentic system where the Player acts as an autonomous evaluator that supplies behavioral evidence to drive the Designer’s next iteration, closing the loop without external supervision.
Why is the Player called “coding‑native” and not just a generic test agent?
“Coding‑native” emphasizes that the Player writes and runs policies through the game’s programmatic interface, avoiding any reliance on natural‑language prompts or visual interpretation at each step. This makes the evidence directly comparable to the game’s internal state, which a generic test agent might not expose.
Each refinement round repeats the four‑stage cycle, allowing incremental improvements and convergence toward the target experience.
Why not perform a single, exhaustive redesign instead of multiple refinement rounds?
A single redesign would have to anticipate all gameplay nuances upfront, which is infeasible. Multiple rounds let the system discover unforeseen failure modes in early rollouts and address them incrementally, reducing risk and computational waste.
Designer expands the user brief into a concrete plan Pt = (ht, $\Delta$t, At, Xt).
Builder drafts a playable version Zt = Draft(Gt, $\Delta$t), generates requested assets X*t, and integrates them into candidate Ct.
Player selects an executable policy $\pi$t,k, rolls it out on Ct to obtain trajectory $\tau$t,k, and records visual evidence Vt,k.
Reviewer aggregates all trajectories Et, computes success rates and playtime, applies game‑specific rubrics, and produces revision feedback for the Designer.
Designer updates the plan based on the feedback, and the loop repeats for the next round.
Player rollout – generate a trajectory from a candidate version and a policy.
Round 1 Designer emits Pt₁ = (“faster run”, $\Delta$₁, “At ≤ 5 s”, X₁).
Builder drafts Z₁ with the speed boost, generates the platform asset X*₁, and integrates Ct₁.
Player runs policy $\pi$₁,₁ on Ct₁, producing a 6‑second trajectory $\tau$₁,₁ (fails time limit).
Reviewer notes success rate = 0 % and playtime = 6 s, recommends tightening the limit.
Designer updates plan to Pt₂ = (“faster run”, $\Delta$₂, “At ≤ 4 s”, X₁).
Builder re‑integrates the same assets into Ct₂ (no new assets needed).
Player runs $\pi$₂,₁ on Ct₂, producing a 4‑second trajectory $\tau$₂,₁ (meets limit).
Reviewer records success rate = 100 % and playtime = 4 s, declares the candidate retained.
The example shows how feedback on a quantitative metric (playtime) directly reshapes the Designer’s acceptance goal, and how reusing assets avoids unnecessary regeneration.
**Figure 2.** Recursive Game Creator’s multi-round refinement workflow. The Designer plans revisions and the Builder implements code and assets. The coding-native Player collects gameplay trajectories. The Reviewer combines behavioral and visual evidence with shared and game-specific criteria to produce preference-informed revision feedback. The central circular arrow denotes repeated refinement with a configurable number of rounds. Agentic-player refinement improves game quality across rounds, while human-involved refinement improves the play experience and its alignment with inferred player preferences.
Quantitative Benchmarking
RGC consistently outperforms baselines on both benchmarks.
We benchmark the Recursive Game Creator (RGC) on two suites—GameCraft‑Bench and GameASG‑Bench—each measuring both overall game quality and adherence to specified requirements.
**Table 1.** GameCraft-Bench results (0–100, higher is better). @k denotes refinement round k.
**Table 2.** GameASG-Bench results. Baselines are from Zhang et al. (2026c), Table 3. All scores are percentages. Task success also reports the count. Bold marks column maxima. Green parenthesized gains in the final row are percentage-point improvements over GPT-6-Astra high with Codex CLI.
RGC consistently outperforms baselines across both quality and requirement‑fulfillment metrics.
Qualitative Evolution of Games
Qualitative ablations reveal how recursive self‑improvement refines game content across three genres.
The recursive harness supports a broad spectrum of game elements: from fog‑of‑war displays and hero rosters to race‑condition dynamics, career garages, and character‑driven dialogues. These examples demonstrate that the system can accommodate diverse interfaces without redesign.
**Figure 3.** Qualitative analysis of multi-round RSI. The three panels compare development versions, organized as early, intermediate, and later snapshots (V1–V3). (a) Action-game combat, encounters, interfaces, and upgrade feedback. (b) Visual-novel dialogue, choices, illustrated events, and reading support. (c) Meme Arena scenes, skills, finishers, and control guidance.
In the action‑game track, later versions add richer character art, more elaborate skill effects, and clearer boss‑mechanic cues. Upgrade feedback becomes visually distinct, making the combat loop easier to read.
The visual‑novel evolves from prose‑heavy exchanges to split speaking turns, illustrated events, and scene‑grounded choices. These refinements improve narrative flow and help players track available decisions.
Meme Arena retains its three‑character roster while iterating arena detail, skill‑specific effects, and finisher emphasis. New movement‑guidance cues and selection interfaces make combat cues more explicit.
Across all three genres, the qualitative evidence shows that recursive self‑improvement targets concrete revision goals: clearer game state communication, richer content, and more interpretable player actions.
Player Exploration and Expert Analysis
Recursive refinement demonstrably boosts player‑experience scores across three rounds.
The Recursive Game Creator treats game development as a closed‑loop process: a Player supplies behavioral feedback, which the Designer and Builder use to iteratively refine mechanics toward the desired experience.
The Player runs directly on the game code, generating gameplay trajectories without invoking a separate neural model for each step.
Figure 4 visualizes how the coding‑native Player explores an FPS test scene via repeated policy rollouts, reaching both open areas and interior rooms.
**Figure 4.** Spatial exploration in an FPS test scene. The left panel shows three illustrative GUI-style routes from a shared spawn. The right panel shows visitation from 48 recorded coding-native policy rollouts. Color shows normalized visitation density. The source reports 97.1% grid coverage, including 11 interiors.
Table 3 summarizes a user study where expert judges rated controls, playability, depth, and art on a 1–10 scale after each refinement round, alongside average playtime.
User‑study scores show a clear upward trend, confirming that recursive revision steers the game toward the intended player experience.
Table 3 reports controls rising from 2 to 8, playability from 1 to 7, depth from 3 to 6, art from 2 to 8, and average playtime increasing from 1.50 to 12.41 minutes across three rounds.
Related Work
Related work situates our approach among coding agents, game development systems, and feedback-driven refinement.
Coding agents have been applied beyond pure software creation, enabling video generation, embodied control, and interactive content. Systems such as Code2Video, VideoAgent, VideoCoCo, Code as Policies, ProgPrompt, Voyager, and Eureka illustrate how generated code can be turned into visual media or robot policies.
In game development, frameworks like MetaGPT, ChatDev, GameGPT, AutoUE, OpenGame, AVR‑Agent, Harness‑of‑Harness, and RSIGame generate or edit game code within engine runtimes. Benchmarks such as GameDevBench, GameCraft‑Bench, and GameXpert‑Bench evaluate these pipelines, yet merely producing runnable artifacts does not ensure an engaging player experience.
Feedback‑driven refinement methods such as Self‑Refine, Reflexion, AFlow, EvoMAC, and the Darwin Gödel Machine use iterative feedback to improve outputs. Preference‑aligned techniques like RLHF, direct preference optimization, and VideoDPO incorporate human or model‑based signals, while experience‑driven procedural content generation and RL target affective outcomes. Our harness builds on this lineage by feeding structured player preference data back into the game‑generation loop to steer iterative revisions toward desired experiences.