Generative Agents,
explained.

An LLM can play a barista for ten minutes. But a believable character has to remember Tuesday's conversation on Friday, hold opinions that build over weeks, keep a daily routine, and react when life interrupts it — all far beyond what fits in a context window. Stuff the raw history in and it overflows; summarize it and the texture of a life vanishes.

The authors' framing predates the agents boom and still cuts deepest: believability isn't a model property, it's an architecture property. The paper's three mechanisms — memory, reflection, planning — are the minimum machinery of a persistent self.

Everything an agent perceives becomes a timestamped natural-language record in its memory stream: "Isabella is decorating the café," "Klaus said he's researching gentrification," "the stove is on fire." Thousands of entries accumulate — a complete experiential log, none of it in context by default.

The stream is deliberately raw and complete. No premature summarization, no discarding — because the architecture's other two mechanisms (retrieval and reflection) decide later what matters. Storage is cheap; judgment is deferred to the moment it's needed.

At each decision, the agent pulls the handful of memories that should shape it, scored by a weighted sum of three signals:

The importance score is the quietly brilliant one: at write time, the LLM rates how notable the event is ("ate breakfast" = 1, "broke up with partner" = 9), so momentous memories keep surfacing months later while noise sinks. The triple — recency, importance, relevance — has since become the standard scoring recipe in agent memory systems.

Concretely, each memory's retrieval score is just the sum of the three normalized signals:

Because importance is fixed high for big events, a 3-day-old breakup still outscores this morning's breakfast — while a query about someone's work pulls the relevant memory to the top. The runnable version below shows exactly that flip.

Raw observations alone make a diarist, not a person. Periodically — when recent importance accumulates past a threshold — the agent reflects: it asks itself the most salient questions about its recent experience, answers them, and writes the conclusions back as new memories citing their evidence.

Reflections cite reflections, building a tree of abstractions — the agent literally develops opinions about itself and others that no single observation contains. When Klaus is asked who he'd like at a dinner party, the answer comes from this tree, not from replaying a thousand café scenes.

Coherent days need intent. Each agent drafts a day plan in broad strokes ("morning: open the café"), recursively decomposes it into hour- and minute-level actions, and stores the plan in the memory stream — where it competes with everything else. When the world interrupts (a burning stove, an unexpected conversation), the agent reacts, then re-plans the rest of the day around what just happened.

Seed one intention — Isabella wants to host a Valentine's party — and let the simulation run. Over two days: Isabella invites customers; invitees remember and tell others; Maria asks Klaus on a date to the party; five agents arrive at the café at 5pm on the right day. Information diffusion, relationship formation, and coordination — none of it scripted.

The ablations are the scientific spine: remove any one mechanism and believability measurably degrades. Memory, reflection and planning aren't features — they're load-bearing.

Smallville handed the field its memory architecture. The stream + scored retrieval + periodic reflection pattern runs, in some dress, inside most persistent assistants and agent frameworks today — and MemGPT systematized the storage side of the same problem months later. The importance-scored, self-reflecting memory is this paper's fingerprint on production systems.

It also opened the social simulation frontier: populations of agents as laboratories for studying information spread, coordination, and collective behavior — and as the engine behind character-driven games and worlds. And it left a warning the authors made explicitly: agents this believable invite parasocial attachment and manipulation. The more lifelike the simulacrum, the more the guardrails matter.

The "Smallville" paper (25 agents living in a simulated town) is best known for its memory architecture, which became a template for believable long-running agents. Each agent keeps a memory stream of observations, then does three things a raw context window can't: retrieves relevant memories by a mix of recency, importance, and relevance; reflects to synthesize higher-level insights from raw observations; and plans its day from those reflections.

Retrieval scoring is the practical heart of it. Not everything in memory is equally useful at a given moment, so the agent ranks memories by how recent, how important, and how relevant to the current situation they are — and pulls the top ones into context. That three-factor score is a widely-copied recipe for deciding what an agent should "remember" right now.

Reflection is what kept the agents coherent over long runs. Periodically the agent asks itself what its recent observations imply ("I keep running into Sam about the election — I care about it"), stores those conclusions as new memories, and reasons over them later. Without reflection, an agent drowns in raw logs; with it, it builds a compressed, higher-level self-model — an idea now common in agents that summarize their own history.

The demonstration itself — agents forming relationships, spreading information, and coordinating a party with no scripting — showed emergent social behavior from the memory-reflect-plan loop alone. The lasting influence is architectural: the recency/importance/relevance retrieval and the reflection step are directly echoed in how today's long-running assistants and multi-agent systems manage memory and stay coherent across time.