Enactra · research note · September 2026

Code4City: can a coding agent build a real city block?

Code4City hands an AI coding agent one square kilometre of Manhattan around Madison Square Park — maps, terrain, aerial photos and street-level photos — and asks it to build that place as a 3D world a game engine can run. We ran it with three models — gemini-3.8-flash, GPT-6 Astra and Fable 5.1 — each given exactly the same data, the same brief, the same machine and maximum reasoning effort, so this compares the models like for like.

The task

Code4City A game engine and a modelling tool

Given
The source data and the brief.
Tools
Unreal Engine and Blender, with a graphics card, so the agent could render and look at its own work.
Hands back
An Unreal project and level that opens and runs, the Blender source files, and the code that produced them.
Effort
Maximum reasoning effort, for all three models.

The source data

Maps, terrain, aerial imagery and street-level photographs of the square kilometre.

Everything was frozen before the runs, so all three runs saw exactly the same bytes.

What came out

Each clip is a delivered world, recorded without changing anything the agent built. Within a row the camera path is identical.

gemini-3.8-flash
Low orbit around the park, 45 m up.
GPT-6 Astra
Low orbit around the park, 45 m up.
Fable 5.1
Low orbit around the park, 45 m up.
gemini-3.8-flash
Down Fifth Avenue at street height.
GPT-6 Astra
Down Fifth Avenue at street height.
Fable 5.1
Down Fifth Avenue at street height.

With the same data, brief and tools, the two larger models produced buildings with windowed facades, streets with lane markings and parked cars, and recognisable landmarks. gemini-3.8-flash produced blocky untextured buildings with oversized roofs.

The same four cameras in each world

Stills from the same camera position, lens and resolution in each world. Click any image for full size.

gemini-3.8-flashGPT-6 AstraFable 5.1
straight down over the park
the park from the south-west
Fifth Avenue
the Flatiron corner

How the agents worked

Every session was logged in full.

runactions takenshell commandslooked at its own imageslooked at the source photos
gemini-3.8-flash327180911
GPT-6 Astra604536561
Fable 5.144829817712

What the shell commands were for

Each shell command is sorted by what it touches: the game engine, the modelling tool, the agent's own scripts, image files, or reading and moving files and logs — mostly the agent checking the output of something it just ran.

own codegame engine3D modellinglooking at an imagereading files and logssomething else
geminiown code: 27%27%game engine: 22%22%3D modelling: 9%9%looking at an image: 1%reading files and logs: 39%39%something else: 1%GPT-6own code: 37%37%game engine: 19%19%3D modelling: 13%13%looking at an image: 9%9%reading files and logs: 22%22%something else: 1%Fableown code: 35%35%game engine: 22%22%3D modelling: 14%14%looking at an image: 12%12%reading files and logs: 16%16%

How often it looked at its own images

Renders, previews and plots the agent produced itself. Looking at the aerial and street photographs it was given is counted separately in the table above.

gemini9GPT-656Fable177

The run that looked at its own output most often delivered the most finished world. That is Fable 5.1, which looked at its own images 177 times, against 56 for GPT-6 Astra and only 9 for gemini-3.8-flash — which spent more of its looking on the source photographs (11 times) than on what it had built.

An action counts as looking at an image when it opens an image file or names one in a command. Images are sorted by where they live: the source data the run was given, or anything else, which is the agent's own output.

Time and cost

runactive timeactionscost
gemini-3.8-flash90 min327$5.84
GPT-6 Astra255 min604$60.46
Fable 5.1170 min448$106.73

Cost, US dollars

gemini$5.84GPT-6$60.46Fable$106.73

Active time

gemini90 minGPT-6255 minFable170 min

gemini-3.8-flash was by far the cheapest run — $5.84, against $60.46 for GPT-6 Astra and $106.73 for Fable 5.1, which ran at maximum effort for hours and cost 10 and 18 times as much. Time does not follow cost: GPT-6 Astra took the longest at 255 minutes but cost less than Fable 5.1, which finished in 170.

Costs are API-equivalent: the tokens each run actually used, priced at the provider's published list price. Active time excludes pauses.

Appendix

A. Following a pedestrian and a vehicle

In each world the camera follows whichever pedestrian and whichever vehicle moved furthest during the recording, from the same distance and height.

gemini-3.8-flash
following one pedestrian
GPT-6 Astra
following one pedestrian
Fable 5.1
following one pedestrian
gemini-3.8-flash
following one vehicle
GPT-6 Astra
following one vehicle
Fable 5.1
following one vehicle
B. How much moves in each world

Moving parts counted from each world's own running simulation (a car with four separately turning wheels counts as five).

runmoving partsvehicle partspedestrian parts
gemini-3.8-flash24168
GPT-6 Astra2,5611,940621
Fable 5.11,580700880

gemini-3.8-flash populated its world with a handful of moving things; the larger models with over a thousand. In gemini-3.8-flash's world the traffic finds the ground by casting a ray straight down from a fixed 20 m and standing on the first solid thing it meets — a roof, a tree canopy or the collision shell of a merged block of buildings — so most of its cars ride at exactly 20.2 m, above the street, at a perfectly constant speed.

C. What each run handed back
runengine assetsBlender filessource filesits own test renders
gemini-3.8-flash110111666
GPT-6 Astra386853153
Fable 5.1397336177