See it build inside Unreal

A level runs at 3 FPS. The agent presses Play, records a trace with Unreal's own profiler, and follows the time down to one Blueprint. Then it fixes it and measures again: about 90 FPS. The level was made slow on purpose, and the agent was not told where the problem was.

• 1The prompt gives only the symptom: the game feels slow, find out why, real numbers, no guessing, fix nothing yet. The agent presses Play on its own and records a 30 second trace. One frame takes 312 ms, and the game thread uses 310 of them. So it is game logic, not graphics. The graphics card works for only 3% of the frame.
• 2It follows that time down to one Blueprint, BP_MarketVisitor. Its Event Tick takes 301 of the 312 ms. 60 visitors each collect all 1,701 static meshes in the level and loop over them on every frame, which is 102,060 loop steps per frame, and the result is never used. It checks its own numbers, and it presses Play again with nothing recording, to confirm the profiler was not the slow part.
• 3Asked for a fix that keeps the same result, it moves the heavy loops from Event Tick to BeginPlay, so they run once. It measures again: one frame goes from 304 ms to 10.6 ms. It reads the list from a live visitor during Play to check the result is the same, and it names the one trade off: the list is now built once, at the start.

One reference image, one prompt, about 22 minutes. The agent builds a real 3D Niagara Fluids vortex, checks its own work from screenshots, and fixes what looks wrong. It ends with sliders you can change yourself.

• 1It starts from Unreal's own Colored Smoke 3D gas template and copies it into the project. It adds the built-in vortex force and a small inward pull, which gives spiral arms, then switches the gas to fire mode so the smoke glows by its color. It adds 13 user parameters and writes its own small module in a Niagara scratch pad that places glowing color along the arms. It compiles with 0 errors and 0 warnings.
• 2Then it checks its own work. The first look is a white box, so it turns the glow down and builds a dark test level. It takes a screenshot, compares it to the reference and fixes one thing per round, about a minute each. When everything turned pink, it found the cause: the old blue color never faded and mixed with the new red. When the arms turned into rings, it slowed them so the gas stretches them into real spiral arms.
• 3It profiles the cost: 1.8 ms on the GPU and 0.08 ms on the game thread. It tilts the camera to confirm it is a real 3D volume and not a flat card. At the end the look changes with the sliders, and Blueprints can set them too.

A full third person animation system from one prompt: a main Animation Blueprint, blend spaces, aim offsets, montages, linked anim layers for unarmed, pistol and rifle, a locomotion state machine, a character, a player controller, a game mode and Enhanced Input. No node placed by hand. You get a first pass you can play and judge in one sitting, then change by asking.

• 1The agent starts by reading. It lists the assets, checks every animation for length, loop state and additive type, and measures how fast each walk and jog clip moves, so it knows where each clip belongs in the blend space. Then it makes the input actions and the key mapping, builds the aim offsets, and creates montages for attack, fire, reload and equip.
• 2It builds the main Animation Blueprint with variables for ground speed, direction, falling, weapon index and aim pitch, writes the event graph that calculates them, and compiles with 0 errors. A base anim layer Blueprint gets six layer graphs. Unarmed, pistol and rifle are children of it and only change which clips play. One property had a different name inside Unreal, so the agent read the error back, found the real name and carried on.
• 3It sets up the character with a camera boom, a follow camera and functions for movement, fire, reload and equip. All five character graphs compile clean. In the play test, attack montages, the switch to pistol, firing, aiming, jumping and sprinting all work.

Hide and seek, built from one prompt. A Behavior Tree, an Environment Query that picks cover, AI Perception so the character can see you, and a mannequin that actually runs and hides. No nodes placed by hand. The useful part is that you spend the time judging the behavior, not wiring the tree.

• 1One prompt asks for hide and seek from scratch: a Behavior Tree, a hiding query, and perception so he can see you. The agent reads its own files, then starts creating the assets. The tree opens empty, just a root. Then it hooks up the AI controller, the perception, the tree, and the query.
• 2It builds the hiding query as a grid of points around the level. It scores them and picks a spot you cannot see, which is how he decides where to run. It builds the hider on a mannequin and assigns the controller.
• 3In play, he sees you and he is gone. The points on the ground are the query looking for cover. Follow him around the wall and he hides. Come closer and he breaks for a new spot. Same loop every time: he sees you, he looks for cover, he hides. That is the loop anyone who has put off EQS because the setup is tedious actually needed.

A day and night music system built in MetaSounds from one spoken request. Six assets, zero imported audio. Every note is generated from math nodes: a shared pluck voice, four mood patches for morning, afternoon, evening and night, and one main source that blends them on triggers. The first pass was close but wrong, so it went and researched the real soundtrack, then rebuilt the voices.

• 1One spoken request, and it produces six MetaSound assets with no wave files. A shared pluck voice, four mood patches, and a main source that blends them. The first build validates at 19 nodes and 46 connections with zero errors, but it does not yet sound like the reference.
• 2Told to research how that soundtrack actually works, it comes back with the real profile: soft piano, quiet pads, space between the notes. It rebuilds every voice to match, a felt piano lead, a pad underneath, a plate reverb on the end, and a proper key for each time of day.
• 3When a long command chokes the shell, it writes the JSON to files and keeps going. Everything you hear in the video is the rebuilt result, generated in the editor, not imported.

A complete Control Rig built from a single prompt, physics included. IK on both arms and both legs, FK down the spine, hair physics on the braid and the bangs, and secondary motion on the chest and hips. The agent reads the skeleton itself, rejects its own work twice when it gets something wrong, and finishes with every validation gate clean. Not one control placed by hand.

• 1One prompt asks for a graph rig on this character: a root and a centre of gravity control, FK down the spine, IK on both arms and both legs, hair physics on the long braid and the front and side bangs, and colliders sized off her real mesh so the hair slides over her shoulders instead of sinking into them. The agent reads its own Control Rig references first, then drives every operation through the cfa command line.
• 2It creates the rig from the skeletal mesh and dumps all 311 bones, deriving what each chain is from the geometry rather than the bone names. It establishes the lateral axis and catches that the arms and the legs run on opposite axes, which is the trap that quietly breaks a mirrored rig, and it finds the mesh already carries an artist authored physics asset so it reads those capsules instead of inventing its own.
• 3It throws away its own work twice. The first pole placement lands the tips on the wrong side of the midline, so it discards them and places them again against the real backward protrusion. Then its own gate reports that only 27 of the 31 controls were actually checked, so it goes back for the remaining four and measures the knee poles at 44.6cm forward and the elbows at 25.6cm back, mirrored.
• 4The graph gate finishes at zero errors and zero warnings across 194 nodes and 21 graphs, with the physics census landing exactly as designed and no stuck or undriven bones. Hair stiffness, damping and gravity, flesh stiffness and damping, and one overall jiggle intensity float are all exposed as rig variables, drivable from an animation blueprint at runtime. It authors Control Rig Modules and full Modular Rigs too, not only graph rigs.

A stylized ocean water material built from a single prompt, in about twelve minutes. No Unreal water plugin, no starter content, and no nodes placed by hand. The agent writes the Gerstner wave HLSL itself, fixes its own compile errors, and hands back a material instance with every parameter exposed.

• 1One prompt asks for stylized water with full control over waves and foam. The agent reads its own material skill first to confirm the conventions, then drives every asset operation through the cfa command line.
• 2It writes Gerstner waves summed across multiple octaves inside a single Custom HLSL node, each layer with its own wavelength, amplitude, steepness and direction, and derives the normals analytically instead of sampling a normal map.
• 3When the material does not compile it reads the error back from Unreal and fixes it, finishing clean at zero errors and 2005 pixel instructions, then clears the orphaned nodes and wires refraction distortion into the depth sampling.
• 4Four assets come out of it: the water material, a Gerstner waves function, a foam function, and a material instance. Shallow and deep colour, subsurface scatter, foam colour and coverage, wind direction, wave scale and choppiness all change from the instance, without opening the graph.

A whole level prototyped without blocking out a single piece by hand. One prompt and a reference image, and the agent plans the layout, builds the materials, and blocks out the entire level itself, a proper prototype level for wall running.

• 1It reads the prompt and the reference image, then plans the level layout on its own before it builds anything.
• 2It creates the materials, lays out the blockout geometry, and arranges all the pieces into place, checking and fixing any errors it hits along the way.
• 3The result is a clean prototype level you can walk through straight away instead of greyboxing by hand. It uses simple cube blockout meshes here, but point it at your own static meshes in the prompt and it arranges those into the level instead.

A full solar system built inside Unreal Engine with Niagara, without wiring a single node by hand. One prompt, and the agent authors the entire Niagara system: the planets, their orbits, the sun, and the asteroids, all driven by user parameters so everything can be changed later.

• 1Build the custom materials for each planet, the sun, and everything else the system needs. When it hits an error it asks Unreal what went wrong and fixes it on its own.
• 2Place the Niagara effect in the world, take screenshots, check what looks right and what does not, and make its own decisions from there (stopped just once to point it at the material overrides step).
• 3Expose everything as user parameters: asteroid belt radius and count, orbit tint colors, planet colors and sizes, sun glow intensity, and overall system scale, all updating live and drivable from gameplay at runtime.

A fully procedural forest built in Unreal Engine 5 using PCG, just by prompting. One prompt, and the agent builds the whole PCG graph, finds the static meshes from a marketplace asset pack by their names, and figures out where to place the rocks, trees, and foliage across the landscape.

• 1Describe the forest (big rocks, small rocks, trees, foliage) and point the agent at a marketplace asset path. It reads the meshes, decides where each one should go, and generates the PCG graph on its own.
• 2Drop the graph into the level and scale up the PCG bounds so it covers the whole landscape.
• 3The first result has too many big rocks and no grass, so re-prompt it to reduce the rocks and spawn grass around them. It rebuilds the graph for a far cleaner scene with full grass coverage.

A complete Unreal Engine 5 menu UI built just by prompting, with one hard rule: no images at all. Every button, panel, piece of text, and the background is made from materials only, no textures and no imported PNGs.

• 1Build the background material first, then add the Common Button and Common Text setup straight from the command line.
• 2Push the background further with prompts, from a fractal fluid look into a real fluid simulation, plus an abstract shape that keeps shifting and changing color.
• 3Walk through everything the agent made: the materials, the per-state material instances for each button, the panels, the styles, and how it all wires into the main menu.

Unreal Engine materials and shaders built just by typing what you want, with no manual node wiring to get started, across three live runs.

• 1Generate an iridescent holographic material from a single prompt using custom HLSL.
• 2Recreate the exact same look using only raw Unreal nodes, with no HLSL at all.
• 3Catch a visual bug, send the agent a screenshot, and let it research and fix the material on its own.