See it build inside Unreal

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.