Using AI Tools for
Game Development
Games need more content than a team can make
- A modern game is a mountain of content: levels, dialogue, items, tests. And it keeps growing.
- You can't scale that by hiring linearly. Budgets and deadlines don't stretch.
- AI agents let a small team produce and check content at scale — the work of a studio, run by a few people.
Agents are your dev crew
We're using AI to build the game, not (mostly) to run inside it. One exception at the end: talking NPCs.
Six jobs, one idea
- 01Generating levels, layouts & encounters— random but always playable
- 02Modular encounter design— case study
- 03Difficulty & progression— tuning the curve with data
- 04QA at scale— thousands of playtests, real bugs & balance data
- 05Visual mockups— fast pre-production (and where the line is)
- 06Machine-learning NPCs— characters that actually talk back
What is an AI agent?
A chatbot answers. An agent does the job: it looks at the situation, decides what to do, and takes an action — running a tool, writing a file, checking a result — then looks again.
One agent is limited. A crew is a studio.
One agent has no one to catch its mistakes; it grades its own homework. So give each agent one job and let them hand work to each other: someone to make, someone to check, someone to fix.
Same as a small studio: a designer, a lead, a tester. Except the team is agents.
Orchestration
Frameworks like CrewAI and LangGraph package this, but the pattern is older than the tools, and a few lines of code often beat them in production.
Make → Check → Fix
One concrete example, before we start:
- A Writer agent drafts a quest.
- A Lore-Checker agent reads it against your story and flags a contradiction.
- The Writer revises, and they check again, until it passes.
Generating levels & encounters
Content that's different every time, and always beatable.
Two ways to make a level
Traditional procedural generation
Rules, noise, and tiles — Wave Function Collapse, grammars. Deterministic, fast, controllable. No AI. This is what most games actually use, and it works.
Agentic generation
An LLM designs from intent — "a tense ambush with a sniper nest" — and places it with tools. Flexible and human-readable, but it needs checking.
Make a level. Prove you can win it.
- The Generator composes an encounter: setting, enemies, a twist, a reward.
- The Evaluator checks it. And this is what just got wild: with MCP and today's models, an agent can actually play the level, or write a deterministic test that plays it.
- Blocked? The Refiner opens a wall or moves a key, and they check again.
The check → fix loop, live
- The Generator is an LLM working from a brief — "a tense ambush that teaches the player to use cover" — not random noise.
- The Evaluator is an agent that can actually play the level (via MCP): is it beatable, and does it deliver the intent?
- The Refiner revises toward the goal — then they loop.
This one runs right in the slide — click Generate level a few times. Every layout is checked, and drilled if blocked, so it's always beatable.
Modular encounter design
Case study: the same crew, working with bigger pieces.
Snap ready-made rooms into a level
Hand the crew a box of ready-made encounter rooms — a fight, a puzzle, a treasure room — each with an entrance and an exit.
- A Composer (the Generator) snaps rooms together.
- A Validator (the Evaluator) guarantees a path runs through.
Same contract, new composer
Games like Spelunky have snapped rooms into beatable levels for years, by hand-written rules. What's new is letting an agent be the composer.
- Each room is authored once, by a human, and validated.
- The agent only arranges pre-approved pieces, so quality holds while quantity scales.
- The winnability guarantee never changes; only who does the composing does.
Human taste, machine volume
Your designers set the vocabulary of rooms; the crew produces and checks endless combinations of them. You get scale without handing away authorship.
Difficulty & progression
Tuning the challenge curve with data instead of guesswork.
Measure the curve, don't guess it
- Playtester agents play and record what happens: deaths, time-to-clear, win-rate.
- A Balancer agent reads that data and nudges difficulty up where it's too easy, down where players stall — then runs it again.
- The same crew can shape order, not just difficulty: open a branch early for players cruising, gate one for players struggling.
Honest note: shipped difficulty directors (Left 4 Dead) are hand-tuned heuristics; the agent-in-the-loop version is where the research is heading. The shipped-AI example is Sony's Gran Turismo Sophy.
Players forgive the help they chose
They never forgive the help they caught. The instant a player suspects the game is quietly bending the challenge, especially near a purchase, it doesn't feel like help. It feels like being handled.
QA at scale
Thousands of playtests overnight, with real bug reports and balance data.
The Chaos Crew
- A swarm of tester agents plays thousands of times: some random, some deliberately trying to break it.
- A Reporter agent turns it into bug reports (steps to reproduce, severity) and balance stats.
- You wake up to data no human team could produce by hand.
100 matches in seconds
- Character A vs. B, 100 simulated matches, no graphics — just results.
- The win-rate settles on screen: A wins 71%.
- Nudge B stronger, re-run, watch it slide back toward 50%.
Illustrative live output. Recorded fallback ready: if the sim stalls or looks wrong by ~0:20, cut to the recording.
The output: a report you can act on
The point isn't watching a bot play. It's the structured report a human can act on the next morning.
- Reproducible: exact steps, seed, and inputs.
- Ranked: severity and how often it hit across 1,000 runs.
- Quantified: win-rates, soft-locks, out-of-bounds, all as numbers.
Soft-lock: player falls behind vendor stall, no exit.
repro: seed 4471 → buy potion → walk left ×3
hit: 38 / 1000 runs (3.8%)
area: market_02 · first seen: build 214
This crew is real today
You can assemble these agents yourself, or use tools that already package them. Studios run them to catch crashes and balance problems before players ever see them.
It helps testers, it doesn't replace them
These agents do the thousandth repetitive run so people can focus on judgment and feel. That's the honest framing, and the one players and colleagues respect.
Visual mockups
Fast pre-production concepting, and a clear line on where it belongs.
A Style-Guide agent keeps mockups on-brand
- Write your look down once: palette, mood, "no neon."
- A Generator produces mockups; a Critic checks each against the guide and sends off-style ones back.
- You explore directions in minutes, for pitches and pre-production.
Where this belongs — and where it doesn't
- Player backlash against AI production assets is still strong, so most studios keep these tools in pre-production, not shipped art.
- That reaction is softer for solo and indie devs, where there's no budget for an art team.
- Underneath it is authorship and ownership: whose work is it, and where did the training data come from.
Mockups yes, shipped art from people
Use AI for mockups and exploration; use asset packs and human artists wherever possible for what ships. I work with artists on my own projects.
The line, drawn by the market
Machine-learning NPCs
Up to now: agents that build the game. Now: an agent that lives inside it.
NPCs you can actually talk to
A Persona is an LLM-powered character that holds an unscripted, real-time voice conversation with the player, built in Unreal Editor for Fortnite (UEFN).
- You speak → the model understands and replies → it talks back in a voice.
- Today it's real-time voice, English-only — you wire it up, you don't train a model.
Even here the move holds — the safety layer is the agent checking the talker before its words reach a player.
From a Fortnite proof to your own games
Epic Personas docs: dev.epicgames.com/documentation/fortnite/developing-personas-overview-in-unreal-editor-for-fortnite
Play you could never script
- An NPC that remembers what you actually did — and brings it up ten hours later.
- Talk your way through: interrogate a suspect, haggle a merchant, talk down a guard, all in your own words.
- Companions that banter and improvise instead of repeating the same three lines.
- A whole town where every character can hold a real conversation — and quests emerge from them.
From menus to open conversation
For decades, "talk to an NPC" meant picking from a list someone wrote. Now the player can say anything — and the character can actually answer. That's a genuinely new kind of play.
One person, a studio's worth of crews
Six jobs, one move
- In every job, one agent makes or plays, and another agent checks the work — sometimes a third fixes it.
- Where it touches artists and testers, it works for people, not instead of them. Say that plainly, and it's the difference between adoption and backlash.
Where to start on Monday
- Find the repetitive work first. The opening move isn't tooling. It's spotting a process worth automating: the manual run, check, or pass someone repeats every build.
- One maker, one checker, in plain code. You rarely need a heavyweight framework in production. A frontier model, the tools it can call (MCP), and a little orchestration run the make → check → fix loop.
- Friendliest first build: the level generator. Small, checkable, and the checker can actually play it.
- Runtime NPCs: Epic's Personas docs (UEFN): build one, don't train one.
- My course goes end-to-end: Multi-Agent AI for Game Development.
Automate the boring, keep the judgment
Find one repeatable process worth handing off, then wire the smallest crew that does it. A maker plus a checker beats a do-everything agent, and you rarely need a framework to run them.
Questions
Joshua Burdick · Epic Games. This is the world of my Multi-Agent AI for Game Development course.