Generative Agents and Emergent Simulation

Most multi-agent systems are tightly scripted teams: the planner plans, the coder codes, the reviewer reviews. That works for well-defined tasks. It does not produce the unscripted behavior you get when agents have memory, priorities, and an open world. Research, society simulation, and increasingly game AI need that second kind.

Smallville is the benchmark for it. Before Park 2023, the best agent simulations were shallow script-followers. After it, the pattern became the default for generative agents in open worlds. If you build an agent simulation in 2026, you are either using Smallville's three components or you need to justify why you are not.

The three components

Memory stream. An append-only log of observations, actions, reflections, and plans. Each entry has a timestamp, a type, a description in natural language, and derived metadata: recency, importance (self-rated 1-10 by the agent), and relevance (cosine similarity to the current query).

[2026-02-14 09:12:03] observation: Isabella Rodriguez asked me if I like jazz
[2026-02-14 09:14:22] reflection:   I enjoy long conversations about music
[2026-02-14 10:05:00] plan:         Attend Isabella's Valentine's Day party tonight

Retrieval combines the three scores: score = w_recency * e^(-decay * age) + w_importance * importance + w_relevance * cos_sim. The top-k entries go into the current prompt.

Reflection. Every N memories, or on an important event, the agent generates higher-order syntheses from its recent memories. Reflection entries go back into the stream and are retrievable like any other memory. This is how agents build "understandings", the architecture's version of long-term beliefs.

Plan. Top-down decomposition. First a day-level plan in broad strokes ("go to work, have dinner with Klaus"), then hour-level plans, then action-level plans. Plans are revisable: when an observation contradicts a plan, the agent replans the affected segment.

Why all three matter (ablation)

Park et al. ran ablations that dropped observation, reflection, and plan in turn. Each ablation hurts believability:

• Without observation the agent misses context and acts on stale beliefs.
• Without reflection the agent cannot form higher-order beliefs, so interactions stay shallow.
• Without plan behavior becomes reactive noise and goals dissipate.

Human raters score believability highest with all three present, and dropping any one produces a measurable regression.

The Valentine's Day emergence

One agent, Isabella Rodriguez, is seeded with the goal "wants to throw a Valentine's Day party at Hobbs Cafe on Feb 14 at 5pm." The 24 other agents receive no such seed. Over simulated days:

1. Isabella's plan includes inviting people.
2. Each invitation becomes an observation in a neighbor's memory stream.
3. That neighbor's reflection generates beliefs: "Isabella is throwing a party."
4. The neighbor's plan incorporates "attend party on Feb 14."
5. Neighbors tell other neighbors. The invitation spreads without central coordination.
6. At 5pm on Feb 14, several agents converge at Hobbs Cafe.

This is emergence in the technical sense. System-level behavior (a party) came out of local interactions (bilateral invitations plus individual planning) with no central orchestrator.

The documented failure modes

Park et al. explicitly document three:

• Spatial norm errors. Agents walk into closed stores, try to use the same single-person bathroom, and eat in rooms not meant for eating. The model does not infer social-physical norms from the environment alone.
• Memory overflow. In deep simulation runs, the cost of memory retrieval grows. The practical remedy is periodic memory compaction (summarize and prune) plus decay on low-importance entries.
• Reflection hallucination. Reflections can invent relationships that are not in the memory stream. Mitigate by including source memory ids in reflection prompts and verifying them at retrieval time.

These show up in production, so any 2026 agent simulation inherits them.

Three-component implementation rules

1. Memory is append-only. Don't mutate a memory entry. Corrections are new entries.
2. Importance scores are cheap. Call the LLM to rate importance 1-10 at write time and cache the score.
3. Retrieval is ranked, not filtered. Take the top-k by combined score. Hard filters lose context.
4. Reflection runs periodically. Trigger it when the sum of importance of unprocessed memories exceeds a threshold (e.g., 150).
5. Plans are revisable. When a new observation contradicts a plan, regenerate the affected segment only, not the whole plan.

Generative agents beyond Smallville

The 2024-2026 follow-up literature extends the architecture:

• Multi-agent social simulation for policy and market research. Smallville-like populations simulate user behavior in response to features. It is faster than an A/B test, though the accuracy is contested.
• NPC AI for games. RPGs built on Smallville agents produce emergent storylines instead of scripted quests.
• Generative-agent evaluation benchmarks. The metric stops being task accuracy and becomes believability and coherence of behavior over long runs.

The architecture is the reference. Extensions swap components (a vector store for memory, retrieval-augmented reflection, a neurosymbolic plan) but keep the three-part structure.

Why this matters for multi-agent engineering

Smallville is the proof of concept that multi-agent emergence is cheap when the components are right. The architecture has since been replicated on open-source models, and smaller LLMs lose believability gracefully rather than sharply. A production system that needs emergent social behavior takes this shape. A system that needs tight task execution should use the supervisor, roles, and primitives patterns from earlier in this phase.

code/main.py implements the three components in stdlib Python with scripted agent policies and no real LLM. It reproduces the Valentine's-party emergence in miniature:

• Memory and Agent.stream: an append-only list of observations, reflections, and goals, each with a timestamp and an importance score.
• retrieve_top_k(stream, query, tick, k): ranks memories by recency, importance, and relevance. Relevance here is keyword overlap, not embedding similarity.
• Agent.reflect(tick): scripted reflection over recent high-importance memories.
• Agent.update_plan(tick): adds a plan to attend the party once the agent holds the matching belief.
• Scenario: 5 agents over 6 ticks. Agent 0 starts with a goal to host a party at tick 5. Invitations spread on a fixed schedule, and the agents converge.

Run:

python3 code/main.py

Expected output: a tick-by-tick trace, then final locations, then a small retrieval demo. In the default run all 5 agents move to HobbsCafe at tick 5. One seed produced the coordinated arrival without any orchestrator.

outputs/skill-simulation-designer.md designs a generative-agent simulation. It covers the number of agents, memory schema, reflection cadence, plan horizon, and evaluation metric.

Rules for production simulations:

• Memory is the database. Pick a real store (vector DB, Postgres) at scale. In-memory stdlib is for prototypes.
• Log the retrieval trace. For each action, log the top-k memories that drove it. This is how you debug.
• Budget per-agent tokens. An agent's retrieve, reflect, and plan steps cost O(k) LLM calls per tick. N agents × T ticks × calls per tick can dwarf your budget.
• Compact memory periodically. Summarize and prune low-importance entries. Retention policy is a design decision, not a detail.
• Detect spatial and social norm violations explicitly. The architecture does not learn them.

1. Run code/main.py. Confirm 3+ agents converge at the party. Increase agents to 10. Does the emergence still happen?
2. Remove the reflection step. What does behavior look like? Map to the ablation finding in Park 2023.
3. Introduce a competing seeded goal ("Klaus wants to give a research talk at 5pm"). Do agents split, or does one goal dominate? What determines it?
4. Add spatial constraints: Hobbs Cafe holds at most 4 agents. Does the simulation handle overflow gracefully, or does it hit the "single-person bathroom" failure pattern?
5. Read Park et al. (arXiv:2304.03442) Section 6 (emergent behavior experiments). Identify one behavior not reproducible in your miniature. What component of the architecture would you need to enhance?

• Park et al., Generative Agents: Interactive Simulacra of Human Behavior: the reference architecture.
• UIST '23 paper page: publication venue.
• Smallville code release: reference Python implementation.
• Hayes-Roth 1985, A Blackboard Architecture for Control: prior art for structured-memory agents.