Simulations that think: from the Game of Life to AI agent societies

Some simulations are machines for producing a known answer: a physics step, a damage formula, a trajectory. Others are machines for producing answers nobody knew in advance. The second kind is what this piece calls a simulation that thinks. It does not think in the human sense. But it makes decisions, local ones, many times over, and the interesting results come from the combination rather than from any single rule. The lineage runs from a grid of cells on graph paper in 1970 to towns of language-model agents throwing each other parties, and for anyone designing games with AI agents, that lineage is the history worth knowing. The design questions have barely changed along the way: what rules to write, what to leave to the system, how much it costs to run, and how to tell whether the result is any good?

From cells to agents

Rules on a grid: cellular automata

Cellular automata go back to the 1940s, when John von Neumann, following a suggestion from Stanislaw Ulam, used a lattice of cells to study machines that could reproduce themselves. The idea reached a wide audience in October 1970, when Martin Gardner’s Mathematical Games column in Scientific American described John Conway’s “Life”.

The rules of Life fit in two lines. On an infinite grid, each cell is alive or dead and has eight neighbours. A dead cell with exactly three live neighbours becomes alive; a live cell with two or three live neighbours survives; everything else dies or stays dead. That is the whole system:

// One generation of Conway's Life on a wrapping grid
function step(grid, w, h) {
  const next = new Uint8Array(w * h);
  for (let y = 0; y < h; y++) {
    for (let x = 0; x < w; x++) {
      let n = 0;
      for (let dy = -1; dy <= 1; dy++) {
        for (let dx = -1; dx <= 1; dx++) {
          if (dx === 0 && dy === 0) continue;
          n += grid[((y + dy + h) % h) * w + ((x + dx + w) % w)];
        }
      }
      const alive = grid[y * w + x] === 1;
      next[y * w + x] = (alive && (n === 2 || n === 3)) || (!alive && n === 3) ? 1 : 0;
    }
  }
  return next;
}

From that come gliders that travel across the grid, guns that emit gliders forever (Bill Gosper found the first in 1970), and eventually constructions that compute: Life is Turing-complete. Even simpler one-dimensional automata share the property. Stephen Wolfram conjectured in 1985 that the elementary automaton known as Rule 110 was universal, and Matthew Cook proved it.

The lesson for AI game designers is not that grids are clever. It is that the complexity of the output is not bounded by the complexity of the rules. Simple local rules, iterated, can produce behaviour you cannot predict without running them. That is both the promise of every emergent simulation and the reason they are hard to design.

Agents with intent: from Schelling to boids

Cellular automata have no individuals, only cells. Agent-based models add entities that move, sense and choose.

Thomas Schelling’s segregation model (1971) is the classic demonstration. Two kinds of agent on a grid each move if too few of their neighbours share their type. Even when every individual is content to be in a mixed neighbourhood, mild preferences produce strongly separated patterns at the level of the whole grid. Nobody wanted the outcome; everybody produced it.

Craig Reynolds’ boids (SIGGRAPH 1987) did the same for motion. Each simulated bird follows three steering rules, separation, alignment and cohesion, using only its nearby flockmates, and the result is convincing flocking with no leader and no global plan. Boids are still the basis of crowd, flock and swarm behaviour in games.

Joshua Epstein and Robert Axtell’s Sugarscape, published in Growing Artificial Societies (1996), pushed the idea towards whole societies: agents with metabolism and vision gathering sugar on a grid, and later trading, reproducing, fighting and passing on cultural traits. Their argument was that to explain a social pattern, you should be able to grow it from the bottom up.

These models share a structure that anyone building LLM agents will recognise: a world, agents with a small set of needs and senses, a rule for choosing what to do, and a clock. Everything after this, language-model agents included, is a richer version of the same loop.

The games lineage: SimCity, The Sims and their heirs

Will Wright’s SimCity (1989) came, by his own account, from enjoying the map editor of his earlier game Raid on Bungeling Bay more than the game itself, and from reading urban systems theory, especially Jay Forrester’s work. The city is a grid of cells carrying values such as land value, pollution, crime and traffic, which spread to and influence their neighbours, close in spirit to a cellular automaton with an economy attached. The player does not control citizens; they shape conditions and watch the city respond.

The Sims (2000) moved the simulation inside the house and onto individuals. Wright cited Christopher Alexander’s A Pattern Language as a primary inspiration. Each Sim has needs such as hunger, energy, hygiene, social and fun, and the intelligence largely lives in the objects: a fridge advertises that it can satisfy hunger, a sofa that it can restore comfort, and the Sim picks among the advertisements according to its current needs. It is a utility system, cheap and tunable, and it produces daily routines and small domestic disasters that nobody scripted.

From there the line runs through Dwarf Fortress (first released by Tarn and Zach Adams in 2006, with a Steam edition in 2022) and RimWorld, where the simulation has become dense enough that players retell its output as stories. RimWorld adds an important twist: an AI storyteller that watches the colony and chooses when to inject events, which turns pacing from an accident into a system.

Era	Example	Unit of thought	What emerges
Cellular automata	Conway’s Life (1970)	A cell’s next state from its neighbours	Patterns, motion, computation
Agent-based models	Schelling (1971), Sugarscape (1996)	An agent choosing a move by a rule	Segregation, markets, inequality
Systemic sims	SimCity (1989)	A cell’s values diffusing through a grid	Traffic, sprawl, decline
Needs-driven agents	The Sims (2000)	Utility choice among advertised actions	Routines, comedy, domestic drama
Deep simulations	Dwarf Fortress, RimWorld	Many interacting systems per agent	Retellable stories
LLM agents	Generative Agents (2023), Project Sid (2024)	A language model reasoning over memories	Plans, conversation, social coordination

LLM-driven societies

The newest step replaces the utility function with a language model. In Park et al.’s Generative Agents (2023), 25 agents in a small town remember, reflect and plan in natural language, and a single seeded intention to throw a Valentine’s Day party spread through the population until several agents turned up at the right time and place. Altera’s Project Sid (2024) scaled the idea to between 10 and more than 1,000 agents in Minecraft, reporting that agents developed specialised roles, followed and changed collective rules, and passed on cultural and religious ideas.

What the language model adds is not more complexity of outcome. Life already had unbounded complexity. It adds interpretation and open-ended action. A Sim chooses from a fixed menu of object advertisements; an LLM agent can propose an action nobody listed, reason about why another agent behaved as it did, and explain its own behaviour in words. That makes the simulation legible in a way earlier systems never were, and it also makes it much harder to keep inside its bounds. The architecture of a single agent, with memory, retrieval and grounding, is covered in AI-driven NPCs: LLM agents and the future of living simulations.

Emergence versus authored story

Every simulation designer eventually hits the same tension, and LLM agents make it sharper. Authored stories are shaped: they have rising action, timing and payoff. Emergent stories are surprising and personal, but most of what a simulation produces is not a story at all. It is weather.

Three things make emergent output feel like narrative:

• Pressure. Agents need goals that conflict and resources that run short. Without scarcity, a simulation settles into equilibrium, which is the least interesting state there is.
• Memory. Consequences have to persist. A grudge that is forgotten by the next day produces events, not stories.
• Interpretation. Players naturally read intent into patterns. Designers can help by surfacing causes: a log entry, a mood reason, or with LLM agents, a character explaining herself.

The practical middle ground is a director: a layer that watches the simulation and nudges it when it stagnates or spirals. RimWorld’s storyteller is the well-known example. With LLMs the director can itself be a model, but it is better kept rule-based, with models only colouring what it chooses. A director that improvises is a second source of unpredictability on top of the first.

Running cost and level of detail

A cellular automaton costs a few operations per cell per tick. A utility agent costs a handful of comparisons. An LLM agent decision costs a model call, which is many orders of magnitude more in compute and often hundreds of milliseconds or more in latency. That changes how you build.

The answer is the same level of detail that rendering has always used, applied to thought:

Tier	Where	Mind	Update rate
Foreground	Near the player, in conversation	LLM for dialogue and replanning, utility AI for movement	Every decision point
Midground	Same region, out of focus	Utility AI or behaviour tree, occasional LLM summary	Seconds to minutes
Background	Elsewhere in the world	Statistical rolls and aggregate state	Once per in-game day

When an agent moves up a tier, its aggregate history is turned into a short summary it can remember; when it moves down, its recent memories are compressed into state. The model is called at moments of meaning, such as a conversation, a goal finished or failed, or a significant event, never every tick. Most of the time a thinking simulation should be a fast, ordinary one with a slow, expensive layer that wakes up when it matters.

How to evaluate an emergent sim

There is no expected output to test against, so you test properties of the system instead. These are the questions to ask:

1. Does it vary? Run many seeds headlessly and compare outcomes. If every run converges on the same state, the simulation has a dominant attractor and the player will find it.
2. Is it sensitive in the right places? Small player actions should sometimes have large consequences. If nothing the player does changes the macro outcome, the sim is scenery.
3. Is it legible? Can a player, or a tester, explain why something happened? Surprise without a traceable cause feels like randomness.
4. Does it hold its invariants? Economies should not create value from nothing; key characters should remain reachable; no agent should act outside its legal actions. Check these continuously.
5. How dense are the stories? Count events a playtester would bother to retell per hour of play. It is subjective, but tracking it from build to build is informative.
6. What does it cost? Model calls and tokens per agent per in-game hour are performance budgets, like frame time.

Record everything, including every model response, so any interesting or broken run can be replayed exactly.

Text games as the simplest thinking simulation

If you want to build an AI-driven simulation of your own, don’t start in 3D. The simplest thinking simulation is a text-based generative game: a small world state held as structured data, a few agents with needs and memories, and a language model narrating what happens and voicing the characters. AI Dungeon, first released in 2019, showed how far people will go with a world made only of generated prose; what it had little of, in its early form, was persistent state underneath, so the world tended to forget itself.

Put the state back and you have the full architecture in miniature. The simulation decides what is true; agents choose from legal actions; the model turns that into language. Everything is inspectable, cheap to run and easy to replay. Generated audio can voice it next, and generated imagery or video can eventually show it, but those are presentation layers. The thinking, such as it is, happens in the loop of state, choice and consequence that Conway’s grid already had in 1970.

Takeaways

• Output complexity is not bounded by rule complexity: Life and Rule 110 show simple local rules can be computationally universal.
• Agent-based models from Schelling to Sugarscape show macro patterns that no individual intended; games, and now LLM agents, inherited this loop of world, needs, choice and clock.
• SimCity simulated conditions on a grid; The Sims put utility-driven needs into individuals with intelligence stored in objects.
• LLM agents add interpretation and open-ended action, which makes emergence legible and control harder.
• Emergent stories need pressure, memory and interpretation; a rule-based director can supply pacing.
• Apply level of detail to thought: LLM calls at moments of meaning near the player, cheap systems elsewhere.
• Evaluate emergent sims on variety, sensitivity, legibility, invariants, story density and cost, with full replay.
• A text-based generative game over hard world state is the simplest, cheapest place to build a thinking simulation.