
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.

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:
- A PSX look. It doesn't need Unreal 5 features, so Unreal Engine 4.27 was enough.
- All gameplay in AngelScript. It lives in text files that agents can read, write and review, and it hot reloads while I play.
- 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

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

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."

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 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".


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.

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



