=Paper=
{{Paper
|id=Vol-494/paper-47
|storemode=property
|title=Multiagent Simulation Model Design Strategies
|pdfUrl=https://ceur-ws.org/Vol-494/masspaper10.pdf
|volume=Vol-494
|dblpUrl=https://dblp.org/rec/conf/mallow/Klugl09
}}
==Multiagent Simulation Model Design Strategies==
https://ceur-ws.org/Vol-494/masspaper10.pdf
Multiagent Simulation Model Design Strategies
Franziska Klügl
School of Science and Technology
Örebro University, Örebro, Sweden
Email: franziska.klugl@oru.se
Abstract—Model design is particularly challenging for multi- from minor bugs at the micro-level – in the agents design
agent simulation models as the simulation paradigm does hardly as well as implementation.
impose constraints on it. This contribution systematically ana- • A last issue is the difficult control of the included
lyzes procedures for developing a multi-agent simulation model:
iterative methods derived from principles, such as KISS or KIDS assumptions – due to the size of the model and the effort
and methods focussing on the different design elements (agents, of developing, a systematic control of the assumptions
interaction, environment). taken while modeling has to be done. After modeling all
assumptions can hardly be recapitulated and tested when
I. I NTRODUCTION they are not explicitly collected while modeling.
Methodological questions are more and more in the focus These are issues mostly in design of a multi-agent model.
of research on agent-based simulation. This contribution deals Clearly there are others, when considering all phases of
with the phase in modeling that requires most experience and the simulation study. Examples for additional problems are
creativity from the modeler: model concept and design. the need for validation when relevant data is missing, the
difficulties of implementing concurrent processes or technical
The development of a multi-agent simulation model seems
problems due to the size of the model and simulation. Never-
to be an inherently intuitive way of modeling: Entities observ-
theless the design phase of a modeling and simulation study
able as active in the real system are captured as active entities
is the one the requires the most experience. This is the phase
– as agents – in the model. There seems to be no need for
that is often coined as “art” [2].
complex aggregation or abstraction necessary for formulating
In this contribution, we are focussing on the issues in model
the model, nor a languages that requires deep mathematical
design and give a systematic view on different procedures. In
skills must be used. Features of the model such as variable
the following we will first set the context of our endeavor by
structure, heterogeneities, mixed local and global effects, ...,
tackling process models for (multi-agent) simulation, as well
can just be formulated or generated from more or less simple
as input from agent-oriented software design. Then we will
agent behavior and interaction – just as observable in the
give procedures for designing a model – one-shot in section
original system or stated in the original ideas. Due to this
III and iterative in section IV. The contribution ends with a
intuitiveness and its general potential, it is often forgotten,
discussion of the procedures and a short conclusion.
that the development of a multi-agent simulation model leads
to particular problems beyond general simulation engineering:
II. M ETHODOLOGIES AND P ROCESSES FOR D EVELOPING
• Determining the appropriate level of detail is everything M ULTI -AGENT S IMULATION M ODELS
else but trivial. Actually, it is the basic design problem
to determine what behavior shall be included or which A. Simulation Study Life Cycle
factors ignored. Phases of a systematic development of agent-based simula-
• Thinking in terms of agents can also be a problem when tion models have been suggested by several researchers [3],
the modeler is used to other paradigms, such as process- [4], [5]. While focussing on integration of data or different
oriented or macro modeling. Then an interaction-oriented roles of participants in the study, their suggestions for pro-
model for generating the aggregate behavior instead of cedures are naturally quite similar to guidelines for general
describing it, may be difficult to design. simulation study development developed by [6], [7] or [2].
• The general intuitiveness of the modeling leads to a The basic phases are initial works such as fixing the objec-
tendency of ad-hoc development. This is supported by tive, making a profound analysis of the system or gathering
visual programming tools such as SeSAm [1]. Modelers necessary data and information. This is followed by making
immediately start implementing instead of thinking about a model concept and elaborating it - this is basically model
an appropriate design beforehand. design. Model implementation and calibration are additional
• Necessary effort for understanding and analyzing the phases that are accompanied by analysis and validation phases.
model and its overall behavior is underestimated. As in a When the model is ready, the simulation study is completed by
multi-agent simulation the overall behavior is generated deployment runs and documentation and interpretation of the
from the interactions and local behavior of agents, special results. Clearly, bugs and deficiencies discovered in one phase
effort has to be invested for excluding artifacts originating may require re-working in previous phases. Figure 1 depicts
Fig. 1. Phases of an agent-based simulation study. Model design may also be iterative.
these basic phases for agent-based simulation development. procedure has some similarities with the work described in
The model design phase is highlighted. this paper; yet here the focus lies in simulation applications
It is quite unrealistic to assume that model design can be fin- with their specific characteristics. Our goal is to deal with a
ished within one cycle. An iterative procedure for developing guideline how to modify the different elements of a model to
the model is appropriate not only for finding the right level of finally build a valid simulation model.
detail – starting with a initial model that is developed further Although there are profound differences between agent-
until it is run-able and its dynamics analyzable. Based on the based software and agent-based simulation – such as the
insight from this analysis, the model is further improved. Such correspondence to an original system ensured by validation
an overall iterative proceeding is indicated in Figure 1. or the inclusion of a simulated environment in addition to the
This process is very abstract and does not use abstractions simulation environment – the abstractions used for designing
and techniques that are particular for agent-based simulation. the software system may also be useful for designing a
This would be necessary for a more specific simulation life simulation model. This is especially the case when real-world
cycle. In contrast to agent-based software, there is no fully organizational structures are used or folk psychology-based
elaborated meta model describing necessary elements of an agent architectures are appropriate in the simulation model.
agent-based simulation in general (or even for a particular In the following we want to tackle strategies for simulation
domain) in sufficiently concrete detail. Thus, a methodology model design from a simpler point of view:
comparable to the ones suggested for agent-based software
engineering cannot be given yet. First attempts for a formal III. AGENT- BASED S IMULATION M ODEL D ESIGN
meta model for multi-agent simulation models have been In the following we will introduce and discuss three design
made, such as in [8], but they are not on a level that makes strategies. They are derived systematically from an idea about
them usable as a basis for the development of more specific elements of multi-agent simulation models: It consists of
life cycle models. three basic components: agents model, environment model and
Before we will tackle model design and possible iterative model of the interactions. Each of them is used as a starting
improvement strategies, we will first have a short look on point or driving force for a design strategy; thus their usage
agent-oriented software engineering where the design of an can be seen as exclusive. However, it might be advisable to use
agent system is central part of every methodology. different approaches one after the other in an iterative setting.
B. Agent-based Software Engineering A. Agent-driven Model Design
For the development of agent-based software, many method- “Agent-driven model design” is the first strategy. It corre-
ologies have been suggested. Clearly, they are based on general sponds to bottom-up design. The focus lies completely on the
software development phases such as requirements engineer- agents, their decision making and their behavior. Environmen-
ing/analysis, specification/design, etc. These methodologies tal and interaction models are added when needed in the agent
rely on appropriate abstractions for representing and analyzing design.
the agent-based software system. Development then happens 1) Basic Strategy: The following procedure can be defined:
by elaboration of these representations. Many methodologies 1) Agent observation and coarse behavior description: The
have been proposed for guiding the development of agent- modeler observes the real-world agents and derives a
based software based on roles or organizational structures or coarse behavior description from its observations. Ob-
focussing on specific agent concepts and architectures, such servations may be replaced by literature work or opera-
as BDI. Good collections can be found for example in [9]or tionalization of hypothesis about agent behavior/decision
[10]. Comparisons based on benchmarks [11] or features [12] making.
aim at supporting the selection of the appropriate methodology 2) Categorize agents and determine the location of hetero-
for a particular problem. We would just like to mention geneity: The coarse behavior descriptions are analyzed
[13] showing how modeling and simulation can be used for for determining how many classes or types of agents
the design of self-organizing agent software. The suggested are necessary for the model and to what level the agents
should be different. The location of heterogeneity may
be on the level of parameter settings, different activities
or even completely different classes.
3) Decide about agent architecture: Based on the coarse
behavior description that treated the agents superficially,
the modeler has to decide about the architecture of the
agent. He may select a behavior-describing approach,
for example perception-action rules with or without
internal state representation or an architecture that is
explicitly grounded on goals and on the configuration
and selection of plans or even using plan generation from Fig. 2. Specification of example bee-agent behavior using activity graphs
first principles or an elaborated cognitive model. This (adapted from [14]).
selection is depending on the complexity and flexibility
of necessary agent behavior.
4) Formalize agent behavior/goals: The next step consists scouting, foraging, returning to the nest, unloading, wagggle
of filling in the actual behavior into the agent architec- dance (recruiting) and waiting. A simple behavior-descriptive
ture. This is done by analyzing, elaborating and refining architecture is appropriate. Due to the identified activities, an
the coarse behavior description developed in the first approach based on activity graphs representing the relations
steps. between activities is useful.
5) Add interactions and environmental aspects when The next step is the formulation, i.e. specification and
needed: Particular elements of the environmental model implementation of agent behavior. In figure 2 we depict the
or structures of interaction are added when the agent be- behavior of an agent.
havior needs to include particular perceptions, messages Figure 2 does not indicate, when an interaction with the
or contains manipulations of environmental entities. As environment or other agents has to take place. When elabo-
these aspects are added in some ad hoc manner, some rating this graph, the modeler concurrently determines that
re-factoring may be necessary, such as merging different there is a 2dimensional map for scouting and discovering
environmental entity classes. Also some considerations resources. There must be resources that provide a nectar of
about necessary heterogeneity are essential. certain quality. When returning to the hive, there must be some
6) Test whether necessary macro-phenomena are suffi- place to unload and some place to dance for recruitment of
ciently reproduced: At any time, model validity has to others. The storage area and the dance ground are only dealt
be tested when it is testable. We assume that the focus with on a very abstract level. They may only be attributes of
on the agents will lead to agent behavior near validity. an object of the type “hive”. For switching activities between
But, a major effort will be testing wether the interplay waiting and foraging, the actual recruitment has to be modeled.
of agents and their environment results in a valid macro- Information is displayed by the dancer and perceived by
level behavior. conceptive other ants that based on the received information
This procedure is a pure agent-driven bottom-up method decide to scout or not.
for developing a multi-agent simulation. Aspects that relate This specification has to be implemented and tested as
agents to others or the environment are only important in so described above. As aggregate measures, the nectar input may
far they are influencing the agent behavior. Before we continue be available for macro-level validation as well as counts how
to discuss this procedure, we give a short example how the many bees are dancing, how many fly out, etc.
application of this method may look like. 3) Discussion: The result of this process is a model that
2) Example: We used an existing simulation model[14] of is fairly process-oriented on the agent level. For the example,
bee recruitment: The basic objective was to find support for the agent-driven design seems to work quite well. This might
the hypotheses that the environmental structure influences the be due to the fact that interaction happens only indirectly via
success of a recruitment mechanism in social insects. the environment or by displaying or broadcasting information.
Using an agent-driven approach, this model is build from In the example, there is no direct message-based interaction.
the point of view of a honey bee. Individual bees are to be In principle the procedure should also work with direct peer-
observed and literature has to be scanned for description of to-peer interactions. However, the strategy does not contain
behavior and parameter values. In the second step, different any perspective on the system-level containing for example
categories of bees are identified: scouts, foragers or bees protocol specifications. Such a bottom-up technique where
waiting/working in the hive. In this particular case these the modeler takes over the perspective of an agent can be
categories correspond more to activities than to different agent appropriately tested using participatory simulations where one
types as agents may instantaneously switch between activities. agent is controlled by a human, the others are simulated.
Therefore one may decide for a homogenous agent population A critical issue occurs when the overall validity is not
with differences in the currently executed activity. reached. Then, this pure bottom-up technique will lead to trial
The following tasks of an agent bee are to be considered: and error procedures as during the development of the model
no connection between macro- and micro level is established.
Additionally this procedure does not help in finding the
appropriate level of detail. Therefore it needs to be combined
with an iterative procedure.
B. Interaction-driven Model Design
There are simulation domains where a focus on interac-
tions is more appropriate than a purely agent-driven design.
Examples may be models that focus on the performance of
organizational design. In the following we want to introduce
interaction-driven design.
1) Basic Process: One can formulate the following basic
process for interaction-driven model design:
1) Identify actors/entities and interactions among them:
Instead of observing individual real-world agents, the
modeler is taking the birds’ perspective and analyzes
Fig. 3. First specification of recruitment protocol together with context
who is interacting and how. description. .
2) Coarse description of protocols and their conditions,
constraints, etc. The identified actors and interactions
are refined to protocols going from general notions Formulating this interaction is not trivial as it is more like
of interaction to atomic exchanges of information and a broadcast (or stigmergic interaction). The message is send –
manipulations of the environment. respectively the information is displayed in the dance – to all
3) Derive agent behavior for producing the interaction agents that want to listen or observe it.
elements (messages, signals, actions...) and add envi- The next step would be to derive agent-behavior from the
ronmental entities, such as shelter objects, to the model interaction diagrams. We suggested to transfer the interaction
when needed for interaction. In this step something like diagram into some finite state machine like representation. If
a finite state machine based language can be used to we do that for every interaction the agents are participating
specify agent interactions as state transitions. in, a collection of finite state machines is generated. These
4) Implement agent behavior and test whether the intended single simple graphs have to be combined into a complete
interactions and their outcome on the macro level are behavior description. This is done by first identifying similar
actually produced by the overall system. It must be also states as interfaces which’s unification merges the single state
tested whether the agent level behavior is plausible or machines into some larger one. This larger one is probably too
valid – depending on the available data. large as every interaction aspect is modeled explicitly. It might
In the interaction-driven approach, agents are basically seen be possible to simplify some parts. Therefore, a refactoring
as black boxes for producing the appropriate messages, infor- might be necessary for bringing the overall state graph into
mation, etc. The general procedure may be further developed some well-structured and minimal form.
into some form organization-driven model design inspired by Figure 4 shows the straight forward combination of a
similar methods and methodologies from agent-oriented soft- number of single-interaction state charts. For connecting we
ware engineering. Then, analysis of organizational structures identified two times similar nodes – end nodes of one interac-
forms the starting point for all system analysis as it forms the tions, starting nodes of the other. In the graph such nodes are
structural backbone of interactions. depicted as black nodes with second ring.
2) Example: We use the same example as above for il- During the development of this behavior graph, we had to
lustrating the approach and its differences to the agent-driven add state machines for interaction partners that are not given
procedure. in figure 4. These interaction partners are the bee hive sending
As given above, we start by identifying the actors and information that is used for the evaluation of the value of the
their interactions. Again we have to tackle the problem of load when the bee-agent is returning to the hive. Additionally,
the location of necessary heterogeneity. Are the actors to be we omitted the interaction with the overall environment where
found on the level of scouts or foragers or as bees on a the agent is requesting and receiving perception information
more homogeneous level? In our particular case we took bees and with resources with that it interacts while harvesting the
as agents. Table I shows the basic interaction between the nectar of this resource.
different types of entities. As a next step, it has to be determined what happens within
The next step is the elaboration of the protocols. We suggest the different states. This is straight forward, often consisting
to use UML-based interaction diagrams for the initial descrip- of waiting for incoming messages.
tion. In figure 3 we show the description of the recruitment 3) Discussion: Despite of the birds’ eye perspective, this
protocol together with an (still) informal text about its context procedure did not result in an abstract and minimal behavior
of appearance. description. Nevertheless, the interaction and dependency of
Interactions Bees Resources Nectar Storage
Bees Recruitment Harvest Unloading
Resources Localization - -
Nectar Storage Status Information - -
TABLE I
I NTERACTION TABLE FOR BEES AS AGENTS .
1) Identify relevant aspects (global status, global dynamics/
local entities) of the part of the model that represents the
environment.
2) Determine the primitive actions of the agent and the
reaction of the environmental entities to these.
3) Determine what information from the environment must
be given to an agent so that it can appropriately select
and perform its actions.
4) Decide on an agent architecture that is apt to connect
perceptions and actions of the agent appropriately for
actually producing the agents behavior. Concurrently, the
elements of the internal agent status are settled.
5) Use a learning mechanism for determining the actual
agent behavior. A reward function for providing feed-
back to the agents actions has to be found. The reward
schema also tackles questions such as when and how
Fig. 4. Putting together single interaction state machines into a complete often to provide feedback to the agents, whether all
agent-level graph that describes all interactions of an agent. The black nodes agents learn based on a shared reward or individual
were the initial start and end nodes of the two graphs. They are basically the reward is given to the agents.
interfaces between the two state machines .
6) Implement the environmental model including reward
function if needed.
behavior on information and material provided by others 7) Specify and implement the agents behavior program or
is treated explicitly, much more than in the agent-driven agent interfaces in combination with the chosen learning
approach. This is actually an advantage of this procedure. mechanism.
However, one can foresee problems when actual pro-active 8) Test and analyze the overall simulation results and
behavior has to be formulated. That means behavioral dy- individual trajectories carefully for preventing artifacts
namics that are not triggered by external messages. Another that come from an improper environmental model or
drawback is, that also resources and other entities that are weak interfaces (perceivable situations and effects of
basically are no agents, have to be treated as agents as every primitive actions).
interaction is formulated based on protocols. Although these 2) Example: For an illustration of this model design strat-
are then just “passive” agents, they have to be practically egy we again use the recruitment scenario although the envi-
tackled as agents for specifying the interactions. ronmental complexity is not high enough to actually require
Due to its focus on direct interaction, other forms of inter- such a procedure.
action may be hard to model, such as stigmergic interaction The start is made by formulating the environmental model.
in form of broadcasted messages that are persistent in the In this simple case the environment consists of a global world
environment decoupling sender and receiver. However, for entity managing a 2-dimensional map, a central hive entity
simulated multi-agent systems with interaction that relies on that is basically a container for the storage and a number of
message-based communication this design strategy seems to resource entities randomly distributed over the map, each with
be appropriate. an individual nectar supply.
The initial environmental configuration in this case is the
C. Environment-driven Model Design following: the hive is positioned in the center of the map.
The third strategy we want to analyze is driven by a focus Each resource is located at a random position. Every resource
on the environment. object has an attribute called “nectar supply” that is initially
1) Basic Process: In analogy to the previously discussed set according to a normal distribution.
design strategies, the starting point of the environment-driven The next step is to design the perception capabilities and
design is an analysis of the environmental structure. Based possible primitive actions – the interfaces of the bee agents.
on this, the agent interface and its behavior definition are Without particular regard on what is actually needed in the
determined. The steps are in particular: behavior definitions, we can list the following perceptions:
• perceive nearby resource, its position respectively (if nearby) complex agent-based simulation models are not well integrated
• perceive existence of resource (from a certain distance) into this design procedure.
• perceive capacity of resource (if nearby)
• perceive hive storage (if nearby) Involving learning mechanisms forms a basis for research
• perceive position display (if at hive) questions with evolutionary background. However, integrating
• perceive current nectar load agent learning into the model design makes the model suscep-
... and actions: tible for artifacts coming from incomplete, imprecise or not
• Perform random search fully elaborated reward or fitness functions. Agents that adapt
• Fly towards perceived resource to an environmental model with flaws can never reliably re-
• Fly towards hive
• Load nectar produce an original system independent how good the learning
• Unload nectar mechanism or the rest of the model is. Nevertheless, it is not
• Display resource information trivial to find appropriate feedback functions characterizing the
• Memorize perceived position
goal of the agents’ development.
One can notice that with defining this interface, the modeler Another risk of this environment-driven approach consists
also determines the abstraction level of the behavior definition in the selection of the learning mechanism. It could easily
– the environmental model alone did not fully determine the happen that no appropriate learning mechanism exists that
level of abstraction. can be used without further research. It is not so difficult to
The next step is to connect perceptions and action to reach the boundaries of what is possible using current state-of-
produce actual agent behavior. In our case this could be done art learning: involving co-adaptation, true multi-agent learning
using a rule-based approach with rules defined by the modeler. with more than a couple of agents, non-Markov settings, etc.
The simple interface that already indicates that a rule-based Then the learning problem may be too hard for finding a
approach – including some stochasticity in agents decisions for mechanism that converges within a feasible time.
some very abstract treatment of internal motivation – might be
sufficient. IV. S TRATEGIES FOR I TERATIVE M ODEL D EVELOPMENT
We may suggest the following rules determining the agent The strategies introduced above are for designing an agent-
behavior: based simulation model in one step. Especially for identifying
1) if hive-storage < A then perform random search (with probability the appropriate level of detail iterative procedures may be
pA )
2) if not at hive and not perception of resource then perform random combined with these strategies.
search
3) if perception of resource then fly towards perceived resource A. KISS: “Keep It Simple, Stupid”
4) if at resource then memorize resource information
5) if at resource then load nectar with rate load
The well known KISS principle for simulation modeling
6) if nectar load > B then fly towards hive means that the modeler should avoid unnecessary complex
7) if at hive and nectar load > B then unload nectar with rate unload models, but keep the model as simple as possible for gen-
8) if at hive and resource information memorized then display re-
source information
erating the appropriate behavior. Simple models contain less
9) if not at hive and not perception of resource then fly to hive sophisticated assumptions, can be easier explained and under-
(with probability pcancel stood. Simplicity also refers to the modeling and simulation
This set of rules is quite small, but sufficient. There are paradigm used formulating and simulating the model.
some probabilities and thresholds to be set ideally based on The starting point of this procedure is the identification and
available data. description of phenomena of the original system that should
While not necessary in the example, using a learning be contained, respectively reproduced by the final model.
mechanism might be an appropriate solution for generating Grimm and Railsback [15] call these basic modules of system
the behavior program based on the perceivable situations and data characteristics “pattern”. Examples for such pattern are a
primitive actions of the agents. A learning approach, e.g. based certain statistical distribution of tree sizes in a forest, another
on classifier systems seems to be feasible at least in this pattern is then the spatial distribution of large trees.
application example.
1) Identify and describe the set of observable
The major question in this application example is when properties (statements)
to give feedback as an information to the agent about its about the real system S.
performance: Giving feedback after each step does not make 2) Define a model M0 that is apparently too
simple for reproducing the system
sense: the random search without information is intentional. with all its properties
The agents shall not learn where the resources are positioned. 3) By calibration, determine the set SM of
Ideally, positive feedback shall be only given when the agent properties, that are reproduced
by M0 .
has accomplished to recruit other bees to a good resource 4) M ← M0
or even more delayed, the reward to all agents could be 5) Repeat Until SM = S
proportional to the current influx to the overall hive storage. a) M ← modify model M for producing more
elements in S than in the last
3) Discussion: Again one can find potential problems con- iteration.
sidering the agents internal motivations for generating true b) Calibrate M and determine SM as the set
pro-active behavior without external triggers. Such elements of of properties reproduced by M.
When this algorithm stops, the result should be the simplest Put into a more pseudo-code way of presentation, the TAPAS
model that captures all phenomena identified at the beginning strategy might look like the following procedure.
of the process.
1) Select an appropriate existing model M
However, it remains open how to modify and enlarge the 2) if M is not implemented, implement it and
model for producing the next model from the previous one. validate it using model alignment
Sometimes also side-steps might be necessary removing one with respect to published data about M .
3) Add new, additional aspects to produce Madd
model component and adding an alternative one. Finally, it is 4) Test and Validate Madd ,
not trivial to see how to modify a model best for producing if sufficient, ready, else go back to 3 or - if
any additional phenomena. In worst case, this might result in necessary to 1.
a try-and-error procedure. Nevertheless the documentation of Step 3 and 4 are similar to the KIDS methodology. The
every single model shall be elaborated that especially contains critical step is the selection (and existence) of the reusable
a list of taken assumptions. model. A sufficient documentation of the original model is
essential and can be seen as a major prerequisite for reuse
B. KIDS: “Keep it Descriptive, Stupid” [18].
In 2004, B. Edmonds and S. Moss published a plea against There are also some perils: it is not known a priori whether
in their eyes over-simplified models in social science (see the model with modification is minimal, valid, or possesses
[16]); Their major argument was: “The point is that it is the intended properties. The advantages of having a starting
simply not appropriate to make simplifications before one point have to be traded off the effort that it means to adapt
knows what is relevant and what not.” (italics in the original). the given model to the new ideas. This is very risky when the
They therefore suggest to initially construct a model with agent model for reuse is not fully understood by people that want
behavior that is understandable and directly deducible from the to reuse it.
observed behavior, but not necessary simple. Given appropriate tool support, also partial models, that
The iterative algorithm based on this KIDS-principle based means single agents, groups of agents or the complete en-
strategy can formulated as in the following. vironmental structure, may be used as a starting point for new
model development.
1) Repeat until a valid model Ms is constructed
a) Define a model M that contains all
D. Candidate-based Modeling
apparently relevant aspects of agent In his book about biological modeling in general Haefner
behavior.
b) Identify all assumptions and make explicit
[19] suggests a procedure for modeling and simulation in
all parameter in Mi . research. Basically, it consists of the construction of a set of
c) Execute a sensitivity analysis for all alternative models. They might differ in parameter settings, but
parameter of M and eliminate all blocks
of behavior that are controlled by a
may also use different architectures, etc. Each of the model
parameter without effect on candidates is calibrated and evaluated by validation. The “best”
the overall outcome. Ms is the model M model is selected and used as a basis for future research.
after sensitivity analysis
d) Test Ms for credibility and validity
This procedure is hardly about iterative changes, but involves
the treatment of several models which has to be done when
At first sight, this procedure basically resembles the usual
for example conflicting hypotheses have to be evaluated for
try-and-error strategy. It does not give any hint what to do if
possible rejection. The candidate-based strategy is generally
the model is not sufficiently valid in terms of aspects that are
applicable, but does not state how one may come to one
not reproduced; As it is less systematic than the KISS strategy,
candidate or from one candidate to another.
the KIDS strategy is more apt for experienced modelers that
know with what model to begin and how to operate if the E. Discussion
outputs are not as intended. In this section we surveyed iterative model design strategies.
We did not tackle particular design strategies for one model,
C. TAPAS: “Take a previous model, add something”
but general procedures how to proceed from a first prototype
A third strategy for model design is pragmatic and focusses to the model ready for deployment. Which of these strategy
on reuse of models. In the agent-based simulation area, it has is appropriate for a particular simulation study is depending
been coined by [17] without further discussing the term. It is on the personal style of the modeler, on his experience, on
related to the KIDS-based strategy but takes an existing model the application domain, on the available data, etc. The table II
as starting point. sums up and contrasts properties of these strategies. First, the
Reuse of models becomes the more inevitable the more appropriateness of the strategies for different types of multi-
expensive investments have been already made to produce agent simulation models is estimated. A second block refers
the model. As construction and testing of an agent-based to directed-ness of the model and minimality of the outcome
simulation is more expensive than for traditional analytical or of the modeling process. The third block of rows compares
simpler microscopic models, reusing a fully validated model aspects of necessary data availability and other properties of
should be especially interesting for agent-based simulations. the modeling process - for example how well this procedure
Strategy KISS KIDS TAPAS Cand.-
based equally thoughtful implementation, calibration, documentation
Apt for linear models high high high high and especially validation. We already tackled these phases
Apt for emergent phenomena low high mid high in an insolated way that leaves a lot of research open for
for shared-environment actors mid high mid high
Objective-orientedness high mid mid mid
combining the different solutions. This – and the application
Resulting minimality high mid low mid and test of the identified design strategies – form the next steps
Share of try & error low mid high high in the future.
Empirical data requirement mid mid low high
Integration of knowledge mid high high mid R EFERENCES
Communication support mid high mid mid
Modeling overhead mid mid low high [1] F. Klügl, “Sesam: Visual programming and participatory simulation for
Expertise in macro models high low low low agent-based models,” in Multi-Agent Systems: Simulation and Applica-
Expertise in micro models high high low high tions, A. M. Uhrmacher and D. Weyns, Eds. Taylor & Francis, 2009.
Required tool knowledge high mid mid high [2] R. E. Shannon, “Introduction to the art and science of simulation,” in
Winter Simulation Conference 1998, 1998, pp. 7–14.
TABLE II [3] N. Gilberg and K. G. Troitzsch, Simulation for the social scientist,
C OMPARISON OF ITERATIVE MODELING PROCEDURES 2nd ed. Open University Press, 2005.
[4] A. Drogoul, D. Vanbergue, and T. Meurisse, “Multi-agent based simu-
lation: Where are the agents?” in MABS 2002, 2002, pp. 1–15.
[5] M. Richiardi, R. Leombruni, N. Saam, and M. Sonnessa, “A common
protocol for agent-based social simulation,” Journal of Artificial Soci-
supports the communication of the current model status. The eties and Social Simulation, vol. 9, no. 1, 2006.
last block refers to whether the modeler needs expertise, [6] A. M. Law, Simulation Modeling and Analysis, 4th ed. McGraw-Hill,
2007.
whether he has also to tackle macroscopic relations within the [7] O. Balci, “Validation, verification and testing techniques troughout the
model – usually expressed in complex formulas, or whether life cycle of a simulation study,” Annals of Operations Research, vol. 53,
this iterative procedure is also apt for beginners in agent-based pp. 121–173, 1994.
[8] F. Klügl, “Towards a formal framework for multi-agent simulation
modeling. We assumed that tools are available that support models,” Institut für Informatik, Universität Würzburg, Tech. Rep. 412,
each of the strategies. 2007.
Using table II a modeler may select a specific iterative [9] B. Henderson-Sellers and P. Giorgini, Eds., Agent-Oriented Methodolo-
gies. IDEA Group Publishing, 2005.
strategy for finding the best model in accordance with features [10] F. Bergenti, M.-P. Gleizes, and F. Zambonelli, Eds., Methodologies and
of the simulation problem. Selection may also rely on common Software Engineering for Agent Ssytems: The Agent-oriented Software
sense heuristics: if a good previous model is accessible, then Engineering Handbook, ser. Multiagent Systems, Artificial Societies and
Simulated Organizations. Boston, London: Springer, 2004.
it is a good idea to reuse that model. If the modeler knows [11] G. Weiss and R. Jakob, Eds., Agentenorientierte Softwareentwicklung.
the system that has to be simulated very well, then the KIDS Springer, 2004.
approach should be used, whereas large holes in the system [12] Q.-N. N. Tran and G. C. Low, “Comparison of ten agent-oriented
methodologies,” in Agent-Oriented Methodologies, B. Henderson-Sellers
knowledge advise more candidate-based or KISS modeling. and P. Giorgini, Eds. IDEA Group Publishing, 2005, ch. XII, pp. 341–
All these iterative procedures may be combined with the 367.
particular design strategies identified above. [13] C. Bernon, M.-P. Gleizes, and G. Picard, “Enhancing self-organising
emergent systems design with simulation,” in Engineering Societies in
V. C ONCLUSION the Agents World VII, 7th International Workshop, ESAW 2006, Dublin,
Ireland, September 6-8, 2006 Revised Selected and Invited Papers, ser.
Model design is the phase in the development of a simula- Lecture Notes in Computer Science, G. M. P. O’Hare, A. Ricci, M. J.
O’Grady, and O. Dikenelli, Eds., vol. 4457. Springer, 2007, pp. 284–
tion model, that requires most experience and skills[2]. This 299.
is true for all forms of simulation modeling, in particular [14] A. Dornhaus, F. Klügl, C. Oechslein, F. Puppe, and L. Chittka, “Benefits
for the development of multi-agent simulation models. In of recruitment in honey bees: effects of ecology and colony size in an
individual-based model,” Behavioral Ecology, vol. 17, no. 3, pp. 334–
this contribution we have identified and discussed different 344, 2006.
strategies for model design – one shot or iterative. The latter [15] V. Grimm and S. F. Railsback, Individual-Based Modeling and Ecology.
can be combined with the former for really developing a Princeton University Press, 2005.
[16] B. Edmonds and S. Moss, “From kiss to kids - an ’anti-simplistic’
well designed model. Even, if the resulting model is not modelling approach,” in Multi-Agent Based Simulation, ser. LNAI, P. D.
significantly “better” than a model developed without these et al., Ed., no. 3415. Springer, 2004, pp. 130–144.
strategies, their application has the great advantage that they [17] A. Pyka and G. Fagiolo, “Agent-based modelling: A methodol-
ogy for neo-schumpeterian economics,” Universität Augsburg, Volk-
support a systematic development and at least partially guide swirtschaftliche Diskussionsreihe, Tech. Rep. 272, 2005.
the development. Nevertheless, the different strategies have to [18] C. Triebig and F. Klügl, “Elements of a documentation framework for
be further tested and elaborated in various simulation studies agent-based simulation models,” Cybernetics and Men, accepted 2009.
[19] J. W. Haefner, Modeling Biological Systems – Principles and Applica-
with different degrees of necessary model complexity. tions, 2nd ed. New York: Springer, 2005.
The vision behind our research is developing a methodology [20] J. D. Sterman, Business Dynamics: Systems Thinking and Modeling for
for successful development of multi-agent simulation studies. a Complex World. Boston: McGraw Hill, 2000.
The idea is to develop a methodology similar to System
Dynamics [20] that allows the development of difference
equation models starting from causal loop graphs to systems of
formulas in a guided and systematic way. In agent-based sim-
ulation, systematic model design has to be accompanied with