GameDevAgent

Turn a mystery idea into a validated, playable AI game through a gated multi-agent pipeline.

Comment

Inspiration

Mystery games are systems, not just stories. A playable case needs characters, motives, evidence, interview logic, puzzle state, assets, progression, endings, and a fair solution that all agree. Traditional authoring makes that coordination slow, while one-shot generation often produces attractive prose without the contracts required by a real game.

GameDevAgent was built to make the production process visible and controllable. Instead of asking a model for a complete game in one response, a creator can move from an idea through specialized stages, inspect the artifacts, review validation, and decide when the result is ready to publish.

What It Does

GameDevAgent turns a natural-language Detective or Escape Room concept into a structured, validated, playable project.

The Creator Agent clarifies the brief, plans the production stages, and coordinates skills for story, investigation, puzzles, text, assets, validation, and publishing. Each stage exposes its artifact and dependency state. A human creator can edit, approve, reject, or regenerate content before downstream stages continue.

Approved packages are published into the Player Runtime.

  • Detective players inspect evidence, ask suspects free-form questions, unlock facts, and submit a scored deduction report.
  • Escape Room players explore illustrated hotspots, collect and inspect items, solve stateful mechanisms, question an NPC, choose routes, and reach different endings and recaps.

The deployed Player Runtime is available at:

https://detective-novel.netlify.app/

How We Built It

The project is a monorepo containing two connected systems:

  • gameGenerator owns the Creator UI, orchestration, skill runtime, artifact staging, validation, and publishing workflow.
  • detectiveGame owns case contracts, gameplay APIs, assets, dialogue, state transitions, scoring, endings, and the React Player Runtime.

The projects share one explicit workspace boundary. The Creator stages structured files for a selected case, validators check the required contracts, and publishing moves approved content into the runtime case workspace. This preserves a visible production trail from the original brief to the playable result.

GPT-5.6 is routed by workload:

  • The flagship GPT-5.6 model handles top-level orchestration and content authoring.
  • GPT-5.6 Terra handles structured validation.
  • GPT-5.6 Luna handles latency-sensitive host, character, and Escape NPC dialogue.
  • Codex coordinates code-aware and skill-based work and was also used extensively to integrate, refactor, test, and document the Build Week project.

The Creator and APIs use Python and FastAPI. Both interfaces use React, TypeScript, and Vite. The Player Runtime frontend is deployed on Netlify, and its public API is deployed on Render.

Challenges

The hardest problem was preserving consistency across stages. A clue created in the story must remain addressable by investigation logic, player-facing content, assets, runtime state, and the final report.

Escape mechanisms add another layer because object state, inventory requirements, puzzle feedback, room transitions, routes, and endings must stay synchronized.

We also needed human review without losing agent continuity. GameDevAgent keeps artifacts inspectable, separates editable content from read-only validation results, and prevents publishing from becoming an invisible side effect of generation.

Finally, the Build Week integration had to distinguish early case prototypes from the new work:

  • GPT-5.6 migration
  • The integrated agent workflow
  • Additional case iteration
  • Puzzle refinements
  • English player-facing content
  • Deployment
  • Reproducible judge documentation

Accomplishments

  • Connected a natural-language Creator Agent to a real Player Runtime.
  • Supported both evidence-driven Detective cases and puzzle-driven Escape Rooms.
  • Made production stages, artifacts, validation, dependencies, and approvals visible.
  • Added role-based GPT-5.6 routing for orchestration, authoring, validation, and runtime dialogue.
  • Added and iterated cases while improving puzzle feedback, state transitions, results, and playability.
  • Produced an English-only submission and player experience.
  • Added automated checks for model configuration, frontend types, repository scope, and player-facing language.
  • Deployed the working Player Runtime for judges.

What We Learned

Agentic generation becomes much more useful when every step has an explicit contract. The most important improvement was not a longer prompt; it was making artifacts, dependencies, validation, and human decisions first-class parts of the workflow.

We also learned that model routing should reflect the job. Deep planning and authoring, deterministic validation, and frequent runtime dialogue have different latency and reasoning needs. Keeping those roles explicit makes the system easier to test and evolve.

What's Next

  • Deploy the Creator Agent as a hosted companion to the Player Runtime.
  • Expand reusable case and puzzle templates without weakening validation.
  • Add richer collaborative review and artifact history.
  • Add more runtime puzzle types and accessibility controls.
  • Continue improving automated playability checks and end-to-end publishing observability.

Built With

Share this project:

Updates