I had a bit of time last week and wanted to see how Unreal’s new MCP works. Mainly, I wanted to get a better understanding and some first-hand experience of the current state of this kind of AI workflow in video games.
The idea was fairly simple: make a quick procedurally generated environment using PCG, and do as much as possible by only talking to an agent rather than manually building things.
This is how it went.
Getting set up
I started a new Unreal 5.8 project and set up the MCP plugin, along with the tool connectors and built-in terminal. I configured the terminal to run Claude — you need a paid Claude subscription for this to work. You can use other LLMs as well. The main point is that Unreal exposes a lot of its internal functionality for agents to use through a protocol called MCP.
I started by asking it to add a rectangular “floor” object, which it did.
Building the first PCG setup
The next step was to work on a PCG graph. The Unreal Fest presentation made this look very impressive, so I asked it to create a reasonable-looking forest using a closed spline as a boundary. I also wanted to be able to define “path” splines where trees would not grow, with vegetation scaling down slightly near those paths.
A few minutes later I had a PCG graph in my level using the built-in Unreal PCG demo assets.
Bringing in real project assets
Next, I imported some assets from our main game project, which is currently running in Unreal 5.7. Using the Migrate function in the asset browser, I was able to bring across some trees, rocks, building pieces, characters and even an entire multi-tile setup. This worked flawlessly.
Then I asked it to set up the lighting for the level. The instruction was to make it look like a spring morning, with a bit of volumetric fog and some light rays. After a couple of iterations, it looked reasonable.
I also imported one of our tile bases, which was much larger than the original floor. At this point I asked Claude to update the splines to work with the new “floor”, and replace all the existing assets with an appropriate selection from the newly imported ones.
It took a while, but it looked through the assets, their shapes and sizes, and came back with an updated graph. It looked very impressive, but still very flat — mainly because the ground itself was flat — and it had that very obvious out-of-the-box procedural look.
Getting around the MCP limitations
The next step was to make the ground hex slightly displaced. It told me the MCP didn’t have the right interface for this, but then wrote a quick Python tool that generated a new mesh and imported it on top of the old hex. This was a bit unexpected, but worked really well.
The only thing it couldn’t figure out was importing vertex colours. For some reason they got lost in the process.
Then I asked it to look at how the rocks were being placed, because they looked a bit generic. It changed the PCG graph so the rock formations looked and felt more natural. It also discovered that we had a variety of rock materials and used a selection of them across some of the instances. That was a nice touch.
Next I moved on to the paths. The rocks were evenly placed and looked a bit off, so Claude improved the PCG algorithm used to generate the points and tried to make the paths feel more “walked”. It also switched to a different selection of meshes that were better suited to pebble-like placement.
I manually painted the vertex colours on the floor hexes, as that was one operation it couldn’t perform.
Letting the agent judge its own work
I still wasn’t happy with the background or horizon. It was pretty much empty and made the whole scene feel flat, so I asked it to build some distant mountains.
It started working out formation, distance and sizing rules and built something I wasn’t completely sure about. I noticed it was still ticking away, and at this point it took a screenshot, analysed what it had made and decided for itself that the formation looked off and the texture scaling wasn’t great either.
It removed all the rocks and built a better version, which ended up staying.
You can see a short video of the environment with a few more assets in on YouTube here https://youtu.be/MKfLmcrVT_8
So, is it actually usable?
Overall, it was very impressive.
Altogether, this took about an hour and a half. It was definitely an eye-opener in terms of how far the technology has come.
It is far from being properly usable, though.
I think Epic will have a very hard time getting this feature into a stable, reliable state. A lot of that comes down to the way Unreal Editor handles incorrect or incomplete data. In quite a few places it relies on asserts, which effectively means crashing the editor for the end user.
In a second experiment, I tried getting Claude to set up some spline operations and had six or seven editor crashes because the spline system is brittle in this way. I suspect there are plenty of other systems with similar patterns.
Regardless, it is definitely worth having a go and experiencing it yourself. Even with the rough edges, it gives a pretty good idea of where this kind of workflow could be heading.
