AGENT-BASED MODELING AND SIMULATION

This is mainly inspired from document: Proceedings of the 2014 Winter Simulation Conference
A. Tolk, S. Y. Diallo, I. O. Ryzhov, L. Yilmaz, S. Buckley, and J. A. Miller, eds.
ABSTRACT

Agent-based simulation (ABS) is an approach to modeling systems comprised of individual, autonomous,

interacting “agents.” Agent-based modeling offers ways to more easily model individual behaviors and
how behaviors affect others in ways that have not been available before. There is much interest in
developing agent-based models for many application problem domains. Applications range from
modeling agent behavior in supply chains and the stock market, to predicting the success of marketing
campaigns and the spread of epidemics, to projecting the future needs of the healthcare system. Progress
in the area suggests that ABS promises to have far-reaching effects on the way that businesses use
computers to support decision-making and researchers use agent-based models as electronic laboratories
to aid in discovery. This brief tutorial introduces agent-based modeling and simulation by describing the
basic ideas of ABS, discussing some applications, and addressing methods for developing agent-based
models.

1 INTRODUCTION
Agent-based simulation (ABS), or agent-based modeling (ABM), is a modeling and computational
framework for simulating dynamic processes that involve autonomous agents. An autonomous agent acts
on its own without external direction in response to situations the agent encounters during the simulation.
Modeling a population of autonomous agents, each with its own characteristics and behaviors, that
extensively interact is a defining feature of an ABS. Agent-based simulation is most commonly used to
model individual decision-making and social and organizational behavior (Bonabeau 2001). These
notions of behavior, decision-making, and interaction apply to modeling many kinds of system. An agent
is a general concept having broad applicability. Agents often represent people, or groups of people. Agent
relationships represent processes of social interaction (Gilbert and Troitzsch 2005). For example, an
individual’s daily activities are explicitly modeled in an ABS of infectious disease transmission to
understand transmission patterns arising from contact with other individuals. In a supply chain ABS,
agents are firms with decision-making behaviors about material sourcing and ordering, stocking,
shipping, capacity expansion, etc. In an ABS composed of artificial agents, collaborating robots search
the landscape and communicate their findings to collectively accomplish a task. The development of
agent-based modeling tools, the availability of micro-data on agent transactions and interactions, and
advances in computation have made possible a growing number of ABS applications across a variety of
domains and disciplines.
 ABS has gained increasing attention over the past several years as evidenced by the increasing numbers
of articles appearing in modeling and applications journals, funded programs that call for agent-based
models incorporating elements of human and social behavior, the demand for ABS courses and
instructional programs, and the growing number of conferences that feature agent-based modeling, such
as the Winter Simulation Conference (WSC). Interest in ABS has steadily grown at the WSC since the
first ABS tutorial we presented in 2005 (Macal and North 2005). Agent-based modeling began as the
computational arm of the field of “artificial life,” which is concerned with the emergence of order in
nature, with the development of Swarm, the first agent-based modeling toolkit some 20 years ago (Macal
2009). Previous to that, the field of cellular automata gave the form, time and state advance mechanisms
to many of the original agent-based simulations. ABS originated and developed quite independently of
traditional Monte Carlo and discrete event simulation (DES). We refer the reader to previous papers on
other introductory topics in ABS not covered here, such as the history of ABS and the relationships of
ABS to other modeling and simulation techniques (Macal, North, and Samuelson 2013; Heath and Hill
2010; Macal and North 2010; Heath, Hill, and Ciarallo 2009).
Agent-based modeling is being applied to many areas, spanning human social, behavioral, cultural,
physical and biological systems. Applications range from modeling ancient civilizations that have been
gone for hundreds of years, to designing new markets for products that do not exist right now. Heath, Hill
and Ciarallo (2009) provide a review of agent-based modeling applications. Selected applications and
overview papers are listed in Table 1. All of the cited publications make the case for agent-based
modeling as the preferred modeling approach for the problems addressed. These authors argue that agent-
based modeling is used because only agent-based models can explicitly incorporate the complexity
arising from individual behaviors and interactions that exist in the real-world.
This tutorial provides an introduction to agent-based modeling and simulation. The goals are to show
that ABS is: Useful: Why ABS is an appropriate modeling approach for a large class of problems and has
advantages over conventional modeling approaches in many cases, Usable: How ABS is advancing to the
point of producing portable, extensible, and transferable software, with better integrated development
environments, and Used: How ABS applications are being developed to solve practical problems. This
tutorial is organized as follows. The first part of the paper (Sections 2 and 3) is on how to think about
ABS. The second part is on how to do ABS. Section 4 is a practical guide on how to get started in ABS,
and Section 5 considers when it is appropriate to use ABS.

2 HOW TO THINK ABOUT AGENT-BASED MODELING

2.1 Structure of an agent-based model

A typical agent-based model has three elements:

• Agents, their attributes and behaviors.

• Agent relationships and methods of interaction. An underlying topology of connectedness defines
how and with whom agents interact.
• Agents’ environment. Agents live in and interact with their environment, in addition to other
agents.
 Table 1: A sample of recent agent-based applications and overviews.
Application Area: Agent-based Model Focus:
Agriculture A spatial individual-based model prototype for assessing potential pesticide exposure of
farm-workers conducting small-scale agricultural production (Leyk, Binder, and Nuckols
2009)
Air Traffic Control Air traffic control to analyze control policies and performance of an air traffic
management facility (Conway 2006)
Archaeology / Trends in archaeological simulation including ABM (Madella et al. 2014)
Anthropology Prehistoric settlement patterns and political consolidation in the Lake Titicaca basin of
Peru and Bolivia (Griffin and Stanish 2007)
Biomedical Research The Basic Immune Simulator, to study the interactions between innate and adaptive
immunity (Folcik, An, and Orosz 2007)
Crime Analysis A realistic virtual urban environment, populated with virtual burglar agents (Malleson
2010)
Ecology Investigation of the trade-off between road avoidance and salt pool spatial memory in the
movement behavior of moose (Grosman et al. 2011)
Predator-prey relationships between transient killer whales and other marine mammals
(Mock and Testa 2007)
Economics Using agent-based models for analyzing threats to financial stability (Bookstaber 2012)
Energy Analysis A building occupant network energy consumption decision-making model (Chen,
Taylor, and Wei 2011)
Application for the Smart Grid (Jackson 2010)
Energy investment decision making (Wittmann 2008)
Oil refinery supply chain (Van Dam et al. 2008)
Environmental Overview of agent-based modeling for environmental planning and policy analysis
Planning and Policy (Zellner 2008)
Epidemiology / Pandemic disease model accounting for individual behavior and demographics (Aleman,
Infectious Diseases Wibisono, and Schwartz 2009)
Global-scale agent model of disease transmission (Parker and Epstein 2011)
Evacuation Tsunami evacuation using a modified form of Helbing’s social-force model applied to
agents (Puckett 2009)
Healthcare A systematic assessment of use cases and requirements for enhancing pharmaceutical
research and development productivity through agent-based modeling (Hunt et al. 2013)
Market Analysis / Consumer marketing model developed with a Fortune 50 firm (North et al. 2009)
Marketing
Consumer airline market share (Kuhn et al. 2010)
Simulation of the possibilities for a future market in sub-orbital space tourism (Charania,
Olds, and DePasquale 2006)
Overview of agent-based applications to marketing (Rand and Rust 2011)
Social Networks Model of email-based social networks. Individuals establish, maintain and allow atrophy
of links through contact-lists and emails (Menges, Mishra, and Narzisi 2008)
Social Psychology Using ABM for theory building in social psychology (Smith and Conrey 2007)
 A model developer must identify, model, and program these elements to create an agent-based model.
A computational engine for simulating agent behaviors and agent interactions is then needed to make the
model run. An agent-based modeling toolkit, programming language or other implementation provides
this capability. To run an agent-based model is to have agents repeatedly execute their behaviors and
interactions. This process is often but not necessarily modeled to operate over a timeline, as in time-
stepped, activity-based, or discrete-event simulation.

2.2 Agents
There is not universal agreement on the precise definition of the term agent in the context of ABS. It is
the subject of much discussion and occasional debate. The issue is more than an academic one, as it often
surfaces when one makes a claim that their model is agent-based or when one is trying to discern whether
such claims made by others are valid. There are important implications of the term agent-based when
used to describe a model in terms of the model’s capabilities or potential capabilities that could be
attained through relatively minor modification. In the literature, descriptions of the term agent tend to
agree on more points than they disagree. Some modelers consider any type of independent component,
whether it be a software component or a model to be an agent (Bonabeau 2001). Some authors insist that
a component’s behavior must also be adaptive in order for it to be considered an agent. Casti (1997)
argues that agents should contain both base-level rules for behavior as well as a higher-level set of “rules
to change the rules.” The base-level rules provide responses to the environment, while the rules-to-
change-the-rules provide adaptation. Jennings’ (2000) computer science-based view of agent emphasizes
the essential agent characteristic of autonomous behavior.
For practical modeling purposes, we consider agents to have certain properties and attributes, as
follows (Figure 1):
Autonomy. An agent is autonomous and self-directed. An agent can function independently in its
environment and in its interactions with other agents, generally from a limited range of situations that are
of interest and that arise in the model. When we refer to an agent’s behavior, we refer to a general process
that links the information the agent senses from its environment and interactions to its decisions and
actions.
Modularity. Agents are modular or self-contained. An agent is an identifiable, discrete entity with a
set of characteristics or attributes, behaviors, and decision-making capability. The modularity requirement
implies that an agent has a boundary, and one can easily determine whether something (that is, an element
of the model’s state) is part of an agent or is not part of an agent, or is a characteristic shared among
agents.
Sociality. An agent is social, interacting with other agents. Common agent interaction protocols
include contention for space and collision avoidance, agent recognition, communication and information
exchange, influence, and other domain-or application-specific mechanisms.
Conditionality. An agent has a state that varies over time. Just as a system has a state consisting of the
collection of its state variables, an agent also has a state that represents its condition, defined by the
essential variables associated with its current situation. An agent’s state consists of a set or subset of its
attributes and its behaviors. The state of an agent-based model is the collective states of all the agents
along with the state of the environment. An agent’s behaviors are conditioned on its state. As such, the
richer the set of an agent’s possible states, the richer the set of behaviors that an agent can have.
Agents often have additional properties, which may or may not be considered as requisite properties
for agency. An agent may have explicit goals that drive its behavior, not necessarily objectives to
maximize as much as criteria against which to assess the effectiveness of its decision and actions. An
agent may have the ability to learn and adapt its behaviors based on its experiences. At the individual
level, learning and adaptation can be modeled as agent behaviors. Individual learning and adaptation
requires an agent to have memory as a dynamically updated attribute of the agent. At the population level,
adaptation can be modeled by aggregate changes in individual behaviors or by allowing agents to enter
and leave the population, with the more successful agents increasing their relative numbers in the
population over time.

Figure 1: A typical agent.

2.3 Agent Relationships

Agent-based modeling concerns itself with modeling agent relationships and agent interactions as much
as it does with modeling agents and agent behaviors. The primary issues of modeling agent interactions
are specifying who is, or could be, connected to who, and the dynamics governing the mechanisms of the
interactions. For example, an agent-based model of Internet growth would include mechanisms that
specify who connects to who, why, and when.
Common topologies for representing social agent interactions include: (1) Soup: A non-spatial model
in which agents have no locational attribute, (2) Grid or lattice: Cellular automata represent agent
interaction patterns and available local information by a grid or lattice; cells immediately surrounding an
agent are its neighborhood. An agent’s location is the grid cell index. (3) Euclidean space: Agents roam
in 2D or 3D spaces. An agent’s location is its relative or geospatial coordinates. (4) Geographic
Information System (GIS): Agents move over and interact with realistic patches of geo-spatial landscapes.
An agent’s location is a geographical unit (e.g., zip code) or geospatial coordinates. (5) Networks:
Networks may be static (links pre-specified) or dynamic (links determined endogenously by relationship-
creating mechanisms). An agent’s location is the relative node location in the network.
No matter what agent-interaction topology is used in an agent-based model to connect the agents, the
essential idea is that agents only interact at any given time with a limited number of other agents out of
the population. This notion is implemented by defining a local neighborhood (possibly a network) and
limiting interaction to a small number of agents that happen to be in that neighborhood. This is not to say
that agents need to be located in close proximity to one another spatially to be able to interact. The
network topology allows agents to be linked on the basis of relationships in addition to proximity. For
example, an agent may be a member of many networks, e.g., proximity, social, familial relationship,
ideological, etc.
2.4 Emergence in Agent-based Models
One of the motivations for agent-based modeling is its ability to capture emergence. Even simple agent-
based models in which agents are completely described by simple, deterministic rules and use only local
information can self-organize and sustain themselves in ways that have not been explicitly programmed
into the models. Emergence can be illustrated by simple agent-based models such as Life and Boids. More
complex models of the kind that people are likely to build to represent real-world phenomenon can also
exhibit emergent behavior resulting from agent interactions. Agent-based modeling algorithms based on
emergence have led to specialized optimization techniques, such as ant colony optimization and particle
swarm optimization, that have been used to solve practical problems (Bonabeau, Dorigo, and Theraulaz
1999; Barbati, Bruno, and Genovese 2011).

3 HOW TO DO AGENT-BASED MODELING

3.1 Thinking Through an Agent Model

Agent-based model development follows the general steps of developing any model with the additions of
agent-related tasks (Figure 2). It is useful to ask a series of agent-specific questions before developing an
agent-based model (Table 2). The answers to these questions help define the scope and level of detail,
granularity, appropriate to modeling the system. They imply the resources required for successfully
completing the project and can be used to help identify likely bottlenecks to development.

Figure 2: Agent –based model development process.

3.2 Modeling Agent Systems

Identifying agents, accurately specifying their behaviors, and appropriately representing agent interactions
are the keys to developing useful agent models. One begins developing an agent-based model by
identifying the agent types (classes) along with their attributes. Agents are generally the decision-makers
in a system, whether they be human, organizational, or automated. Once the agents are defined, agent
behaviors are specified. One needs to have a theory of agent behavior as a basis for modeling agent
behavior. For example, a normative model in which agents attempt to optimize a well-defined objective
can be a useful starting point to eventually developing more descriptive and domain-specific behavioral
heuristics. Alternatively, one may begin with a bounded rationality model or a generic behavioral
heuristic, such as anchoring and adjustment, to describe agent behavior, or a formal behavioral modeling
framework such as the Belief-Desire-Intent (BDI) model (Wooldridge 2009). In addition to agents, an
agent-based model consists of agent relationships. One defines the agent relationships and then adds the
methods that control which agents interact, when they interact, and how they interact.

Table 2: Questions to ask before developing an agent-based model

Model Purpose and Value-added of Agent-based Modeling:
What specific problem is the model being developed to address?
What specific questions should the model answer?
What kind of information should the model provide to help make or support a decision?
Why might agent-based modeling be a desirable approach?
What value-added does agent-based modeling bring to the problem that other modeling approaches cannot bring?
All About Agents:
Who should be the agents in the model?
Who are the decision makers in the system?
What are the entities that have behaviors?
Where might the data come from, especially for agent behaviors?
Agent Data:
What data on agents is simply descriptive (static attributes)?
What agent attributes are calculated endogenously by the model and updated for the agents (dynamic attributes)?
What is the agents’ environment? How do the agents interact with the environment? Is agent mobility in space an
important consideration?
Agent Behaviors:
What agent behaviors are of interest?
What decisions do the agents make and what information is required to make such decisions?
What behaviors are being acted upon?
What actions are being taken by the agents?
How would we represent the agent behaviors? By If-Then rules? By adaptive probabilities, such as in
reinforcement learning? By explicit heuristics? By regression models or neural networks?
Agent Interactions:
How do the agents interact with each other?
How do the agents interact with the environment?
How expansive or focused are agent interactions?
Agent Recap:
How do we design a set of experiments to explore the importance of uncertain behaviors, data and parameters?
How might we validate the model, especially the agent behaviors and the agent interaction mechanisms?

3.3 Describing Agent-Based Models

Several formats have been proposed for describing agent-based models. Chief among these standards is
the Overview, Design Concepts, and Details (ODD) protocol. According to Grimm et al. (2010), “The
primary objectives of ODD are to make model descriptions more understandable and complete, thereby
making ABMs less subject to criticism for being irreproducible.“ ODD describes models using a three-
part approach: overview, concepts, and details. The model overview includes a statement of the model’s
intent, a description of the main variables, and a discussion of the agent activities and timing. The design
concepts include a discussion of the foundations of the model, and the details include the initial setup
configuration, input value definitions, and descriptions of any embedded models (Grimm et al. 2010).
Examples of using the ODD protocol include Polhill et al. (2008) and Schreinemachers and Berger
(2011).
3.4 Designing Agent-Based Models
Design is a key phase in building agent-based models. Modern software practices are based on a template
design approach in which recurring elements are codified and reused for new applications. For example,
many agent-based toolkits take an object-oriented approach, which has proven very valuable in designing
models, as well as software. See, for example, Pegden (2014). The Unified Modeling Language (UML)
provides a set of tools in the form of diagrams for object-oriented software system design and
representation that is independent of computer code implementation (Booch, Jacobson, and Rumbaugh
2005). North and Macal (2013) discuss helpful process and product design patterns for agent-based
modeling. An agent-based modeler refers to existing design patterns to model important features of a real-
world system, such as how time should be treated in a model.

3.5 Advanced Agent-Based Modeling

Often, an agent-based modeler would like to include a variety of advanced capabilities in their model.
These capabilities include distributed computing implementations, artificial intelligence and machine
learning algorithms, geographical information systems (GIS), connections to relational databases, version
control systems (especially if there are multiple developers working on a project), and integrated
development environments (IDEs). It is often useful to first develop a core model that includes these
capabilities as connections or “stubs” to ensure the core model design is acceptable and to verify that
scaling up the design appears feasible. Agent-based modeling and software toolkits usually provide such
advanced capabilities.

3.6 ABS Software and Toolkits

Agent-based modeling can be done using general, all-purpose software or programming languages, or can
be done using specially designed software and toolkits that address the specific requirements for modeling
agents. Agent modeling can be done in the small, on the desktop, or in the large, using large-scale
computing clusters, or it can be done at any scale in-between. Projects often begin small, using one of the
desktop ABS tools, or whatever tool or programming language the developers are familiar with. The
initial prototype then grows in stages into a larger-scale agent-based model, often using dedicated ABS
toolkits. Often one begins developing their first agent model using the approach that one is most familiar
with, or the approach that one finds easiest to learn given their background and experience.
We distinguish several approaches to building ABS applications in terms of the scale of the software
that one can apply according to the following continuum:

Desktop Computing for ABS Application Development:

• Spreadsheets: Excel using the macro programming language VBA
• Dedicated Agent-based Prototyping Environments: NetLogo, Repast Simphony
• General Computational Mathematics Systems: MATLAB, Mathematica
Large-Scale (Scalable) Agent Development Environments: Repast, Swarm, MASON, AnyLogic, Simio
General (Object-Oriented) Programming Languages: Java, C++, Python

Desktop ABS can be used to learn agent modeling, prototype basic agent behaviors, and perform
limited analyses. Desktop agent-based models can be simple, designed and developed independently in a
period of a few days by a single computer-literate modeler using tools learned in a few days or weeks.
Desktop agent modeling can be used to explore the potential of ABS with relatively minor time and
training investments, especially if one is already familiar with the tool.
Spreadsheets, such as Microsoft Excel, are in many ways the simplest approach to modeling. It is
easier to develop models with spreadsheets than with many of the other tools, but the resulting models
generally allow limited agent diversity, restrict agent behaviors, and have poor scalability compared to the
other approaches designed specifically for agent modeling. Agent-based modeling in spreadsheets
requires some macro-programming to be done in a language such as VBA (Visual Basic for
Applications), the macro programming language for Excel and other Microsoft Office applications.
Complex agent models have been developed entirely using spreadsheets. In previous WSC papers, we
described a spreadsheet implementation of a spatial agent-based shopper model (Macal and North 2007).
General-purpose desktop computational mathematics systems (CMS) with integrated development
environments (IDEs), such as MATLAB and Mathematica, can be used to develop agent models,
although the agent-specific functionality has to be written by the developer from scratch, as there are no
dedicated libraries or modules that focus on agent-based modeling. The basic requirement is knowledge
of how to program in a scripting language. CMS environments have rich mathematical functions and in
some cases, the tools even support symbolic processing and manipulation. If a CMS environment is
already familiar to a developer, this can be a good place to start agent-based modeling (Macal 2004).
Swarm was the first ABS software development environment, launched in 1994 at the Santa Fe
Institute. Swarm was originally written in Objective C and was later fitted with a Java interface. Special-
purpose agent tools, such as NetLogo, provide facilities for agent modeling (Wilensky 2014). The most
directly visible common trait shared by the various prototyping environments is that they are designed to
get first-time users started as quickly as possible. NetLogo uses a modified version of the Logo
programming language (Harvey 1997) and was originally developed to support ABS education at all
levels, but it can be used to develop a wide range of applications. Following the original Swarm
innovation, the Repast (REcursive Porous Agent Simulation Toolkit) toolkit was developed as a pure Java
implementation (North, Collier, and Vos 2006), and Repast Simphony (Repast S) is the latest version of
Repast, designed to provide visual point-and-click tools for agent model design, agent behavior
specification, model execution, and results examination. Repast Simphony 2.0 also includes ReLogo, a
new Logo-like interface for specifying agent models (Ozik et al. 2013). Reviews of Java-based agent
modeling toolkits are provided by Tobias and Hoffman (2004) and Nikolai and Madey (2009).
Scalable ABS software environments are now freely available and/or open source. These include
Repast (North, Collier and Vos, 2006; North et al. 2013), Swarm (Minar et al. 1996), NetLogo (Wilensky
2014) and MASON (GMU 2014) among others.
AnyLogic (XJ Technologies 2014, Borshchev 2013) and Simio (Simio 2014, Pegden 2014) are
leading commercial simulation environments that include agent-based modeling capabilities. AnyLogic
features “multimethod” modeling, i.e., has the capabilities to structure models that combine all three
simulation paradigms: agent-based, system dynamics, and discrete event. Simio is a simulation modeling
framework based on “intelligent objects” and supports a seamless use of multiple modeling paradigms
including event, process, object, and agent-based modeling.
As computational capabilities continue to advance in both hardware and software, new capabilities
are continuously being incorporated into the latest versions of ABS toolkits. The field is advancing
rapidly toward highly scalable, high productivity agent development environments that are easy to learn
and use.

4 HOW TO GET STARTED WITH AGENT-BASED MODELING

Many people ask how to get started with agent-based modeling. A good background in simulation
modeling in the traditional fields of discrete-event simulation, Monte Carlo simulation, or even system
dynamics is an excellent prerequisite but is not essential, as the field of agent-based modeling was not
originally founded on these fields or the software that supports them. Some universities offer courses on
agent-based modeling, but not very many at this time. There is not even a generally agreed upon agent-
based modeling curriculum for the modeling and simulation community, but Macal and North (2013)
attempt to get that discussion rolling through their experiences with workshops and tutorials such as this
one. Many people have found success at becoming agent-based modelers, including the authors, by
independently following a path such as this:
 1. Read about introductory agent-based modeling,
2. Review some good, simple applications in the literature,
3. Download, play with, and inspect some available pre-built ABS demonstration models,
4. Attend conferences devoted to agent-based modeling or that have significant focus on ABS,
5. Define a problem meaningful to you to address with agent-based modeling (see Table 2), and
6. Develop some simple agent-based models (prototypes) in available ABS toolkits.

Going through these steps positions one to start thinking about how to develop larger-scale and
serious agent-based models. The most important point to make is that there is no substitute for learning
about agent-based modeling than to get one’s hands dirty and actually build an agent-based model. This
is true even if the ultimate goal is not to become a full-time agent-based modeler. Steps 5 and 6 were
discussed in the previous section. Steps 1-4 are discussed below.
A background in computer programming is very helpful but not absolutely essential to get started
with agent-based modeling, as ABS environments may offer high-level languages that are relatively easy
to learn (e.g., NetLogo, ReLogo, et al.) or visual environments that simplify ABS specification (e.g.,
AnyLogic, Repast Simphony, et al.). However, developing an ABS with advanced capabilities (GIS,
database connectivity, etc.) often requires programming, typically in Java or another object-oriented
language such as C++. There is a natural relationship between ABS and object-oriented programming, as
agents may be regarded as objects with behaviors, i.e., intelligent objects (Macal and North 2007).
A single comprehensive source for reading all about ABM does not exist. Good introductions to
ABM include the web sites by Axelrod and Tesfatsion (2014), the ACE web site also by Tesfatsion
(2014), and the new web site by Railsback and Grimm (2013). The book by Epstein and Axtell (1996) is
often regarded as launching the field of social agent simulation in a sustained way. It includes simple, but
elegant, models of various social processes that are still being elaborated upon. The early paper by
Bonabeau (2001) remains as one of the most cited and readable papers on the motivations for ABS. The
book by Gilbert and Troitzsch (2005) is widely read and provides a highly readable overview of the field
including how to construct simple ABS. Our book (North and Macal 2007) is designed to provide a broad
non-technical introduction to ABS in terms of how to think about and do ABS as well as providing
terminology and language for becoming conversant in agent-based modeling.
There are several recurring issues that are often raised by newcomers to ABS including how agents
handle resource contention and allocation, how time is taken into account, etc. There are common
approaches in ABS to address these (Macal 2013) and other issues that are beyond introductory ABS.
The SIMSOC Archive (https://www.jiscmail.ac.uk/cgi-bin/webadmin?A0=simsoc) and SIMSOC listserv
are good places for information on various introductory and advanced ABS topics.
Good ABM applications are scattered throughout the literature across many disciplines. There is no
single publication source for ABM applications, but the online Journal of Artificial Societies and Social
Simulation (JASSS) has provided a consistent outlet for agent-based models for many years
(http://jasss.soc.surrey.ac.uk/JASSS.html).
Disciplines often produce their own overview publications on agent-based modeling specific to their
discipline. These can serve as valuable resources for understanding the value of using ABM in a
discipline and include key references for the domain. For example, disciplinary ABM overview and
survey papers include: marketing (Rand and Rust 2011), economics (Cristelli, Pietonero, and Zaccaria
2011), financial economics (LeBaron 2005), transportation (Bernhardt 2013), electric power markets
(Weidlich and Veit 2008), geographical information systems (GIS) (Brown et al. 2005), and many other
areas. Simple Google searches on “agent based model” or multi agent system model” yield many
application papers.
It can be very useful to visit the web sites for the ABM toolkits and download the software (NetLogo
or Repast, for example) or trial versions (AnyLogic, for example). Demonstration examples are provided
that give a good idea of how agent-based models are constructed and of the software’s capabilities.
 Several conferences have a focus on agent-based modeling or tracks devoted to ABS. The annual
Winter Simulation Conference tends to have a full track of proceedings papers devoted to agent-based
simulation and applications. Our estimates are that about 20% of the papers in WSC are on agent-based
simulation. The annual MABS (Multi-Agent-Based Simulation) workshop, which is part of IAAMAS
(International Conference on Autonomous Agents and Multi-Agent Systems), focuses on agent-based
modeling “from the standpoint of the multiagent systems community of engineering and the
social/economic/organizational sciences” (https://sites.google.com/site/mabsworkshop/). The annual
Computational Social Science Society of the Americas (CSSSA) conference, formerly NAACSOS,
focuses on “Computational Social Science (CSS), a scientific discipline where computational methods
and simulation models of social dynamics are employed to offer new insights into social phenomena
beyond what is available with traditional social science methods”
(http://computationalsocialscience.org/csssa2013). SwarmFest (www.swarmfest2014.org) is a conference
devoted to agent-based modeling and simulation. Other conferences such as the annual INFORMS
meeting (https://www.informs.org/) and the annual MORSS (Military Operations Research Society
Symposium, http://www.mors.org/) often have significant numbers of presentations involving agent-
based models, and these number have steadily grown over the past 10 years.

5 WHY AND WHEN ABS

We conclude by offering some ideas on the situations for which agent-based modeling can offer distinct
advantages to conventional simulation approaches such as discrete event simulation (Law 2007), system
dynamics (Sterman 2000) and other quantitative modeling techniques. Axtell (2000) discusses several
reasons for agent-based modeling especially compared to traditional approaches to modeling economic
systems. When is it beneficial to think in terms of agents? When any of the following criteria are
satisfied:

• When the problem has a natural representation as being comprised of agents

• When there are decisions and behaviors that can be well-defined
• When it is important that agents have behaviors that reflect how individuals actually behave (if
known)
• When it is important that agents adapt and change their behaviors
• When it is important that agents learn and engage in dynamic strategic interactions
• When it is important that agents have dynamic relationships with other agents, and agent
relationships form, change, and decay
• When it is important to model the processes by which agents form organizations, and adaptation
and learning are important at the organization level
• When it is important that agents have a spatial component to their behaviors and interactions
• When the structure of the system does not depend entirely on the past, and new dynamic
mechanisms may be invoked or emerge that govern how the system will evolve in the future.
• When arbitrarily large numbers of agents, agent interactions and agent states is important
• When process structural change needs to be an endogenous result of the model, rather than an
input to the model