Content uploaded by Robert Siegfried
Author content
All content in this area was uploaded by Robert Siegfried on Aug 25, 2014
Content may be subject to copyright.
A Reference Model for Agent-Based Modeling and Simulation
Robert Siegfried, Axel Lehmann Rachid El Abdouni Khayari, Tobias Kiesling
Universit¨
at der Bundeswehr M¨
unchen IABG Industrieanlagen-Betriebsgesellschaft mbH
{robert.siegfried|axel.lehmann}@unibw.de {khayari|kiesling}@iabg.de
Keywords: Agent-based modeling, multi-agent simulation,
reference model
Abstract
Multi-agent simulations gain more and more importance for
the simulation of complex systems. In order to meet the con-
tinuously increasing requirements regarding complexity, level
of detail, and size of the model on the one hand and an effi-
cient modeling and execution on the other hand, a reasonable
theoretical foundation is essential. Based on the awareness
that at the current time these foundations of multi-agent simu-
lation are weak in comparison to other simulation paradigms,
the necessity for a general approach for defining and describ-
ing a multi-agent simulation is examined. Following this in-
vestigation, an exemplary reference model for agent-based
modeling and simulation is introduced. This reference model
is intended to provide a common understanding of agent-
based models along with well-defined semantics of their sim-
ulation. In addition, it permits the implementation of various
simulators adhering to the specified semantics using the same
model and producing identical simulation runs.
1. INTRODUCTION
1.1. Motivation
Agent-based modeling is currently in widespread use to
model complex systems. Especially if a large number of het-
erogeneous objects with individual behavior (and learning)
has to be considered, agent-based models are often the first
choice. Nevertheless the theoretical foundations of agent-
based modeling and simulation appear to be a lot weaker
than for alternative simulation approaches (like e. g. tradi-
tional discrete event simulation or object-oriented simula-
tion) [5]. Surprisingly, this includes ambiguous definitions of
basic terms (e. g. which elements comprise an agent-based
model and how they are related to each other [4]) as well
as missing definitions of advanced concepts (e. g. what is to
be understood exactly by the simulation of an agent-based
model). The resulting unsatisfactory state was just recently
summed up by M¨
uller: “Most, if not all, existing multi-agent
simulation platforms produce simulation results which do not
depend only on the model but on the way the model is im-
plemented and the scheduling ordered, this ordering being at
worst arbitrary and at best randomized” [7].
Therefore, the current assessment of the situation is that
agent-based modeling and simulation is still far from being
done in a standardized way. Especially simulators are often
custom-made and tailored for a specific question (respec-
tively model) in mind. As modeling and simulation should
strive for a more systematic approach, it is obvious that a
general approach for describing an agent-based model and
its respective simulation is still missing. In order to address
this challenge, this paper motivates the need for a reference
model for agent-based modeling and simulation and presents
a first approach towards such a reference model.
1.2. Purpose and scope of the Reference Model
The reference model for agent-based modeling and simu-
lation, as proposed in the following, aims to
•identify the key concepts of agent-based models and
their dependencies,
•provide clear and sound definitions of the key concepts
of an agent-based model and its respective simulation,
•provide a general scheme for the description and docu-
mentation of agent-based models,
•provide an abstract basis for the development of algo-
rithms and simulators used for the simulation of agent-
based models.
Currently, the intention of the reference model is to provide a
solid conceptual basis for agent-based modeling and simula-
tion. In order to provide this conceptual basis, which should
be general enough to be applicable to a wide range of use
cases, a reasonable abstraction level has to be chosen. The
guiding principle, which is followed throughout the reference
model, is to avoid prescriptive requirements as far as possible
and make these only when necessary. In this context, a central
point is the abstraction of specific agent architectures (i. e. of
the specific modeling of internal structures of the agents) as
well as the abstraction from a specific execution paradigm of
the simulator.
The assumed target audience of this reference model are
modelers, developers and scientist in the area of multi-agent
simulation. It can help and guide modelers in creating and
documenting agent-based models in a standardized and well-
defined way, thereby providing a common language and un-
derstanding. Developers may build upon this reference model
to define technical recommendations and interface specifica-
tions, and to create simulators which adhere to common se-
mantics and allow the reuse of agent-based models on various
simulators. The scientific community may use the reference
model to develop and describe concepts and algorithms on a
higher level, thereby gaining the advantage of more general
results which are applicable in a much wider range than be-
fore.
1.3. Outline
Section 2 presents the current status of research in describ-
ing agent-based simulations. Based on these preliminaries,
Section 3 contains the main contribution of this paper: a ref-
erence model for agent-based modeling and simulation. The
conclusions and outlook on the future work in Section 4 fi-
nally complete this paper.
2. OVERVIEW OF THE CURRENT STATUS
OF RESEARCH
Various approaches and formal models for describing
agent-based models have been developed and proposed in the
past. Examples are the publications by Kl¨
ugl [5], Uhrmacher
[12, 11], Weyns and Holvoet [14], Scheutz and Schermerhorn
[10] and Helleboogh [2]. Each approach usually focused on
some specific objective, but often appeared to meet its goal
only through compromising on other accepted principles and
ideas. Furthermore, the existing definitions and approaches
of suitable generality often seem to oversimplify key aspects
(e. g. actions without duration).
Instead of presenting a selection of the existing approaches
in detail, which would be incomplete anyway, this section
provides a short overview over the common aspects found
in the above mentioned approaches. Major drawbacks as well
as positive aspects of these approaches are pointed out.
2.1. Environment and Situatedness
Many authors emphasize the importance of the environ-
ment, which is somehow intuitively clear, as the common def-
inition of an agent usually contains the concept of situated-
ness [9, p. 32f.], [2]. In order to avoid confusion and because
of a multitude of different and sometimes unclear ways of
dealing with the environment, especially in the closely related
fields of multi-agent simulation and multi-agent systems, a
precise definition of the term is necessary: Although obvi-
ous, it is important to clearly distinguish between the simu-
lated environment and the simulation environment. In short,
the simulated environment is an abstraction of the original
environment and thus part of the model itself, whereas the
simulation environment (also called simulator) provides the
infrastructure necessary for running the simulation [6, 16, 8].
As pointed out in [2], the real environment is typically dy-
namic, meaning that the environment changes in ways beyond
the agents’ control. Therefore, the simulated environment is
not always considered to be just a passive common space but
as an active part of the simulation. Despite carrying its own
processes, sometimes the environment is considered to be re-
sponsible for even more technical aspects like detecting and
resolving conflicting actions of the agents, e. g. in [14]. Here,
the missing clarity in distinguishing between the simulated
environment and the simulation environment becomes very
obvious in many approaches.
In summary, it is questionable whether the simulated envi-
ronment should be responsible for tasks like computing the
effects of desired actions. It seems a lot more appropriate –
especially against the background that the environment has to
be modeled and validated as carefully as the agents acting in
it – to put only these properties and dynamics into the envi-
ronment which are necessary for the intended model purpose.
Auxiliary tasks, especially if they are not related to the model
directly (like the computation of conflicting actions), should
be left to the simulation environment, i. e. the simulator.
2.2. Active and Passive Entities
Another common aspect is that almost all approaches con-
sider various types of entities situated within the model. An
obvious distinction is to separate the entities mutually ex-
clusive into agents and resources [5]. Generally speaking, it
makes sense to distinguish “between active and passive enti-
ties, that is, between agents and (non-agentive) objects of the
real world” [13].The passive entities usually represent some
objects from the real world and are therefore associated with
a couple of defining properties which may well change re-
spectively be altered during a simulation.
Although there are slight differences between the various
approaches, the importance of differentiating between the in-
tended action of an agent and the outcome of an action is reg-
ularly stressed. As Kl¨
ugl puts it, “one must accept, that the
agent itself can only control its effectors, but not the effects
of its action in the environment” [5, p. 9]. Out of this problem
arise multiple challenges like efficient conflict detection and
resolution. Scheutz/Schermerhorn as well as Kl¨
ugl appear to
deal with this problem within their respective model update
functions, but did not discuss the details. As this topic bears
a lot of information for the execution of a simulation run and
is directly connected to the aspect of the atomicity of actions
and the duration of an action, the topic of conflicting actions
seems to be too important not to be considered in the defini-
tion of an agent-based simulation.
2.3. Stepwise Execution and Simulation Time
Although not always explicitly mentioned, most ap-
proaches make use of a stepwise execution of the simulation
of the agent-based model. For example, the definition of a
simulation run given by Scheutz and Schermerhorn explicitly
utilizes this stepwise execution and further implies, that all
agents are executed in each step and that no action can happen
in between these steps. Implicitly assumed in this model is
the fact, that all actions need exactly one time step for execu-
tion [10]. Kl¨
ugl defines a simulation quite similarly in terms
of model configurations and “the iterated application of the
update functions defined by the model onto the start configu-
ration and state” [5, p. 15]. Due to this quite vague definition
and a missing formal description of a simulation run, Kl¨
ugl
does not mention the stepwise execution explicitly.
By assuming a stepwise execution of the simulation, both
approaches allow synchronization at each simulation step.
Besides a missing clarification whether these time steps are
all of the same length, this stepwise execution of the agents is
somehow contradictory to the notion of autonomous and in-
dependently acting agents (cp. [14]). Deeply connected with
this is the vague definition (if at all) of synchronization as-
pects in several models. But as “synchronization is often the
technically most difficult aspect in implementing an agent-
based simulation” [5, p. 22], the missing accuracy and clarity
in this point is a major drawback of those approaches. Fur-
thermore, as also mentioned above, the whole area of inter-
ference and synergy of actions is often sparsely treated.
Another example of an unclear separation of concerns can
regularly be found in the mix-up of the simulation time (e. g.
discrete, continuous) and the execution paradigm (e. g. event-
based, round-based) used by an actual simulator. In combina-
tion with a stepwise execution of the simulation, many au-
thors give up this clear distinction between the simulation
time (i. e. the time model) and the execution paradigm. This
is especially disadvantageous as the often chosen time-sliced
simulation model is inefficient and inappropriate to synchro-
nize agents that act at irregularly distributed points in time [1]
and becomes an even greater problem when trying to paral-
lelize the simulation execution. In summary, an explicit time
model is required as well as a clear separation of the time
model from the execution paradigm used by the actual simu-
lator.
2.4. Unclear Separation of Concerns
The major aspect which many approaches are missing, is
a strict and consistent separation of concerns. In this context,
separation of concerns refers to the separation of the model,
the definition of a simulation of a model and the actual exe-
cution of the simulation within a specific simulation environ-
ment.
The absence of this clear separation leads to fuzzy defini-
tions on the one hand and imposes unnecessary limitations
to the development and documentation of multi-agent simu-
lations (especially within teams) on the other hand. Further-
more, this unclear basis complicates the development of al-
ternative simulators which adhere to the same common set of
specifications and provide clearly defined semantics. As also
noted above, often an unclear separation between simulation
time and execution paradigm prevails. Thereby, the applica-
bility of the model is unnecessarily limited and the use of
efficient techniques (e. g. event-based simulation) is rendered
impossible.
3. A REFERENCE MODEL FOR AGENT-
BASED MODELING AND SIMULATION
3.1. Requirements and Basic Ideas
Based on the presented current status of research, this sec-
tion sums up the main requirements on a reference model and
the intended targets.
3.1.1. Separation of Concerns.
The key idea which will be followed throughout the whole
approach is the strict separation of concerns. This will not
only significantly reduce the complexity of the single parts
but will also provide the necessary basis for future work on
distributed development and execution.
As this strict separation of concerns is the basic underly-
ing idea and key requirement, it is important to define pre-
cisely which concerns shall be separated. On the highest level
the agent-based model itself, the simulation of this model
and the actual simulator have to be distinguished. The agent-
based model describes the entities and the interplay of these
in a common environment. Based on the (static) agent-based
model, it has to be defined what is meant by the simulation
of this model. This includes especially the behavior of a sin-
gle agent and the combination of multiple possibly conflict-
ing agents. The simulator itself is not part of the reference
model, as a multitude of simulators can be thought of (e. g.
sequential or parallel) which all adhere to the same seman-
tics. At this point, it should be noted that the requirements on
the simulator are defined via the semantics of the simulation.
As long as a simulator works accordingly to the semantics of
the simulation (as defined in the following), the simulator is
considered to be valid.
At this point, it should be mentioned that DEVS (Discrete
Event System Specification) strictly distinguishes between
the model and the simulator. In this context, especially the
extensions of DEVS with regard to agent-based models pro-
vide a lot of valuable suggestions [11, 5].
3.1.2. Decoupling of Simulation Time.
In line with the separation of concerns, the simulation time
has to be modeled explicitly and completely independent,
i. e. without restrictions to issues like stepwise execution, etc.
The way the time progresses during a simulation (e. g. time-
stepped, event-based) is completely handled by the specific
simulator and can be implemented rather arbitrarily as long
as the simulator is conforming to the specification as laid out
in the following subsections.
B
FForest
Burning forest
Burned forest
Watered forest
Figure 1. The example scenario consists of a grid world with
five different cell types (empty, forest, burning, burned, wa-
tered) and two agents: a fireman (F) and a firebug (B).
3.1.3. Abstraction from Specific Agent Architectures.
The internal structure of the agents themselves (e. g. agents
based on the BDI-architecture) is not of interest in the context
of this work. Nevertheless, as “nearly all systems .. . con-
stitute a definite intra-agent architecture” [1], the reference
model must be able to represent the various different agent
architectures.
3.1.4. Actions.
Each agent is capable of executing a number of actions
(depending on his sensors and effectors). All actions of the
agents can have a duration and may interfere with each other.
Combined with an explicit time model this imposes espe-
cially that different actions can have different durations which
need not to be a multiple of some common smallest time step.
3.1.5. Environment.
The environment is seen as a mostly passive background
providing the common playground for the agents. Neverthe-
less, the environment can generate events which can be per-
ceived by the agents. In this context it is important to men-
tion that the agents have to perceive their environment explic-
itly and that this perception (depending on the model purpose
and the agents sensors) can be erroneous (cp. internal model
in [12, 11]).
3.2. Example Use Case
To illustrate the proposed reference model, a simple exam-
ple of a fireman fighting against fire spreading in a landscape
is chosen (see figure 1). Inspired from [3] and [7], the scenario
also contains a firebug. We have to represent the landscape
made of empty spaces and forests with its dynamics of fire
occurrence and spreading. We assume that the firebug wan-
ders around randomly and ignites some forest with a given
(low) probability. As long as no fire is detected, the fireman
is waiting at his current position. If a fire occurs, he moves
towards the fire. When on a burning place, he waters the sur-
face.
Agent-based model
Model world
Time Environment Rules
Events Entities
Agents
Body Actions Processes
Objects
Figure 2. The basic elements of an agent-based model.
3.3. Definition of an Agent-Based Model
In the following, a definition of an agent-based model is
presented which forms the basis of the proposed reference
model for agent-based modeling and simulation.
Definition 1 (Agent-based model) An agent-based model is
a 3-tuple ABM = (MW,ENT,EV )of the model world MW ,
the entities EN T and the events EV .2
The above mentioned main components and the resulting
composition of an agent-based model are shown in Fig. 2.
All components of the so-defined agent-based model are de-
scribed in detail in the following sections.
3.3.1. Model World.
The model world defines the common surrounding of all
agents within a model. The model world MW = (T,E,R)
consists of the specifications of the time and the environment,
as well as the common rules and laws.
The domain of the simulation time Tmay be arbitrary and
depends only on the model purpose (e. g. discrete or contin-
uous). The only restriction which is imposed on the simula-
tion time is that it has to be totally ordered (i. e. antisymmetry,
transitivity and totality are fulfilled), cp. [17, p. 99f.]. The def-
inition of simulation time in this generality imposes the least
constraints on the further modeling of the event handling and
agent behavior. Keeping in mind the central idea of the ap-
proach of separating the concerns, this general definition of
simulation time allows the designers of different parts (e. g.
different kinds of agents) to use time models which are best-
suited in their case, as long as the the overall simulation time
is a superset of all locally used time sets.
Example The time is chosen to make use of a discrete do-
main, i. e. T=N. In this example, a single time step repre-
sents an interval of 1 second. /
In order to define the actions of a single agent and the in-
terplay between multiple simulated agents, the common en-
vironment needs to be defined. As an abstraction of the real
environment, the environment Edenotes the common space
in which the agents can act. As for the simulation time, the
restrictions regarding the environment are quite low: the sim-
ulated environment may be discrete or continuous, bounded
or unbounded and can be of arbitrary dimension (also often
2-d or 3-d is used). As suggested before, the environment is at
the current state assumed to be mainly passive, but of course
changeable.
In order to allow processes within the environment, the
concept of locations is introduced. A location simply denotes
some connected space within the environment. The set of all
possible locations is denoted by L. Each location may be as-
sociated with a set of properties pidescribing this location
(e. g. temperature, humidity):
pi:L→Diwith i∈N(1)
In this case, Diis just a placeholder for the actual domain
of the specific property (e. g. degree Celsius for temperature
might use discrete values in [−40,50], while humidity in per-
cent may use continuous values in [0,100]).
Besides these properties, each location may be associated
with currently occuring environmental actions:
ai:L→envActions (2)
The set envActions denotes the possible environmental ac-
tions. Each action a∈envActions has a duration and may
change the environment (e. g. burning trees) as well as the
location itself (e. g. spread of fire).
Example The environment is modeled as a rectangular grid
of cells. A cell can be of one of the following types: empty,
forest, burning, burned, watered. Each cell has a property
pTrees denoting how many living trees are on this cell. The
burn-action decreases pTrees by one in each time step until ei-
ther no trees are left or the fire is extinguished. The fire does
not spread to neighboring cells. /
Rules determine the conditions under which actions are in
conflict with each other (e. g. collision of agents) and rep-
resent general laws of the model world (e. g. gravitational
force). The set of all rules is denoted by R. Rules are an es-
sential part of the overall model and can be modeled in vari-
ous ways (propositional logic, first-order logic, . . . ). It is as-
sumed, that all rules and laws are given in an appropriate form
and that they can be evaluated in the required ways.
3.3.2. World Events.
A world event represents an event occurring in the sim-
ulated environment. As such, world events are part of the
agent-based model. The set of all possible types of events
which can possibly occur is denoted by EV . In other words,
EV does not denote the actual events themselves but the dif-
ferent kinds of events (e. g. environmental, action, communi-
cation, . . .) which are suitable within a specific model.
It is important to stress that each event ehappens at a spe-
cific point in time te∈T. Events do not have any duration
which means that all events are consumed in the same mo-
ment they occur. Multiple events may occur at the same point
in time, furthermore all events are distinguishable and can
be associated with specific properties (e. g. type of the event,
area of influence).
World events usually trigger some kind of action in the
influenced agents. In order to avoid confusion, it should be
mentioned explicitly in this place, that the world events are
not identical to the events known from event-driven simula-
tion. This concerns especially the implementation of an actual
simulator: A specific implementation of the proposed agent-
based simulation may be event-driven, but does not need to
be. The simulator could as well use a time-stepped approach,
as long as all definitions and specifications laid out in this
reference model are fulfilled.
3.3.3. Agents and their Behavior.
Generally speaking, every multi-agent simulation consists
of an environment and multiple entities interacting in it. In
this sense, an entity can either be an (actively acting) agent or
a (widely passive) object.
Definition 2 (Entity set) The tuple E NT = (A,O)denotes
all entities which are part of the model. Adenotes the set of
all agent types, Othe set of all objects. 2
As it is common agreement within the agent community that
an agent consists of a body and a behavior (cp. [10, 5]), this
distinction is also adopted for this approach. The agents body
defines its physical dimensions, the number and placement of
its sensors as well as its effectors. Although these bodily as-
pects can’t be completely separated from the possible actions,
of course, the focus is mainly on the behavioral modeling of
an agent and therefore bodily properties will be omitted at the
moment.
On an informal basis the behavior of a single agent is de-
termined by the following aspects:
•Each agent is capable of executing various actions.
•Each action consumes a specific amount of time.
•The actions of an agent can be combined to processes.
•Processes of an agent may be executed concurrently.
This informal description of an agent does not include the
event handling, i. e. the occurrence of an event can influence
an agent and usually triggers some kind of action within the
agent. Keeping this in mind, the given informal description
fits well with the requirements stated by Braubach, that any
multi-agent architecture has to support the creation and dele-
tion of agents, that agents are comprised of a number of par-
allel tasks and that agents may receive messages from other
agents resulting in a change of their behavior [1].
Definition 3 (Agent) An agent A ∈Ais defined as the tuple
A= (B,A,P)with Brepresenting all bodily properties, Ade-
noting the agents actions and Pbeing the set of all processes
of this agent. 2
At any instant of time, each agent has a well-defined state
which exactly describes all the properties of the agent as well
as his embedding in the model world at this time. Therefore,
this definition of state applies a somewhat omniscient view
and assumes perfect knowledge. It has to be very clearly dis-
tinguished from possible internal states and knowledge of the
agent itself (which may be incorrect or incomplete, or both).
Definition 4 (State of an agent) Given an agent A, its state
at time tis denoted by St(A).2
The expression St(A)should not be interpreted as a function
of A, but more as a shortform of St(ABM|A), i. e. the state
at time tof the agent-based model ABM focused on agent A
(=projection on A).
Describing an agent bottom-up, the primary concept to be
defined are the actions. The term action denotes some atomic
action on the level of a single agent which eventually makes
use of some of the agents sensors and effectors. The set of all
possible actions of an agent is denoted by A. As long as the
context is clear, additional superscripts like AAfor denoting
that the actions of agent Aare meant are omitted.
The actions of an agent can be thought of as the basic build-
ing blocks, e. g. simple controller actions. Each action can di-
rectly affect a subset of the sensors and effectors of the agent,
although these relations are not investigated in full detail for
the time being. Another possibility are actions which are not
affecting the bodily parts of the agent (i. e. sensors and effec-
tors) but trigger some built-in mental actions (e. g. some kind
of reasoning).
Definition 5 (Execution of an action) An action a∈Amay
either succeed or fail. If astarts execution in t0and if aex-
ecutes successfully, aterminates at t0+tsucc(a)with tsucc(a)
denoting the duration of action a. If afails, the execution is
aborted at t0+tfail(a)with tfail (a)denoting how long ahas
been executed before failing. 2
An action can only fail to execute (i. e. be interrupted) by
means of influences from outside (e. g. some conflict with
an action of another agent). Each action (either successful or
failed) implies a state change:
St(ABM)×a−→ St+t(a)(ABM)(3)
The actual nature of this state change, especially in the case
of failed actions is defined by the rules of the model world. A
possible set of rules could define, that actions are treated like
transactions and therefore are executed as a whole or not at
all. Another possibility if an action afailed would be that the
result of an partial execution of ais computed.
Example Fireman-Agents are capable of three actions:
View: Perceive environment, duration: 1 timestep.
Move: Move to next cell (in direction of the closest fire),
duration: 1 timestep.
Water: Use water to extinguish fire at the current cell,
duration: 4 timesteps.
Firebug-Agents are only capable of the following actions:
RandomMove: Move randomly to a neighboring cell,
duration: 1 timestep.
MakeFire: Ignite current cell with probability 0.1,
duration: 1 timestep. /
Example 2 Another example for actions would be the re-
presentation of agent communication by two corresponding
actions (e. g. Send and Receive). In this way, agent communi-
cation can be integrated in a consistent manner. /
As noted above, the actions of an agent can be combined
to form more complex behavior patterns, so-called processes.
The processes of the agents are activated by events, which in
turn can activate multiple processes (of eventually multiple
agents depending on the type and region of influence of the
event).
Definition 6 (Process) A process Pof an agent is a 3-tuple
P= (EVactivate ,fact,fsucc )with
•EVactivate ⊆EV being the set of events activating this
process.
•fact :EVactivate →A∪ a choosing the first action to ex-
ecute depending on the specific activation event. ade-
notes a special action without duration indicating the end
of the current process.
•fsucc :A→A∪ a being the transition function leading
from one action to the next if the current action was ex-
ecuted successfully. 2
It is obvious that the given definition of a process describes
only its structure (=syntax). As is common in various other
branches of computer science the definitions of syntax and
semantics, i. e. in this case of the structure and the execution
of a process, are strictly separated.
Definition 7 (Execution of a process) Given a process P
which receives an event e∈EVactivate at time t0∈T, the exe-
cution of Pis defined as follows: Let fact (e) = anow:
1. If anow =a,Pfinishes successfully at t0.
2. Begin execution of anow at time t0.
3. If execution of anow is successful, t0=t0+tsucc (anow),
anow =fsucc(anow )and continue with step 1.
If execution of anow failed, Palso fails at t0+tfail(anow )
and the execution of the process terminates. 2
By this definition, each process remains active until either the
process finishes successfully or terminates because of a fail-
ure.
Example The Firebug-Agent is capable of the actions A=
{RandomMove, MakeFire}. The Wander-Process is now de-
fined as follows:
•EVactivate ={start}with start denoting the “birth”-event
of the agent.
•fact (start) = RandomMove
•fsucc(RandomMove) = MakeFire
fsucc(MakeFire) = RandomMove /
Example 2 With regards to agent communication, the
Send-Action of an agent might trigger a Communication-
Event, which in turn activates the Receive-Process of another
agent. /
Recalling the above given definitions, an agent is com-
prised of actions which in turn can be combined to concur-
rently executed processes. The execution of an agent Ais then
defined as the response to incoming events: given an incom-
ing event, the execution of an agent involves mainly relaying
this event to all relevant processes.
Definition 8 (Behavior of an agent) Given an agent A
which receives an event eat time t0∈T, the execution of A
(i. e. its behavior) is defined as follows:
1. Let Pact be the subset of the processes Pof an agent
which are activated by the event e. Formally: Pact =
SP∈PA|e∈EV P
activate P.
2. All processes P∈Pact receive eat time t0and are exe-
cuted according to the definition given above. 2
3.4. Simulation of an Agent-Based Model
The proposed reference model does not impose any re-
quirements on how to implement or realize the handling of
events. On the contrary, the only requirement is that the sim-
ulation environment (= the simulator) adheres to the given
definitions and assures that all events are processed correctly.
Definition 9 (Processing an event) Given the set of agents
A, an event eoccurring at time t∈Tis processed as follows:
1. For each agent A∈Athe set of all events to which the
agent Aresponds in some way is denoted by EV A
activate =
SP∈PAEV P
activate .
2. All agents A∈Awith e∈E V A
activate receive eat time
t0and are executed according to the definition given
above. 2
This definition assures that each event eis relayed without
delay to all agents able to respond to this event. All further
processing is already defined by the semantics of processes
and actions.
Given the definition of an agent-based model, the mean-
ing of simulation of such a model can now be defined in an
appropriate way.
Definition 10 (Multi-Agent Simulation) Given an agent-
based model ABM as defined previously, i. e. ABM =
(MW,ENT,EV ), the simulation Sis defined with respect to
some specific time interval [t0,t1]as the correct processing of
the set of all events {e1,...,en} ⊆ EV occurring within this
interval, i. e. the simulation of ABM is said to be correct, iff
all events occurring in this interval are processed correctly
and all agents are executed correctly. 2
Therefore, if the model ABM is assumed to be in state ABM0
in t0and ABM1in t1, a simulation can be seen as the state
transition S:ABM0× {e1,...,en} → ABM1of the underlying
model.
4. CONCLUSION AND OUTLOOK
A novel and general approach for describing a multi-agent
simulation is presented with a strong emphasis on the cen-
tral idea of a clear and strict separation of different concerns.
As laid out briefly in the beginning of this paper, a survey of
existing approaches for (formally) describing a multi-agent
simulation revealed that the formal basis of this simulation
paradigm is amazingly weak. Based on the commonalities
and missing points of the investigated approaches, the re-
quirements concerning a reference model are worked out.
The proposed reference model defines what is to be un-
derstood by an agent-based model and subsequently by the
simulation of this model. The agents are modeled via actions
and concurrently executed processes. Thereby, no specific
agent architecture is enforced, and various agent architectures
should fit within the proposed approach. A very simple exem-
plary use case is shown; while the general applicability of the
proposed reference model as well as the compatibility with
the various agent architectures still needs to be demonstrated.
On the other hand, a reference implementation for a sequen-
tial simulator revealed a direct transferability of the given def-
initions into executable code.
What has to be done still, is to complete the evaluation of
the devised reference model. This includes especially an in-
vestigation about the completeness of the formalism, i. e. if
the presented approach is applicable for a wide range of real-
world models with sufficient detail. This evaluation will also
reveal whether the proposed approach needs to be formal-
ized more strongly. Furthermore, the differences and analo-
gies with traditional paradigms like Discrete Event Simula-
tion have to be worked out and integrated smoothly into the
proposed approach.
In the long run, the presented approach will serve as the ba-
sis for the parallel execution of agent-based simulations. This
includes especially the challenge that agent-based models are
designed exactly once and without taking care of the actual
simulator executing the simulation. Each simulator adhering
to the defined semantics will deliver the same results, poten-
tially making use of a parallel execution.
REFERENCES
[1] L. Braubach, A. Pokahr, W. Lamersdorf, K.-H. Krem-
pels, and P.-O. Woelk. A Generic Simulation Service
for Distributed Multi-Agent Systems. In R. Trappl, edi-
tor, Cybernetics and Systems 2004, pages 576–581, Vi-
enna, 2004. Austrian Society for Cybernetic Studies. 3-
85206-169-5.
[2] A. Helleboogh, G. Vizzari, A. M. Uhrmacher, and
F. Michel. Modeling dynamic environments in multi-
agent simulation. Autonomous Agents and Multi-Agent
Systems, 14(1):87–116, February 2007.
[3] X. Hu, A. Muzy, and L. Ntaimo. A hybrid agent-cellular
space modeling approach for fire spread and suppres-
sion simulation. In M. E. Kuhl, N. M. Steiger, F. B.
Armstrong, and J. A. Joines, editors, Proceedings of
the 2005 Winter Simulation Conference, pages 248–255.
ACM, December 2005.
[4] N. R. Jennings, K. Sycara, and M. J. Wooldridge. A
Roadmap of Agent Research and Development. Au-
tonomous Agents and Multi-Agent Systems, 1(1):7–38,
March 1998.
[5] F. Kl¨
ugl. Towards a Formal Framework for Multi-Agent
Simulation Models. Technical report, Institute of Com-
puter Science, University of W¨
urzburg, April 2007.
[6] F. Kl¨
ugl, M. Fehler, and R. Herrler. About the Role of
the Environment in Multi-agent Simulations. In Weyns
et al. [15], pages 127–149.
[7] J.-P. M¨
uller. Towards a formal semantics of event-
based multi-agent simulations. In Proceedings of
the 9th International Workshop on Multi-Agent-
Based Simulation, 2008. Not published yet. http:
//mabs2008.dcti.iscte.pt/revised_for_
pre_proceedings/23Muller.pdf.
[8] J. Odell, H. V. D. Parunak, M. Fleischer, and S. Brueck-
ner. Modeling Agents and Their Environment. In
F. Giunchiglia, J. Odell, and G. Weiss, editors, Agent-
Oriented Software Engineering III, volume 2585 of Lec-
ture Notes in Computer Science, pages 16–31, Berlin,
Heidelberg, 2003. Springer-Verlag. doi:10.1007/3-540-
36540-0 2.
[9] S. J. Russell and P. Norvig. Artificial Intelligence – A
Modern Approach. Pearson Education, Inc., 2 edition,
2003.
[10] M. Scheutz and P. Schermerhorn. Adaptive algorithms
for the dynamic distribution and parallel execution of
agent-based models. Journal of Parallel and Distributed
Computing, 66(8):1037–1051, August 2006.
[11] A. M. Uhrmacher. Dynamic Structures in Modeling and
Simulation: A Reflective Approach. ACM Transactions
on Modeling and Computer Simulation, 11(2):206–232,
April 2001.
[12] A. M. Uhrmacher and R. Arnold. Distributing and
Maintaining Knowledge: Agents in Variable Structure
Environments. In Proceedings of the Fifth Annual Con-
ference on AI, Simulation, and Planning in High Auton-
omy Systems, pages 178–184. IEEE Computer Society
Press, December 1994.
[13] G. Wagner. AOR Modelling and Simulation: To-
wards a General Architecture for Agent-Based Dis-
crete Event Simulation. In P. Giorgini, B. Henderson-
Sellers, and M. Winikoff, editors, Agent-Oriented Sim-
ulation Systems, volume 3030/2004 of Lecture Notes in
Computer Science, pages 174–188, Berlin, Heidelberg,
2004. Springer-Verlag.
[14] D. Weyns and T. Holvoet. Model for Situated Multi-
Agent Systems with Regional Synchronization. In 10th
International Conference on Concurrent Engineering,
Agent and Multi-Agent Systems. Balkema Publishers,
July 2003. CE’03.
[15] D. Weyns, H. V. D. Parunak, and F. Michel, editors.
Environments for Multi-Agent Systems, volume 3374 of
Lecture Notes in Computer Science, Berlin, Heidelberg,
2005. Springer-Verlag.
[16] D. Weyns, H. V. D. Parunak, F. Michel, T. Holvoet, and
J. Ferber. Environments for Multiagent Systems State-
of-the-Art and Research Challenges. In Weyns et al.
[15], pages 1–47.
[17] B. P. Zeigler, H. Praehofer, and T. G. Kim. Theory of
Modeling and Simulation – Integrating Discrete Event
and Continuous Complex Dynamic Systems. Academic
Press, San Diego, 2 edition, 2000.
