Procedural Generation vs AI Agents: Which One You Want
Noise, grammars and WFC against an agent driving an editor. Determinism, scale, runtime and iteration cost — the axes that decide which one you need.
A wave function collapse solver will produce ten thousand valid dungeons before lunch, and not one of them will be memorable. An agent driving an editor will build one town square where the fountain sits where a person would have put it, and that takes four minutes and costs money every time you run it. These are not two attempts at the same product. They are different machines, and the only useful question is which one your problem is shaped like.
What classical PCG actually is
Procedural generation is not one technique, and treating it as a monolith is how this comparison usually goes wrong. Four families do most of the work in shipped games.
Noise fields
A function from coordinates to a value — Perlin, simplex, Worley cells — summed over several octaves, then thresholded and remapped into height, moisture, ore density, cave volume. Cheap enough to evaluate per vertex, infinite in every direction, and deterministic for a given seed. Godot ships FastNoiseLite in the box; every other engine is one small file away from the same thing. Noise gives you landscape. What it cannot give you is intent — noise has no opinion about where the village goes.
Grammars and rewriting
L-systems came out of biology: Aristid Lindenmayer, 1968, modelling how algae grow. They turned out to describe branching plants extremely well, which is why vegetation tooling still leans on them. Shape grammars do the same trick for architecture — CityEngine's CGA rules subdivide a mass into floors, floors into facade panels, panels into windows. Graph rewriting works on level topology instead of geometry: find-and-replace rules over a graph of rooms and connections.
Unexplored's cyclic dungeon generation is the canonical example of the last one, and its scale is instructive: two generators, many modules, and roughly five thousand individual rewrite rules, authored by hand in a purpose-built tool. That is the honest price of a grammar and also the point of one — five thousand rules is five thousand pieces of design intent, written once and applied for ever.
Constraint solvers
Wave function collapse — Maxim Gumin's 2016 implementation of what Paul Merrell had published in 2007 as model synthesis — treats a level as a grid of cells, each holding the tiles still possible there. Collapse the lowest-entropy cell, propagate the adjacency constraints to its neighbours, repeat. You supply the tiles and the rules for which edges may meet which, and the solver structurally cannot emit an illegal join. What it cannot tell you is whether the result is worth walking through.
Engine-native and DCC systems
Unreal ships a node-based PCG framework: spatial data flows in from a component in the level, becomes points, is filtered and transformed through a graph, and spawns meshes — live in the editor, or at runtime. Houdini sits at the other end of the pipeline, where a digital asset is built once and loaded into Unity or Unreal through Houdini Engine with its parameters exposed. This is where PCG stops being a demo and becomes production infrastructure: Ghost Recon Wildlands used it for thousands of kilometres of road through mountain terrain, and the Far Cry 5 team rebuilt the entire game world nightly on build machines.
Whole open worlds rest on these systems, and they are not going anywhere.
What an agent driving an editor actually is
The other approach hands a language model the tools a level designer would use — draw a road network, subdivide blocks, place a building of these dimensions, scatter trees inside this polygon, set the sun angle — and lets it work in steps, reading the scene back between them. Cuberta works this way: the editor exposes location-level tools over the Model Context Protocol, you connect your own agent to it, and the location appears object by object while you keep the ability to select, move and undo anything.
The structural difference is not "AI" against "algorithm". A procedural system's output is a system that produces content; an agent's output is content. One is a factory, the other a very fast contractor.
Runtime versus authoring time
This axis settles most of these arguments before the interesting part starts, and it gets skipped constantly. A procedural system compiles into your game. A seed, a few kilobytes of rules and a noise function become a planet on the player's machine, generated in the frame before they see it. An agent cannot do that. It needs a model, a network round trip, tens of seconds to minutes, and money per invocation. Nobody is putting that in the loading transition between floors of a roguelike.
If the requirement contains the words "at runtime" — infinite terrain, a fresh dungeon each run, a world too large to ship as data — the comparison is over before it begins. You want PCG. Agents live entirely at authoring time, on the near side of the build.
Determinism, and a seed you can ship
Same seed, same world, on every machine, for ever. It reads like a technical footnote and it is worth an enormous amount.
Elite fitted a galaxy of star systems into a machine with kilobytes of memory by storing the seed instead of the systems. No Man's Sky derives planets, flora and colour palettes from a 64-bit seed, which is where the figure of over 18 quintillion planets comes from, and why two players who travel to the same coordinates find the same rock formations. A Minecraft player can paste a seed into a forum post and someone else gets an identical world.
The everyday payoff is smaller and more useful than the marketing one. A bug report that contains a seed is reproducible. A designer can lock the seed for the tutorial island and iterate on the rules without the island moving underneath them.
Agents give you none of that: the same prompt twice produces two different towns, both plausible, neither reproducible. Be precise about what is lost, though. The process is non-deterministic; the artifact is not. Once you have exported the GLB, that file is as fixed as one a human modelled. You lose reproducible generation, not a stable asset.
The rest of the axes
| A procedural system | An agent in an editor | |
|---|---|---|
| What you author | rules that make content | the content itself |
| First result | days: build the system first | minutes |
| Ten-thousandth result | effectively free | ten thousand times the first |
| Same input twice | identical, by construction | a different plausible answer |
| Where it runs | editor and shipped game | authoring time only |
| Brief changes midway | edit rules, regenerate all | say the new thing, carry on |
| When it looks wrong | read the graph, bisect the seed | look at the step, redo it |
| Who has to write it | someone fluent in graphs or code | someone who can describe a place |
| Best at | a million acceptable results | one genuinely good one |
Intent: encoded once, or interpreted each time
A grammar is intent compiled. "Shops on corners, houses mid-block, nothing over three storeys within 40 m of the square" — written once, it holds across every instance the system will ever generate, without you thinking about it again. The price is that you must be able to state your intent as rules, and "this street should look like it was rebuilt in a hurry after a fire" is not a rule you will write in an afternoon.
An agent interprets intent fresh, per request. You get the rebuilt-after-a-fire street without writing a rule for it, and you get a different one tomorrow from the same sentence. Interpretation delivers flexibility and inconsistency in the same package, and you do not get to take only one.
Scale, and where the lines cross
At a million instances the procedural system wins by a margin nothing closes: its marginal cost per instance is near zero and the agent's never drops. At one instance the ordering reverses, because the system costs days before it produces anything. The crossover is not at a million — in practice it sits in the low dozens, right around the point where you notice you have described the same constraint five times and have been hand-executing a rule you could have written down.
Where agents genuinely win
- One-off places that have to feel authored. The hub village, the boss arena, the street in the trailer. Nobody writes a generator for something they need once, and a generic version of a place the player spends two hours in is the wrong economy.
- Briefs that change halfway. "Make it a fishing village instead" is one sentence to an agent and a rewrite to a grammar, because the rules that produced the mining town encode assumptions that are now wrong.
- When the rules cost more than the result is worth. Three variations of a farmyard do not justify a farmyard generator. Ten thousand do. Most work sits nearer to three.
- Teams with no technical artist. A grammar needs someone who thinks in graphs or code. An agent needs someone who can describe a place precisely — a skill more level designers already have.
What agents are bad at
Consistency across many scenes
Ask for forty houses and the agent interprets the word "house" forty times. Floor heights drift, kerb profiles drift, the material palette widens. A kit-based procedural system cannot make that mistake, because it has one kit and one set of constraints. Agents approximate constraints rather than enforcing them, which is the strongest argument for keeping a procedural layer underneath.
Cost per scene
Every location costs model time and money, and the tenth costs the same as the first. A procedural system's cost is almost all up front — a much better shape as soon as you need volume.
They do not ship
Worth repeating, because it is the hardest constraint here: an agent is a tool in your pipeline, not a system in your game. Whatever it builds must be baked into assets before a player sees it.
The hybrid most studios will land on
Not a compromise — a division of labour along the axes above. The agent authors, the procedural system fills.
Concretely: the agent lays out the road network, the block structure and the twenty buildings a player will actually look at, because those need judgement and there are only twenty of them. That location leaves Cuberta as GLB or FBX with textures included, and in the engine the PCG graph takes over — vegetation scattered by slope and biome mask, street furniture along splines, distant filler at density, regenerating whenever the layout moves. Anything that must exist at runtime stays on the procedural side. Most tools sold as AI city generators already sit on this seam: a model chooses layout and style, procedural rules do the arranging.
The tell that you have the split right is the direction the work flows: judgement to the agent, volume to the rules, neither asked to do the other's job. That is roughly how the division already worked between a lead designer and a Houdini artist. The tools changed. The shape of the problem did not.
