@sashanaria · 7 min read

Title card: Run to Ember, directing a game jam with a crew of AI agents. Epic AI MegaJam 2026, theme Director's Cut. Four days, one human, 311 commits. Behind the text, the red mech Ember holds its blade over a ruined city, seen from a rooftop in first person.

For four days in November my job was directing. I made a first person game for the Epic AI MegaJam, and AI agents wrote almost all of its code and a lot of its content. I made the design calls, built the level by hand, played it all day and said what felt wrong.

Run to Ember is a run across a ruined city under a dome, a jump onto the blade of a 35 m mech, and a short turn-based fight at the end. It is a solo entry, made in Unreal Engine 4.27. The jam's theme was Director's Cut, and its theme text said: "Using AI agents? You're directing those too. Set the vision, delegate tasks, and decide what makes the cut."

This is the short version. The full making-of, with every tool, commit hash and failure, is in the dev log on itch.

First person view on a zipline: gloved hands on the cable over a ruined city in the mist, with the red mech Ember standing in the distance.

The idea

The idea comes from my earlier thoughts about mech tactics games. What if the story doesn't live in dialogue or descriptions, and you live it instead, as the pilot running to the mech and then fighting in it?

That is why the run is most of the game. The fight in the jam version is small, one mech against a few enemies, and it's there to show the idea. The director's cut part is the running.

Text first, before the jam

Before this jam I had been making games with agents in both Unreal and Godot. In Unreal the slow part was always Blueprints. They are binary assets, so an agent can't read them, diff them or review them. In Godot everything is text, and agents are much faster there.

So before the jam I made three calls:

  1. A PSX look. It doesn't need Unreal 5 features, so Unreal Engine 4.27 was enough.
  2. All gameplay in AngelScript. It lives in text files that agents can read, write and review, and it hot reloads while I play.
  3. The UI as text too. I made a small plugin that builds screens from XAML files.

On top of that sits a project template with the tools an agent needs to check its own work: a bridge into the running game for input, state and screenshots, scenario files that play the game and write pass or fail reports, and a test gate. All of it was done before the jam started, and none of it is game content.

The crew

Diagram of who held what during the jam. Me: every design call, the level, playtests, art picks and feel. Orchestrator: owns the Unreal project and the one editor. Author agents: one task each on their own git worktree. Reviewers: a different model from the author, code and tech only. Mac content thread: concept art, 3D tests, audio and films. Producer bot: the plan, credits and handoffs. The rule: my decisions are logged word for word with a date.

The setup is a faster version of the one I described in One Designer, a Crew of Agents. A few rules kept it sane:

  • My words, dated. Every design decision was logged as my exact words with the date. An agent could not "remember" a decision I never made.
  • A writer never reviews its own work. A different model reviewed each change.
  • Code review doesn't cover art. No art import counted as ready until a fresh in-engine capture showed it with real textures, on the ground, at the right scale.
  • One editor, handed back and forth. I was in the editor most of the day. Agents prepared work offline and merged it when I handed over: "editor is yours for like 20 mins or so, integrate everything that was waiting for integration".

Models moved around, mostly because of quota. Claude Opus 5.5 orchestrated on Thursday until it hit its weekly limit. GPT-6 Astra and GPT-6.1 SOL carried Friday to Sunday morning, with Astra on the 3D, Blender and animation work. Claude Fable 5.2 took the last day.

Four days

The four jam days as four cards. Thursday: movement on a test range; went wrong: enemies rendered with no textures and the checks still passed. Friday: the city, by hand; went wrong: rain fell upward. Saturday: props and a change of plan; went wrong: the build grew to 2,410 MB. Sunday: making it shippable; went wrong: a compile error got past a green test run.

Thursday. Movement on a test range. I compared two character controllers and picked by feel: "I think PB seems to be a bit more fun and snapier". By evening there was mantling, hold climbing with stamina, vault, slide, searchlights and a zipline.

Friday. An agent had run overnight on its own. My verdict in the morning: "As for overnight fixes I didnt like most of it." I blocked out the city by hand while agents worked on separate files: the first person arms, the blue PSX look, the weather, and three short films that play over the world as double exposures.

Saturday. Agents gave one roof vent brief to Blender, Meshy, Rodin and Tripo and put the results side by side. I liked Rodin's look most, and a city kit followed. That afternoon I broke my own "No combat" rule and asked for a battle at the end: "just ember fighiting 2-3 enemies, that is it."

Sunday. The build had grown to 2,410 MB, because I had placed 5,986 kit pieces for speed. An overnight agent run brought it down with streaming, LODs and texture caps. My brief for the last day: "we are not aiming for pure quality, we need fast, dirty, working tricks, smoke and mirrors, optimization, players experience is the goal."

Bar chart of the packaged game's size. Empty template dry run: 63 MB. Saturday afternoon: 2,410 MB. Sunday morning: 716 MB. Submitted: 501 MB.

Tuning while I play

The fastest loop of the jam was this one. Every number the player feels sits in an AngelScript tuning file. I play in the editor and write a chat message, an agent changes one value, it hot reloads into the running game within seconds, and I keep playing.

On Sunday night one searchlight got three commits in two minutes: "before was just nice, go back to quater", "half it now more", "and one more time". The enemy's beam in the last building went from fixed sweep points, to points I can drag in the level, to a rule that only tagged cover hides the player and casts a shadow. That took 22 minutes.

The battle at the end: on a grid over the ruined city, a burning tile explodes next to enemy units while the mech Ember stands at the edge of the board.

The battle went the same way. After a playtest I wrote: "lets leave just 1 skill, if you shoot empty field, it will spawn fire, if you shot fired cell it will do blast, we are cutting now, it should be easy to understand and fun". Three skills became one.

What the checks missed

The agents checked their own work inside the running game, and that caught real bugs. One review found a soft lock and a stamina bug before any playtest did. But the failures I remember all passed their checks:

  • Enemies came in with no textures, and the checks were green.
  • Rain fell upward. I reported it, the fix passed its test, and I saw it going up again. The test checked position. My eyes saw the streak texture.
  • The music was "too happy" and the generated cars looked awful. No test has an opinion on that.
  • A script passed the test run and still failed to compile in the editor.
  • For a while an agent and I were tuning the wrong light.

The 25/25 result proves the scenario ran successfully, not that the animation looks correct.

That line is from an orchestrator's own note on Friday, and it is my favourite of the jam. Agents cannot judge art or feel. Someone has to look.

Concept and result

Concept art set the look and the beats of the route. It was a guide, not a layout to copy. To pick an image model I asked for the same shots from three of them with the names hidden: "dont tell me which one is what, so I can judge only by look".

Side by side. Left, concept art: a flooded street between ruined buildings with a red mech in the distance. Right, the final build: the same flooded street in the game, with sunken cars and the red mech small in the mist.
Side by side. Left, concept art: a pilot jumping from a ruined building toward the blade of a giant red mech. Right, the final build: the mech Ember holding its blade, seen in first person from the edge of the last building.

What it cost

The harness I use has a usage dashboard. For the week of 10 to 16 November it shows 367 sessions and $2,507 at API list prices, across all my projects. I ran on subscriptions, so this is not what I paid. One model, GPT-6 Astra, was 49.4% of it.

Bar chart: $2,507 of agents at API prices in one week, 367 sessions. GPT-6 Astra $1,239 (49.4%), Grok Bot $422 (16.8%), Claude Fable 5.2 $279 (11.1%), Grok 4.7 xhigh fast $230 (9.2%), Claude Opus 5.5 $217 (8.7%), GPT-6.1 SOL $62 (2.5%).

The biggest number is the cache. Of 3.67 billion tokens processed, 3.56 billion were cached input. Almost everything an agent reads, it has read before.

What I learned

  • Plain text is the speedup. Code, UI, tests and tuning as text meant agents could read and review almost the whole game.
  • Tune live. Playing while an agent changes one number was the fastest loop we had.
  • Check inside the packaged game. Scripted runs in the shipped build caught bugs the editor never showed.
  • The editor is one shared resource. Much of the jam was handing it back and forth.
  • Plan for quota. Models ran out mid-task, so the routing changed every day and every task needed a handoff note.
  • Fast kitbashing has a bill. Heavy packs cost a whole night of optimization.

Tools and thanks

  • Engine: Unreal Engine 4.27 with Hazelight's AngelScript, and Project Borealis movement.
  • Agents: Codex (GPT-6 Astra, GPT-6.1 SOL), Claude Code (Fable 5.2, Opus 5.5, Sonnet 5.5), Cursor (Grok 4.7), all inside T3 Code.
  • 3D and animation: Blender, Cascadeur, Rodin. Meshy and Tripo in a side-by-side test.
  • Images, film and sound: ChatGPT and fal for concept art, Kling and DaVinci Resolve for the films, ElevenLabs and FMOD for audio.
  • Level method: Steve Lee's How I design levels in text first, and why.

The full credits and licences are on the game page. You can download and play it there.

Aleksandr Nariadchikov · @sashanaria

Run to Ember: Directing a Game Jam with AI Agents

PLAYTEST LENS

A playtest analyst I built solo for Meta’s hackathon, and what it can’t see.
Run to Ember: Directing a Game Jam with AI Agents

KICKTURN: 3D SKATE ON PLAYDATE

How I built a 3D skate game for Playdate with AI agents in one jam weekend.
Run to Ember: Directing a Game Jam with AI Agents

AGENTIC GAME DEVELOPMENT

How I build a game with AI agents and keep the final say on every design call.
This site uses cookies for site functionality and traffic analysis. Privacy policy