GridFall: A Multi-Agent LLM Game Simulation in Godot With Five AI Mayors (and the Roof Fix in the Repo)

GridFall is a multi-agent LLM game simulation in Godot. You don't build the city. Five AI mayors on five different models do, and you watch. What makes it worth studying is how the work is divided. The language models only make decisions. A conventional simulation checks each decision and resolves the outcome, and a three-step fallback chain keeps the city running when no model is reachable.

This specimen is by Kunal (DEV post, GitHub repo). This post compares the maker's write-up and README with the Generative Agents paper to separate the parts of the city that are AI from the parts that are ordinary game code.

What is GridFall?

According to the maker's DEV post, GridFall is a 3D city builder made with Godot 4.7 and Blender. Five AI mayors each own one district of a shared city. Every game day they read the map, argue in public, propose and vote on laws, build infrastructure, change taxes and annex wilderness. The player watches, inspects any tile and can step in. The Disasters tab drops an earthquake or tornado, and the Powers tab sends a decree to every mayor.

The maker says GridFall was built with Factory's Droid coding agent. The agent wrote the Godot code, the Blender asset pipeline and the tests, while Kunal set direction and reviewed the results. The 3D models are procedural Blender geometry with Poly Haven CC0 textures and some Kenney CC0 kits. The post also says it was drafted with AI and reviewed by the maker. The repo lists an MIT license.

If you follow agent-built projects, compare it with the AI-agent-built Godot point-and-click adventure. More examples are under the Godot and coding agents tags.

How are the five mayors and their roles set up?

The DEV post and README list one model and one role label per mayor. All of them are served through GMI Cloud inference.

Several supporting agents sit around the mayors, according to the post and README:

• About 100 residents on MiniMaxAI/MiniMax-M3. Each decides daily whether to work, how to commute, where to spend, whether to protest and whether to move away.
• GridFall Gazette, which writes a daily newspaper and editorial.
• Council Speaker, which rules on proposed ordinances.
• Chaos Director, which picks disasters aimed at each city's weak spots.
• Grid Operator, which decides who loses power first in a blackout.
• Street Inspector: click a tile, and whoever is standing there tells you what's wrong.

Two points of analysis here. First, every model is reached through one provider, GMI Cloud. The "five vendors" idea is really five entries from one inference catalog, not five separate API integrations. Second, the role labels are the maker's. The sources don't say how much of each mayor's style comes from its prompt and how much from the model itself. They publish no comparison of how the mayors differ. Read "growth maximalist" as an assigned brief, not a measured trait.

What does a mayor see and do each day?

This loop is the most reusable part of the project. Per the DEV post and README, once per game day each mayor receives:

1. An ASCII map of its district
2. District and city stats, open lots and open construction sites
3. Land it can annex
4. Yesterday's results, including any rejected actions
5. The other mayors' public posts
6. Letters from its residents
7. The Gazette headline, open proposals and any player decree

The mayor replies in JSON. The README lists the fields as a private thought, a public post, a mood, up to seven actions, an ordinance proposal and votes. The allowed action types are road, zone, build, bulldoze, taxes, emergency, grant and annex.

As a sketch of that shape (field names here are illustrative, not copied from the repo):

{
  "thought": "private reasoning, visible to the player",
  "post": "public statement to the other mayors",
  "mood": "...",
  "actions": [{"type": "build", "...": "..."}],
  "proposal": "ordinance to propose",
  "votes": {"...": "yes"}
}

The simulation checks every action and rejects invalid ones with a reason. The mayor reads that reason the next day. The README notes that a game day waits up to 75 seconds for the mayors' calls. Every private thought is readable, so the player can see why a mayor acted, not only what it did.

The design lesson is that the model never changes game state directly. It proposes, the rules decide, and the model learns about its mistakes in the next prompt. A related pattern is covered in structured JSON output for small LLM game design.

Which parts are AI, and which are plain simulation?

The DEV post is direct about this: the AI only makes decisions, and a real simulation works out what happens next. The README lists the systems underneath:

• Zoning: residential, commercial and industrial demand with three density levels, driven by road access, power, water, land value and taxes.
• Utilities: a power network with load shedding (coal, solar, wind), water pumps, sewage capacity and garbage through landfills.
• Services: police, fire, hospital, school and parks, each with a coverage radius. Big projects include a stadium, train station, university and airport.
• Maps and money: traffic, pollution, crime, land value and happiness maps, plus per-district budgets and 10 citywide ordinances.
• Disasters: eight types, from fire and blackout to flood and tornado.

Two details make the simulation feel less scripted. Incidents don't end on a timer. A broken water main stays broken until residents with the right skills and paid city crews put in enough repair work. Builds also take time: about two days for a house, six for a tower, twelve for a stadium and fifteen for an airport, according to the post. The README adds that traffic, wages, sales tax and moods come from residents' daily choices rather than fixed formulas. That is the one place where LLM output feeds the economy directly, not just through mayor actions.

How it compares with Generative Agents

The obvious reference point is Generative Agents: Interactive Simulacra of Human Behavior by Park et al. That paper placed 25 agents in Smallville, a sandbox in the style of The Sims, where they plan their days, share news, form relationships and coordinate group activities while users observe and intervene. GridFall shares the observe-and-intervene setup. It differs in two ways. Its agents compete for land and budgets in a game economy, and their decisions are structured JSON that game rules accept or reject.

A caution: neither source reports outcomes. There are no figures on how often actions are rejected or how the districts diverge. The only concrete emergent moment shown is a Day 12 screenshot, captioned with a burst sewage main and each mayor responding in its own voice. Treat everything else as design intent.

What was the mirror roof fix, and what about the 'two other fixes'?

The DEV post's URL slug promises an explanation of why every roof was a mirror, plus two other fixes. The published post text has no section on roofs or layout. The title displayed on the page is different, and it describes the game as a whole.

The roof fix appears only in the README's rendering section. Per that section, model materials are tuned when they load. Roofs, brick, concrete, plaster, stone, wood and paving are set to matte because their source textures marked them as fully metallic, which made roofs reflect the sky. Sheet metal is set semi-matte, and glass and chrome keep a soft sheen.

Neither the DEV post nor the README describes the other two fixes, including any layout fix, so this post doesn't guess at them.

For Godot users, the takeaway from the README is simple. If you combine textures from several free sources, check the metallic values on imported PBR materials before you blame the lighting. This comes from the maker's notes and is not a verified procedure.

How do you run GridFall offline or live?

The DEV post gives these steps for Godot 4.7:

git clone https://github.com/KunalSiyag/gridfall.git
cd gridfall

# First run only: import models and textures (a few minutes)
godot --headless --path . --import

# Offline: recorded AI responses + heuristics, no API key
GRIDFALL_OFFLINE=1 godot --path .

The maker says he checked these steps on a fresh clone. To run the mayors live, set GMI_API_KEY and launch without GRIDFALL_OFFLINE. Live play depends on GMI Cloud, and neither source gives costs, so check pricing and model availability yourself. The README also documents GRIDFALL_RECORD, GRIDFALL_SPEED and GRIDFALL_RESIDENTS flags.

Every AI call falls back in this order:

1. A live model response
2. A replay cache of recorded responses (22 game days ship with the repo)
3. A hand-written heuristic for that role

The UI shows which of the three answered each call. The README notes a limitation: the replay cache predates wind farms, landfills and big projects. On replayed days, a mayor may borrow one of those builds from its heuristic planner. Offline mode is therefore recorded AI plus some scripted logic, not live AI.

On performance, the maker reports about 60 fps on an RTX 3050 laptop. Only claimed land is simulated each tick. The city starts at 32×32 tiles inside a 192×192 world, and mayors annex 16×16 plots that cost more each time.

Who should clone GridFall?

Based on the sources, GridFall is most useful to developers studying multi-agent LLM design in a game engine. It is a readable worked example of three patterns: structured JSON decisions, rule validation that feeds errors back to the agent, and a live/replay/heuristic fallback chain that keeps the game playable without a key. If you're wiring agents into Godot yourself, it pairs well with our godot-ai MCP server guide.

It is less useful if you want:

• Evidence that models play differently. No comparisons are published, and the roles are prompt labels.
• A deep city sim to play. It's a spectator project. Multi-city multiplayer, with each player bringing their own model and key, is only planned.
• Provider independence. The repo is built around GMI Cloud.

Also keep in mind that the code was written mostly by a coding agent, which may affect how easy it is to extend.

For a contrast on auditability, mech.app's write-up on 100 LLM agents running a town economy for 26 weeks reports 2.44 million agent decisions. That team chose event sourcing with validation both live and offline, partly to catch money being created or lost. GridFall's readable private thoughts and per-call source labels cover some of the same ground. Neither source says GridFall keeps a full event log.