Guide to the Claude + Unreal Engine 5.8 Setup

Two Versions of the Same City  

City Sample is one of the best-known showcases of what Unreal Engine 5 can do. In December 2021, Epic unveiled The Matrix Awakens: An Unreal Engine 5 Experience — an interactive demo inspired by The Matrix for next-gen consoles. Its huge, highly detailed city, complete with traffic and crowds of MetaHuman characters, was later released publicly as a learning project: developers used it to explore World Partition, Nanite, Lumen, Chaos, Mass AI, and other UE5 systems. Incrypted covered how Epic built the digital humans for this demo back in 2021 in its MetaHuman Creator review.

The original had one catch: while the city was rendered in UE5, it was assembled with procedural tools outside the engine — in SideFX’s Houdini. Replicating that pipeline was only feasible for a team with specialists in third-party software.

The update changes exactly that. The new version of the city, as stated in the announcement, is “built entirely in Unreal Engine” — using the Procedural Content Generation (PCG) framework and the new experimental PCG Primitives plugin, which Epic describes as “a library of primitives and examples for world building.” On top of that, the new city is more complex than the original: it sits on uneven terrain, roads and sidewalks curve, and the streets are overgrown with deciduous trees and entire forests — something the earlier procedural version could not do. 

What’s Included in the Update  

The project now looks like this: the original level built in Houdini is still there, and two new ones have been added alongside it. According to the documentation, this includes the full procedural city level L_CitySamplePCG_Demo, generated from 18 interconnected PCG graphs — from the terrain graph PCG_1_1_Terrain and background mountains to districts, streets, highways, parking lots, buildings, and rooftops — and a simplified level, CitySample_Generator_steps, where the city is built through a sequence of dependent graphs so each phase can be studied and reworked separately.

In addition to the levels, the project includes:

• PCG graph examples that show the city being procedurally rebuilt step by step — they also serve as reference baselines for the MCP server
• five types of Megaplants trees used to populate the entire procedural city
• the PCG Assembly library — ready-made static mesh configurations for rooftop platforms and piers
• shape grammar sets — rules that let you quickly assemble buildings and roads from selected presets
• a dedicated PCG subgraph designed specifically for generating City Sample buildings

All PCG graphs and assets are packaged into the CitySamplePCG plugin (in Epic’s documentation, it also appears as CitySamplePCG_demo) — with it, you can reproduce the city in your own project. The sample relies on a number of systems with Experimental and Beta status, some of which are disabled by default — for example, you may need to manually enable Nanite Foliage for vegetation at the project level.

Unreal MCP: a Neural Network Gets Access to the Editor  

The second half of the announcement is about who built this city. In Unreal Engine 5.8, which Epic unveiled at State of Unreal on June 17, 2026, an experimental Unreal MCP appeared — a Model Context Protocol server embedded directly into the editor process. Through it, any MCP-compatible AI agent can connect to Unreal Editor and control it: spawn actors, set up lighting, create materials, and edit the scene. In the same announcement, Epic emphasized that “the interface is open, as is the choice of model: build with Claude, Gemini, or any other,” and called 5.8 the last planned major UE5 release — early access to UE6 is slated for late 2027.

Here’s how it works: in the editor, you enable the Unreal MCP and All Toolsets plugins, after which the server comes up on the local address 127.0.0.1:8000. Next, the agent is launched from the project root and sees the editor’s tools as standard MCP tools. Tool Search mode is enabled by default: instead of hundreds of schemas, the model gets three meta-tools — list_toolsets, describe_toolset, and call_tool — and loads the required sets on demand.

Security is handled radically simply: the server accepts connections only from the local machine and rejects any external requests, but it has no authentication layer — you can’t expose it to the public internet. All tool calls run sequentially on the editor’s game thread, so the agent can’t trigger two conflicting actions at the same time. 

PCG as the Language LLMs Use to Describe the World  

The core idea behind the updated City Sample is that the language model doesn’t need to place millions of objects one by one — it writes the rules, and PCG handles the placement. At Unreal Fest Chicago 2026, Epic presented a talk on how an LLM uses PCG as its “spatial language,” building on the PCG Primitives plugin with ready-made examples of roads, buildings, forests, and parks.

To make this work, the MCP server adds a set of PCG skills — context packages that explain to the model how the framework is structured. The main one, Skill_PCGGraphGeneration, covers tasks with repeatable rules: planting vegetation, filling out city blocks, and laying out a road network. Alongside it is a shape grammar skill for facades and street dressing, plus skills for terrain based on Mesh Partition, surface detailing, and biomes. Loading the skill is a mandatory part of session setup: without it, Epic frankly warns, the model “misunderstands PCG concepts, overcomplicates solutions, mixes up nodes and parameters, and builds unreliable graph logic.” Technically, skills are UAgentSkill class objects inside the engine, and the agent receives them through the same MCP tools: ListSkills shows what’s available, and GetSkills returns the instructions for the selected one.

Epic describes the process as a “supervised collaboration,” rather than an agent working autonomously. The recommended workflow is nine steps, where a human manually selects the required assets in the Content Browser, asks the model to first study the reference graphs and explain the plan, applies changes incrementally, and stops incorrect actions early. For heavy operations like inspecting the attributes of thousands of PCG points, there is a separate Data View mode — processing happens outside the model’s context window and saves tokens.

Guide: Connecting Claude Code to Unreal Engine 5.8  

Claude Code is first on the list of clients for which Epic generates an Unreal MCP configuration. That’s where we worked: no command line needed, every model action is visible in the chat, and the result shows up immediately in the editor viewport. What’s more, we delegated the integration setup to Claude itself: instead of manually editing configs, it took a single prompt with a link to the documentation. Below is the full step-by-step route.  

Step 1: install Unreal Engine 5.8

Unreal MCP and the new City Sample levels require version 5.8 specifically — they are not available in 5.7 and earlier. Open the Epic Games Launcher, go to the Unreal Engine → Library tab, click “+” next to Engine Versions, and select 5.8 (at the time of publication, the current build is 5.8.2). You don’t need to compile the engine from source — Unreal MCP works with the standard binary build. If you already have an older version installed, 5.8 will install alongside it and won’t affect existing projects.

The installation takes 50-60 GB and anywhere from half an hour to several hours, depending on your connection. While the engine is downloading, you can move on to the next step.

Step 2: grab City Sample from Fab

The project is distributed for free, but the path to it runs through the Fab asset store. Open the City Sample page and click Add to My Library — the panel on the right shows that the latest update is dated August 27, 2026.

After you add it, the button will change to Saved in My Library, and View in Launcher will appear next to it. Click it.

Your browser will ask for permission to open Epic Games Launcher.

In the launcher, the built-in Fab panel will open with the same listing. Click Create project.

In the Choose Project Name and Location window, set the project name and folder, and be sure to check Select Version of the Engine for Project: by default, the launcher may fill in an older version — switch it to 5.8, otherwise the project will not include PCG levels or Unreal MCP.

Next comes a long download. The launcher will download about 96 GB, and after unpacking, the project will take up more than 200 GB on disk, so free up space on your SSD in advance. 

After installation, the library shows the project’s actual size — 205.58 GB on disk.

Once the download is complete, the project will appear in the launcher’s My Projects section.

Step 3: Let Claude Code handle the setup

Open the Claude desktop app, go to the Code tab, and select the project folder — the one that contains the CitySample.uproject file. This matters: Claude Code reads the MCP server configuration from the .mcp.json file in the root of the opened folder, and a session launched from somewhere else won’t see the server. Next — one prompt with a link to the documentation. 

Prompt

Unreal Engine 5.8 ships with an experimental built-in MCP server called Unreal MCP (plugin ModelContextProtocol), documented here: https://dev.epicgames.com/documentation/unreal-engine/unreal-mcp-in-unreal-editor. Set up the connection between this Claude Code session and the editor. Once the editor is running, verify the connection. 

From there, Claude acts on its own, and that is the most interesting part of the test. It reads the documentation, checks the project state, and explicitly adds the ModelContextProtocol and AllToolsets plugins to CitySample.uproject. Then it requests desktop access — the only point where a human needs to grant a new permission — finds the editor window, takes a screenshot, locates the Cmd console field in the bottom panel, and enters the ModelContextProtocol.StartServer command on its own.

After that, the model validates the setup: it confirms that port 8000 is listening, performs the MCP handshake over HTTP, requests the tool list, and makes a test call to a real tool. It enables server autostart via the editor settings MCP toolset — the change is written to EditorPerProjectUserSettings.ini. Finally, Claude creates a .mcp.json in the project root — in the same format generated by Epic’s console command ModelContextProtocol.GenerateClientConfig ClaudeCode. 

In the final report — a table of checks: port 8000 is listening, the handshake succeeded, tools/list returned three meta-tools, 52 toolsets are available via list_toolsets, and the test call to SetSectionProperties completed. And one warning: the Claude Code session started before the server came up, so the unreal-mcp tools will only appear after restarting the session.

Claude Code shows every file edit and every desktop action — for a first run, it is worth reviewing to understand exactly what is changing in the project. 

Step 4: Restart the session and open the city

Open the L_CitySamplePCG_Demo level first and wait until the buildings appear in the viewport: World Partition loads the cells, and the PCG components validate the cache.

Initial state of the city: the square and courtyards are planted with temperate-zone trees from the Megaplants pack.

Initial state of the city: the square and courtyards are planted with temperate-zone trees from the Megaplants pack.

Step 5: Load the PCG Skill and Read the Graphs

Epic calls loading the skill a mandatory part of setting up the session, and we combined it with the first project read — to immediately see how well the model understands what it is dealing with.

Prompt

List the available agent skills in this project and load the PCG graph generation skill. Then look at the PCG graphs of the City Sample level and explain in a few sentences how the city is generated. Do not change anything yet. 

After about 30 tool calls, the model gets a list of 22 skills registered in the editor.

Next, Claude reads the graphs: Districts — in full; Roads, Lots, and Buildings — in a compressed form (the structures turned out to be too large, and the model collapsed them with a script into a list of nodes with types and parameters); the remaining 14 — from their descriptions. The final explanation accurately reproduces the pipeline: terraforming the island and background development, two manual footprints (a hexagon tower and Central Park), slicing the city with arteries into districts and blocks with three road categories, subtracting roads and the park from lots, assigning building styles by district class, roofs, piers, and an outer forest thinning toward the water.

With context skills and the graphs already read, you can move on to the main thing — rebuilding the city with words.

Demo: Rebuilding a City With Prompts  

All changes are made in the parameters of the PCG graphs, so the city remains fully editable by hand — no baked result. 

Tropical vegetation

The first request is the shortest and, as it turned out, the longest to execute.

Prompt

This city is located in a tropical latitude. Adjust the vegetation accordingly. n

Claude first figures out where the vegetation lives: all the city’s trees are five temperate-zone species from Megaplants (black alder, hazel, European beech, Norway maple, and aspen), assigned across three graphs — Outer Forest, Central Park, and Leftover Lots. Then it hits a blocker: there are no tropical plants on the machine — not in the project, not in the plugin, and not in the local Megascans library. Simply reshuffling node parameters would still give you the same alder. So the model stops and proposes a plan: download free tropical packs from Fab, sized around 2–4 GB, but since that’s a download from an external service, it asks for an explicit “yes.”

After the reply “yes, download from Fab,” the episode begins that made the whole test worth it. Unreal MCP has no toolset for Fab, so Claude drives the Fab window inside the editor via the desktop: it clicks the Fab button in the Content Browser, sets the Free filter, reads the listings, opens the license selector, chooses the free Personal plan, and hits Add to Project. On the very first pack, Fab shows a license agreement — and the model stops again: “this is a legal agreement on your account, so I left the dialog open.” You accept it yourself, or with the command “accept the Fab EULA,” and the download continues.

Next, Claude behaves like a meticulous asset manager: it grabs Palms Pack 01 (12 palm variants from 1.3 to 9.2 m, plus undergrowth and grass), Tropical Vegetation: Pandanus Plants by Project Nature (the pack isn’t flagged for 5.8 — the model picks the closest 5.4 version, reasonably assuming static meshes migrate without issues), as well as Alexandra Palm from Quixel and Banana Plants (these two ultimately didn’t make it into the graphs — the first turned out to be 1.5-meter-tall undergrowth, and the second imported as a single mesh). But it skips “raw” FBX/glTF sets made for Blender — they would have required manual material setup. Then it measures each new mesh with a script, splits them into canopy palms, mid-story, and ground cover, and tweaks 13 asset-assignment nodes across three graphs, raising the outer forest density from 0.05 to 0.07 trees per square meter — palm crowns are now alder-sized. After a few viewport test shots, it removes the “dry palm” and “thickets” variants, which read from a distance like dead trees. 

Along the way, the model fixed an error that had existed in the project before it: four nodes in the outer-forest and residual-lots graphs referenced a non-existent noise texture, which prevented those graphs from generating at all — Claude found the same texture under a different name and repointed the references. Three vegetation volumes were regenerated without errors.

Height limit for development

The second request is about the city skyline, and here the model had to deal with numbers.

Prompt

Ensure no building is higher than 200 m. 

Claude traces where the height comes from and finds three independent sources. For regular buildings, MaxHeight is read from the noise texture and multiplied by the high-rise zone coefficient up to 5 — totaling up to 370 m, while complex buildings add three more tiers on top. The main tower is a separate graph: a base plus tiers, and each of the tower’s three “arms” is four identical tiers, so a “90-meter” arm actually reached 352 m, and the whole structure hit 481 m. Finally, the background skyline is meshes uniformly scaled up 100×, up to 295 m.

The corresponding fixes: in the buildings graph — a global constant and five limiter nodes set to 180 m at every point where footprints fall into a building assignment (complex buildings with their tiers end about ten meters higher); in the tower graph — the arm tiers were cut to 47, 42, and 37 m, the middle tiers to 30 m, and the top block to 60 m; for the background, Z-scale was reduced to 60 with a position offset so the top lands at 198 m. Along the way, the model noticed that the ring of trees around the tower was still alder from the previous step, and replaced it with the same palms.

The most interesting part is the process. Editing the graph automatically triggers regeneration, and explicit Claude calls to regenerate during that time get rejected. The model runs into this twice, reads the editor log, figures out the pattern, and adds a background command to “wait until the log has been quiet for 25 seconds” before retrying the call. After regeneration, it measures each building group from its own base and compiles a table: regular large — 176.8 m, complex — 190.1 m, mid district — 147.8 m, small — 39.8 m, tower arms — 176, 160, and 144 m, antenna — about 193 m, background — 198 m.

For the report, Claude takes two screenshots with the camera set to exactly 200 m in height and zero tilt.

Light like 9 a.m. in Bogotá

The third request doesn’t touch PCG, focusing on lighting instead — and shows that the editor skills aren’t limited to procedural generation.

Prompt

Adjust the lighting of the scene so it is set in Bogota at 9 AM on the 29th of July 2026. 

Claude loads the street-lighting skill from the editor registry, finds the level’s light actors, and calculates the sun’s true position for Bogota at that date and time. It then applies the changes to the light sources, checks the density and coverage of the cloud material, and captures the result with the same camera as the original scene — so the comparison is fair.

Limitations Worth Knowing Upfront

The combo is impressive, but it has plenty of sharp edges — some Epic acknowledges itself, and others surfaced during testing.

Everything is experimental. Unreal MCP, PCG Primitives, and the sample’s core systems all carry Experimental status: APIs and data formats can change at any time, and Epic advises caution when using them in shipping projects.

Hardware and footprint. City Sample is one of Epic’s heaviest learning projects: a 96 GB download, more than 200 GB on disk, and for the original sample the company recommended a 12-core CPU at 3.4 GHz, 64 GB of RAM, and a GeForce RTX 2080-class GPU with 8 GB of VRAM. The simplified CitySample_Generator_steps level exists specifically to help you understand the mechanics without that kind of load.

Local only, and editor-only. The server lives inside the Unreal Editor process: close the project — the connection is gone, and you must open the Claude Code session strictly from the project folder, otherwise .mcp.json won’t be picked up. The server has no authentication, and port 8000 listens only on the local machine — that’s protection, but also a limitation: remotely, from a laptop to a workstation, the setup doesn’t work.

An LLM is not an autopilot. The documentation keeps stressing: the model is reliable only within clearly defined tasks, with references, and under supervision. Complex graph edits require an understanding of how PCG works — without that, you can’t validate the result quality. In our test, the model stopped itself twice — before loading from an external service and before accepting the license agreement — and that’s the right behavior, but it means you can’t leave it alone with the task.

Regeneration gets in its own way. Any edit to a PCG graph triggers automatic regeneration, and while it’s running, explicit regeneration calls are rejected. On the full city, rebuilding buildings takes minutes, and the model has to wait, watching the log — Claude learned to do this as it went, but session time grows.

Token costs. Analyzing large graphs and doing mass asset inspection are expensive operations: a city with 18 graphs can quickly chew through context and the message limit. This can be partially mitigated with Data View mode and by explicitly selecting the needed objects in the Content Browser instead of freely searching across the project.

None of these limitations changes the main point: the setup works for a regular user on a regular PC, without building the engine from source and without API keys.

Words Become Worlds

The updated City Sample is Epic’s answer to the main AI question in game development: not “will a neural network replace the artist,” but “what language should they speak.” Instead of generating finished scenes as a black box, the company embedded the model into an existing procedural pipeline: the LLM writes the rules, PCG executes them, and the result remains fully editable — in the announcement, this was framed as “no black boxes and no magic pills, just your creative vision, amplified and accelerated.”

The gesture itself is telling: in 2021, Epic used the “Matrix” city to showcase the power of Nanite and Lumen, and in 2026, the same city to demonstrate how the PCG + MCP + Claude stack works. An official MCP server in one of the two main game engines means agentic tools stop being an enthusiast add-on and become part of a developer’s standard toolkit. Incrypted explained how the same logic works in a 3D editor in a guide to pairing Claude with Blender, and covered the core techniques for working with Anthropic’s model in a comprehensive guide to Claude. City Sample raises that bar to a city with millions of objects — and, as our test showed, the Claude desktop app is enough for it, with one prompt for setup and three for rebuilding.