I have been building CodeFizz Editor Agent, a plugin that lets an AI assistant work directly inside the Unreal Editor. It is not a chat window that writes code for you to paste in. The agent calls real editor commands, so it creates the asset in your project, and it can read back what happened and correct itself when something does not compile.
It works with Claude Code, Cursor, VS Code, Gemini, and any MCP client.
UMG: the full widget tree, slots, bindings, animations, MVVM viewmodels
StateTree, Enhanced Input, Level Actors, Curves, Data Tables, and Insights profiling
That is not the whole list and I can’t paste 615 lines here. The full catalog is searchable at Tools | CodeFizz Editor Agent
How it works
Everything runs through a free command line tool called cfa. The same binary is also an MCP server, so your AI tool can talk to it either way.
irm https://codefizz.dev/install.ps1 | iex
cfa login
cfa install-plugin "E:/Unreal/UE_5.8"
cfa skill install
cfa health_check
The cfa skill install step is the one that matters more than people expect. It installs a reference that teaches the AI how the commands actually behave, the conventions to follow, and the traps to avoid. Without it the model guesses at parameters. With it, it looks things up first and gets it right far more often.
The plugin is under 4 MB and runs entirely on the editor side. Nothing ships in your packaged game.
Versions
UE 5.6, 5.7 and 5.8, Windows 64 bit. Every release is built and tested against all three before it goes out.
I will drop some clips of actual runs in the replies below rather than stacking them all in the first post.
Happy to answer anything here. If there is a part of the editor you want reachable that is not in the list yet, say so and I will look at it. Most of what exists now came from exactly that kind of request.
Materials and shaders, built by typing what you want
This was the first one I recorded, and it is three separate runs in one video.
First, an iridescent holographic material from a single prompt, written as custom HLSL. Then the same look again from scratch, but with a rule: raw Unreal nodes only, no HLSL anywhere. Two very different graphs, same result on screen.
The third run is the one I actually care about. There is a visual bug in the material, so I take a screenshot and hand it to the agent. It looks at the image, works out what is wrong, researches it, and fixes the material itself. That loop of “look at the result, correct the asset” is the whole reason I kept building this.
A full UE5 menu UI with zero images, materials only
One hard rule for this run: no images at all. No textures, no imported PNGs. Every button, panel, label and the background had to be made out of materials.
It starts with the background material, then the Common Button and Common Text setup added straight from the command line. From there I keep pushing the background with prompts, from a fractal fluid look into an actual fluid simulation, plus an abstract shape that keeps shifting and changing colour.
The last part of the video is me walking through what it actually built: the materials, a per state material instance for every button, the panels, the styles, and how the whole thing wires into the main menu.
I described the forest I wanted (big rocks, small rocks, trees, foliage) and pointed the agent at a marketplace asset pack. It read the meshes out of that pack by name, decided where each one should go, and generated the whole PCG graph itself.
Then I dropped the graph in the level and scaled the PCG bounds up to cover the landscape.
The first result was honestly not great. Too many big rocks, no grass anywhere. So I re-prompted it to cut the rocks down and spawn grass around them, and it rebuilt the graph. Second pass looks far cleaner with full grass coverage. I left that part in because that is what using it actually looks like.
A whole solar system in Niagara, no nodes wired by hand
One prompt, and it authors the entire Niagara system: the planets, their orbits, the sun, the asteroid belt.
It builds the custom materials for each planet and the sun first. When it hits an error, it asks Unreal what went wrong and fixes it, without me stepping in. Then it places the effect in the world, takes screenshots, looks at what is right and what is not, and keeps making its own calls from there. I only stopped it once, to point it at the material overrides step.
The part worth watching is the end. Everything is exposed as user parameters: asteroid belt radius and count, orbit tint colours, planet colours and sizes, sun glow intensity, overall system scale. All of it updates live and can be driven from gameplay at runtime, so it is not a one shot asset you throw away.
A level prototype from one prompt and a reference image
I gave it one prompt and a reference image, and it blocked out the whole level. It plans the layout first, before it builds anything, then creates the materials, lays out the blockout geometry, and arranges the pieces into place. Errors along the way it checks and fixes itself.
What comes out is a prototype level for wall running that you can walk through straight away, instead of greyboxing the whole thing by hand.
Worth being clear about the limits: this run uses plain cube blockout meshes. If you point it at your own ready made static meshes in the prompt, it arranges those into the level instead.
A stylized ocean water material, written from scratch in about twelve minutes
No water plugin, no starter content, no nodes placed by hand.
I asked for stylized water with full control over waves and foam. It reads its own material reference first to confirm the conventions, then does every asset operation through the command line. It writes Gerstner waves summed across several octaves inside one Custom HLSL node, each layer with its own wavelength, amplitude, steepness and direction, and derives the normals analytically rather than sampling a normal map.
It does not compile the first time. It reads the error back out of Unreal and fixes it itself, finishing at zero errors and 2005 pixel instructions, then clears the orphaned nodes and wires refraction distortion into the depth sampling.
Four assets come out: the water material, a Gerstner waves function, a foam function, and a material instance. Shoreline foam blends properly because it is driven by scene depth against pixel depth. From the instance I can change shallow and deep colour, subsurface scatter, foam colour and coverage, wind direction, wave scale, amplitude and choppiness, without ever opening the graph.
That is the bit that matters to me. A hand written water shader is usually a day of work for a tech artist. This was a prompt, a self correcting build, and a parameter pass.
