Generative Agents Behavior Simulator
A notebook-based, locally runnable simulation of human-like behavior in a D&D town setting.
What does this agent do, and when should you use it?
This is a working implementation of the kind of model described in Generative Agents: Interactive Simulacra of Human Behavior. It is distributed as notebooks that can run locally or on Google Colab, with JupyterLab recommended for local use. The stable model is in notebook/Release, work-in-progress models with newer features are in notebook/WIP, and a WIP library is under game_simulation. The current model simulates Phandalin, the town from an introductory D&D 5e adventure, using a setting described as more free-form than the paper's simple scenario. It uses lower-parameter, locally runnable models to address the cost of high-quality instruction models and many long-context queries, while noting that future instruction-tuned models are expected to perform better.
A user selects a notebook from notebook/Release or notebook/WIP and runs it locally or in Google Colab. The model runs a simulation of the town of Phandalin, aiming to model the kind of human-like behavior described by the paper. A WIP library is also available under game_simulation. The supplied material does not identify notebook filenames, inputs, prompts, model calls, cell order, or output artifacts, so those end-to-end details cannot be verified.
- A researcher with local GPU hardware who wants to run an implementation related to the model type described in the Generative Agents paper.
- An experimenter who wants to try the notebooks in Google Colab instead of deploying a service.
- A prototype developer studying simulated behavior in the more open-ended Phandalin setting from an introductory D&D 5e adventure.
- A user who wants to start with a stable version and compare notebook/Release with notebook/WIP when newer features matter.
- An experimental team constrained by the cost of high-quality instruction models and long-context queries that wants to explore a lower-parameter local-model approach.
What are this agent's strengths and limitations?
- Documents two notebook execution paths: local runs and Google Colab.
- Separates a stable release, newer WIP notebooks, and a WIP library across notebook/Release, notebook/WIP, and game_simulation.
- Uses the Phandalin D&D setting, described as more free-form than the paper's simple scenario.
- Explicitly uses lower-parameter locally runnable models to address the cost of high-quality instruction models and long-context queries.
- The current version works best with 16GB VRAM; although sub-8GB VRAM environments are supported, no performance or feature trade-offs are documented.
- No installation commands, dependency versions, model-download method, credentials, or notebook execution sequence are provided.
- The material acknowledges room for improvement in the current lower-parameter local models and expects future instruction-tuned models to perform better.
- There is no verifiable documentation of an API, CLI, evaluation results, output format, or production deployment interface.
How do you install or deploy this agent?
No copyable installation commands, dependency list, model acquisition method, environment versions, or credential requirements are provided. The documented execution boundary is that notebooks run locally or in Google Colab, JupyterLab is recommended for local use, and the notebooks should work as-is in Google Colab. A reproducible setup still needs the specific notebook filename, dependency installation steps, model-file source, and first-run workflow.
How do you use this agent?
Choose the model described as most stable in notebook/Release, or choose a newer WIP version in notebook/WIP; open and run the applicable notebook in local JupyterLab or Google Colab. A WIP library is also available under game_simulation. The material does not document a first notebook, command, parameters, or cell execution order, so no more specific verified invocation can be supplied.
How does this agent compare with similar options?
The material contrasts this project with the paper's approach, which requires a high-quality instruction model such as GPT-3 and many long-context queries: this implementation instead uses lower-parameter, locally runnable models to reduce running cost.