Concordia — Generative Agent-Based Modeling with a Game Master

TL;DR

Why it matters. Classical agent-based models (ABMs) reach scale by stripping agents down to a few hand-coded rules. Concordia proposes a way to keep the rich, language-mediated behavior of LLM agents while still grounding the simulation in concrete variables — money, votes, possessions — that the modeller controls.
What it proposes. A library for Generative Agent-Based Models (GABMs) built around two primitives: generative agents assembled from modular components, and a Game Master (GM) — borrowed from tabletop role-playing games — that turns free-text action attempts into grounded event statements.
Headline result. Read this as a framework-and-position paper. Its contribution is an architecture (agent ⇄ GM loop), a set of worked examples (a town election, a small business, a property dispute, a smartphone simulation), and an explicit epistemics for validating such models.
Limit. Validation is the open problem the paper names but cannot solve: train–test contamination, LLM stereotyping of human groups, and the absence of an agreed standard for when in-silico results generalize to real life.
What to keep. The reframing is the payload. Concordia agents act by answering “what does a person such as I do in a situation such as this?” — a logic of appropriateness in place of a logic of consequence. Neither reinforcement learners nor utility maximizers, they open up a different set of modelling questions.

Background

Agent-based modeling has been a workhorse of the social and natural sciences for decades, but historically at an abstract level: agents are a handful of state variables updated by hand-coded rules, and the interesting behavior is whatever emerges from many of them interacting. The cost of that tractability is realism — behavioral-economics findings about how people actually decide are rarely integrated with institutional or resource-economic structure in the same model, because encoding both in rules is brittle and laborious.

Large language models change the affordance. An LLM agent can apply common sense, recall semantic knowledge, reason and plan (imperfectly), role-play a specified sub-population, and — crucially — communicate with other agents in natural language. Park et al.’s Generative Agents (2023) demonstrated the appeal with a 25-agent Smallville. The question Concordia takes up is the engineering one underneath. What is the minimal, reusable structure that lets you build any such simulation instead of hand-rolling each world from scratch? The structure has to ground the simulation in a concrete environment and expose variables you can intervene on.

Concordia comes from the Google DeepMind / Google Research group later associated with the scale-oriented social simulators. It is deliberately not opinionated about what you simulate; it is opinionated about how the agent and the environment are factored.

Core Idea

The Concordia loop: two agents (Dorothy, Charlie) each emit an action attempt; the Game Master consumes the action attempts and emits event statements that update grounded variables and become observations fed back to the agents — **Fig. 1.**The high-level Concordia loop. Generative agents consume observations and produce action attempts in natural language. The Game Master consumes those attempts, decides what actually happens, writes an event statement (the canonical 'fact of the world'), updates grounded variables, and emits the resulting observations back to the agents.Source: Vezhnevets et al. 2023, Fig. 1

A GABM, like any ABM, has two halves: a model of the environment and a model of individual behavior. In Concordia both are generative. The environment half is the Game Master, a name and role taken directly from Dungeons & Dragons, where one player narrates and adjudicates a world the others act within. Agents do not act on the world directly — they describe what they intend to do (“Alice makes breakfast”), and the GM decides the outcome, writes an event statement describing what actually happened, updates the world state, and sends observations back.

The GM’s most important job is grounding. Each experiment declares a set of grounded variables: money in an economic sim, votes in an election sim, the stock of a fishery in a commons sim. The GM tracks them, decides how events change them, and rejects actions that violate them. You cannot pay more than you have. This is what keeps a language simulation from drifting into pure narrative: the non-linguistic mechanics can be implemented with any classical tool (ODEs, finite-state machines, graphical models) inside GM components.

The agent half rests on a hypothesis from March and Olsen (2011): people act as if answering three questions — What kind of situation is this? What kind of person am I? What does a person such as I do in a situation such as this? The claim is that an LLM trained on human culture can answer these acceptably when given an agent’s context, and therefore can stand in for a human of a specified type.

Method

Generative agents as a society of components

An agent's working memory assembled from components: an Identity block, a Plan block, an Observation block, and a Call-for-action question, concatenated into the context that conditions one LLM call producing the next action — **Fig. 2.**An agent's working memory z, assembled from components. Identity (with sub-components for core characteristics, occupation, and feelings), Plan, Observation-and-clock, and a final Call-for-action question are concatenated into the context that conditions a single LLM call. The output is the agent's next action attempt.Source: Vezhnevets et al. 2023, Fig. 2

A Concordia agent has a long-term associative memory (the same retrieval architecture as Park et al. 2023 — a growing set of remembered strings) and a working memory $\mathbf{z} = \{z^{[i]}\}_i$ assembled from components. Each component holds a natural-language statement of one aspect of the agent or its situation — identity, current plan, hunger, financial state — and updates that statement by querying memory and calling the LLM. The set of components is the agent’s “society of mind”: you add the ones your simulation needs (possessions for an economic agent, thirst and stress for a physiological one).

Formally the agent is a two-step sampling process. In the action step it samples an activity $a_t$ from a context built by a formatting function $f^{[a]}$ over the component states $\mathbf{z}_t$ (in the simplest case, concatenation). In the update step each component re-derives its state from the memory stream $\mathbf{m}_t$ — into which incoming observations have already been folded ( $\mathbf{m}_t = \mathbf{m}_{t-1} \cup \mathbf{o}_t$ ). The elegant consequence is that an agent and a component are the same kind of object: an agent is “just” a component whose output the GM interprets as an action. Components can update at different cadences, and their internal logic can be ordinary code, not only LLM calls.

The Game Master, symmetrically

The GM is implemented like an agent, but its components describe the state of the world rather than the disposition of one actor: where players are, the value of grounded variables, what items exist. Each agent action puts four questions to it. What is the state of the world? What event results? What does each player observe? What changes in the grounded variables? It then emits an event statement $e_t$ , adds it to its own memory, and issues per-player observations. A player who would not have perceived the event receives none. Because GM components can wrap any existing model, known physical, chemical, or financial dynamics can be imported wholesale.

Digital grounding and nested games

Concordia extends the same machinery to digital environments. A PhoneTriggeringComponent detects when an agent reaches for a simulated phone and spawns a nested PhoneGameMaster that runs for the duration of the interaction, scoped to that one agent. A PhoneUniverse translates the agent’s free-text intent (“Alice creates a meeting with Bob”) into structured calls against app state (Calendar, Chat, Navigation). Because the abstraction is “free text in, structured action out,” the digital layer can range from a mock-up all the way to real API calls against live services — which is what makes Concordia usable for synthetic user studies and sandbox evaluation of unreleased products, not only academic social science.

Interpretation: agency without optimization

The paper spends an unusual amount of space arguing what its agents are not, and this is the part most worth carrying away. A Concordia agent is not a reinforcement learner: there is no reward signal, no policy improved by gradient descent. To change its behavior you change its social context: the components describing who it is and where it stands. There is no scalar objective to turn. (The authors note an LLM could be made to run policy iteration in-context; that would be an add-on layered above the mechanism.)

Nor is it a rational utility maximizer. It shares with Homo economicus the property of being prospective, but the resemblance is misleading: the LLM’s basic operation is predicting the next token in the description of the situation, and it never simulates future trajectories in search of the highest payoff. There is no utility function under the hood. Agents can be made to look rational by prompting them to play economists, which produces role-play with the shape of optimization.

The positive framing is March and Olsen’s logic of appropriateness as opposed to the logic of consequence. This is also why Concordia is a natural home for theories of social construction: situations, roles, and institutions are “talked into existence,” causal influence runs both from agents to structures and back, and valuation itself is socially constructed — questions that are awkward to even pose in a payoff-matrix framework, because GABM never requires you to specify payoffs at the outset.

Validation: the honest hard part

Because a GABM’s results are only useful if they say something about real life, the paper foregrounds a hierarchy of evidence (borrowed from evidence-based medicine) and a set of best practices rather than a benchmark score:

Rung	Evidence for a GABM	Strength
Generalization	Direct measurement against new real-world data the model could not have seen	Gold standard
Algorithmic fidelity	Does conditioning on a sociodemographic backstory reproduce that group’s responses? (Argyle et al. 2023) — must be re-measured per question	Strong, scoped
Model comparison	”Model A is more trustworthy than B” is far easier to support than absolute trust	Relative
Robustness	Sensitivity analysis over prompt wording and irrelevant details	Necessary, not sufficient
Consistency with theory	Do model outputs match, e.g., downward-sloping demand curves?	Weakest rung

The guiding slogan is parsimony: make the minimal number of maximally general modeling choices, because complex models are brittle and brittle models fail to generalize. None of this resolves the open problems. Train–test contamination is the first: an LLM has “read” every paper on the Prisoner’s Dilemma. The second is the risk of studying stereotypes of groups rather than their lived experience. The third is what happens “in the limit of detail,” when the target is one specific individual.

Limitations

The paper is candid that validation is unsettled and largely a community problem rather than something any one architecture can fix. Three issues are specific to LLM-based ABMs. Contamination: results on any canonical task may reflect the LLM having memorized the literature, so scenarios must often be disguised. Stereotyping: LLMs likely represent stereotypes of human groups, a problem that worsens for minority populations and can silently substitute caricature for behavior. Algorithmic fidelity is non-uniform: any given LLM models some people better than others, so fidelity must be re-established for each research question rather than assumed once. And the whole enterprise inherits the standard ABM caveat — a model that shows “A causes B in the model” is a hypothesis about the world, not a measurement of it.

Sapiens Q Take

Three things we would take into simulation work. First, Concordia reads as the substrate beneath the simulators covered earlier in this series. OASIS (one million agents) and AgentSociety (high-fidelity 10,000-agent worlds) sit at the two ends of a scale–fidelity tradeoff; Concordia is the design pattern — agent components plus a grounding Game Master — that either end instantiates. If you have read those posts, this is the engineering grammar underneath them, and the CAMEL “AI User / AI Assistant” protocol is the same loop with the population set to two. Second, the “logic of appropriateness” stance is a practical design heuristic, not only philosophy. When you want an agent to behave differently, the Concordia move is to edit its context rather than define a reward. Context here means who the agent is, where it stands, and what it just observed. That is exactly why component-based agent design composes so well, and why prompt-as-policy systems are so sensitive to wording. Third, the grounded-variable discipline is the transferable safety rail. The single most common failure of free-text agent simulations is narrative drift: agents hallucinate money, items, or characters into existence. Concordia’s answer reuses cleanly in any LLM-agent system: declare the few variables that must stay consistent, and give a Game Master veto power over actions that violate them. The paper’s location system teaches the same lesson from the other direction, since it was added only after agents hallucinated their surroundings without it. The honest takeaway is the validation chapter: treat any GABM result as a hypothesis with an explicit evidence rung attached, and say which rung.

References

Original paper: Generative agent-based modeling with actions grounded in physical, social, or digital space using Concordia
Code: google-deepmind/concordia
Generative Agents (small-scale predecessor): Park et al. (2023), arXiv:2304.03442
OASIS (scale end of the tradeoff): Yang et al. (2024), arXiv:2411.11581 — covered earlier in this series
AgentSociety (fidelity end): Piao et al. (2025), arXiv:2502.08691
CAMEL (two-agent role-play): Li et al. (2023), arXiv:2303.17760
Logic of appropriateness: March and Olsen (2011); algorithmic fidelity: Argyle et al. (2023), arXiv:2209.06899