Generative Agents,
explained.

Rungs 1 to 4 optimise task completion. This rung asks a different question — can a population of agents behave plausibly, as characters with histories, over days of simulated time — and the change of objective changes what the architecture must provide. A task agent can forget everything when the task ends. A character cannot, because consistency with its own past is the thing being evaluated.

So memory becomes the system. A memory stream records observations as natural-language entries, and the essential part is how retrieval scores them: by recency, importance and relevance together. Recency alone forgets what mattered; relevance alone surfaces the same few entries forever; and importance is scored by the model when the memory is written, so a proposal of marriage does not compete on equal footing with what was for breakfast.

Two mechanisms build on top of it, and both are about producing behaviour a log cannot. Reflection periodically reads recent memories and writes higher-level conclusions back into the stream — so the agent holds generalisations about people and itself, not only events, and those reflections can themselves be reflected on. And hierarchical planning decomposes a day into hours and hours into actions, with re-planning when something interrupts, which is what keeps behaviour coherent across a long horizon instead of locally sensible and globally aimless. What emerges from the combination is the reported result: information spreading between agents, coordination nobody scripted, relationships that persist.

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: removing reflection, then planning, then memory access each lowered believability in turn. 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.

Each of the 25 agents is the same architecture wrapped around gpt-3.5-turbo; GPT-4's API was invitation-only at the time. The town is a sandbox built with the Phaser game framework, and a server translates between game state and text.

1. Seed an identity. The authors wrote one paragraph per agent covering occupation and relationships, split into separate seed memories.
2. Record observations. At each step the agent perceives nearby agents, objects and its own actions, and each perception becomes a memory object holding a natural-language description, a creation time and a last-access time.
3. Rate importance once. When a memory is created the model rates its poignancy from 1, purely mundane like brushing teeth, to 10, like a breakup or a college acceptance. In the paper's example, cleaning up the room scores 2 and asking a crush out scores 8.
4. Retrieve by three scores. For the current query, each memory gets recency (exponential decay of 0.995 per sandbox hour since it was last retrieved), its importance, and relevance (cosine similarity between embeddings of the memory and the query). Each score is min–max scaled to the range 0 to 1, the three are added with equal weights, and the top memories that fit the context window go into the prompt.
5. Reflect when enough has happened. When the importance scores of recent events sum past 150, the agent reflects, which worked out to two or three times a game day. It takes its 100 most recent memories, asks for the 3 most salient high-level questions they can answer, retrieves memories, including earlier reflections, for each question, and asks for 5 high-level insights, each citing the numbered memories it rests on. The insights are stored as reflections with pointers to their evidence, so reflections on reflections form a tree.
6. Plan from the top down. The agent drafts its day in five to eight broad chunks from its summary description and a summary of the previous day, then recursively splits them into hour-long chunks and then into 5 to 15 minute actions. Plans are stored in the memory stream too, so they are retrieved like anything else.
7. React and talk. At every step the model is asked whether to continue the plan or react to what was just observed; a reaction regenerates the plan from that moment. Dialogue is generated turn by turn, each line conditioned on what the speaker remembers about the other person.
8. Ground actions in the map. The world is a tree of areas and objects, and each agent keeps its own partial copy that can go stale when it leaves an area. To place an action, the agent walks its tree from the root, asking the model for the most suitable area at each level. The model is also asked how the action changes the object, such as a cafe coffee machine going from off to brewing.

• h — sandbox hours since m was last retrieved, not since it was created, so a memory that keeps being used stays fresh.
• importance — the model's 1 to 10 poignancy rating, fixed when the memory is written.
• em, eq — embeddings of the memory text and of the query.
• α — the weights, all set to 1 in the paper's implementation.

The decay is slow: 0.995^^h halves after about 138 sandbox hours, close to six game days. Because each term is rescaled over the candidates, what counts is spread rather than absolute value: a term that is nearly equal across memories contributes almost nothing to the ranking, while the top candidate on any term always scores 1 on it. Set the relevance weight to zero and the agent retrieves the same few recent, important memories whatever it is asked; set the importance weight to zero and a breakup competes on equal terms with breakfast.

The controlled evaluation interviewed agents with 25 questions in five categories: self-knowledge, memory, plans, reactions and reflections. Each question was answered under five conditions, and 100 evaluators recruited online ranked the answers for believability. Ranks became TrueSkill ratings, tested with Kruskal-Wallis and Dunn post-hoc tests.

Each component removed lowered believability, and the full architecture beat the memoryless condition, which stands in for earlier LLM agents, by an effect size of 8.16 standard deviations. Every pairwise difference was significant except between the two worst conditions, crowdworkers and the memoryless baseline.

The two-day simulation was measured too. Knowledge of Sam's mayoral candidacy spread from one agent (4 percent) to eight (32 percent), and of Isabella's Valentine's party from one to thirteen (52 percent); none of the agents who claimed to know had hallucinated it. Network density rose from 0.167 to 0.74, and 6 of 453 answers about other agents (1.3 percent) were hallucinated. Five of the twelve invitees came to the party; of the seven who did not, three cited conflicts and four had said they were interested but made no plan to go.

The failures are specific. As memories accumulated, agents chose odder places, such as lunch at the bar once they learned it existed. Norms not written into the world description were broken: agents entered a one-person dorm bathroom that was occupied, and shops after their 5 pm closing. Instruction tuning made agents formal and agreeable, and Isabella rarely said no to party ideas that did not fit her. Agents also embellished, as when Yuriko described her neighbor Adam Smith as the author of Wealth of Nations. The whole run cost thousands of dollars in token credits.

The cost is acknowledged and is the main barrier: every agent's every step is model calls, and reflection and planning add more, so a couple of dozen agents for a few simulated days is a serious bill. Nothing about the design is cheap, and scaling the population scales the cost linearly at best.

The evaluation is believability judged by human raters, which is the honest measure for the objective and a soft one — there is no ground truth for what a character should do next, so results cannot be compared the way a benchmark score can. The paper is straightforward that the emergent social behaviours were measured in a single two-day run of 25 agents, which is an existence demonstration rather than a controlled effect, and the popular retelling of them was considerably less careful.

Reflection can also compound error: a generalisation inferred from a misunderstanding becomes a durable belief that colours every later retrieval, with nothing to correct it.

How it held up: the memory-stream-plus-scored-retrieval design is the standard answer to agent memory, and the three-way scoring is copied directly in systems that have nothing to do with simulated towns. Reflection as a distinct write-back step — the agent generating summaries of itself — is the other idea that spread. Rung 6 takes issue with one thing here: that the memory is managed for the agent by a retrieval policy someone else chose.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

Give the model a tool, then a loop, then a memory, then a world. Ends on the 2026 paper measuring how badly the whole stack degrades over many turns.

1. 1ReAct2023
2. 2Toolformer2023
3. 3Reflexion2023
4. 4Voyager2023
5. 5Generative Agents2023
6. 6MemGPT2023
7. 7LLMs Get Lost in Multi-Turn Conversation2026

All 110 papers, in 19 ladders →