Fishwick P.A. (editor) Handbook of Dynamic System Modeling
Подождите немного. Документ загружается.
7-18 Handbook of Dynamic System Modeling
to describe application data models that can be fed to EMF in several formats. The native input format is
an XML file, which can be produced from UML class models by tools like Rational Rose. Java source code
that is annotated appropriately can also be converted into ECore models. EMF provides a code generator
(called java emitter templates, or JET) that is capable of translating models that conform to the ECore
into Java. Based on the input to ECore, the EMF.Codegen can generate a basic model editor following
the schema. The editor uses classes from the EMF.Edit framework to provide standard table and property
sheet views. Most modeling projects have extended the EMF.Edit framework with customized capabilities.
The EMF itself does not produce graphical editors—other eclipse plug-ins that provide such capabilities
have been integrated with EMF.
Microsoft has committed to the DSM community by initiating a metamodeling tool that is integrated
within Visual Studio (Microsoft DSL) and tied to the software factory vision (Greenfield et al., 2004). At
the time of this writing, this tool is still in beta mode and represents one of the newer entries in this space
of representative tools. The current state of the MS DSL tools support the definition of a modeling editor
as specified from a project wizard. A template-based code generator is available from which generic code
can be instantiated with various placeholders representing data obtained from a model.
Given the numerous tool suites that support DSM, it is often desirable to share models among different
tools. In fact, initial consideration has been given toward bridging the gap between EMF and Microsoft
DSL models (Bézivin et al., 2005). The ability to exchange models among tools has several obstacles such
as: (1) the syntactic problem of sharing the information within a model across different data formats, (2)
the semantic problem of resolving the meaning of a model as expressed across different metamodels that
may describe common properties of the same domain, and (3) the infrastructure problem resulting from
tools that are open, but have different APIs to access the underlying representation. An approach to tool
integration that addresses these problems is to consider patterns of interaction and configuration within
a tool integration framework (Karsai et al., 2005).
7.5 Conclusion
This chapter presented an introduction to DSM, including an overview of general concepts as well as case
studies to illustrate the potential for application. From our own collective experience, DSM offers an order
of magnitude improvement in productivity in those environments that are tied to software product lines
that can be configured across multiple alternative design spaces. Although the future outlook for DSM
looks promising, there is still much research and development needed to improve the capabilities provided
by supportingmodeling tools. Issues related to group or team modeling (e.g., version controlof models that
are distributed among a globally dispersed team) are being explored, but additional functionality is needed
to make DSM tools popular beyond specific niche domains. In addition to future technical developments,
there is also a need to combat the organizational culture to promote adoption. This has been stymied by
the stigma associated with the past failures of CASE tools (i.e., many who are first introduced to DSM
mentally create a link back to the limitations of past CASE environments). This chapter described the
flexibility and productivity that can be achieved by a modeling environment that can be tailored to a
specific domain to generate applications from higher-level abstractions.
Acknowledgment
This work was supported in part by an NSF CAREER grant (CCF-0643725).
References
Alderson, A. Meta-CASE Technology. 1991. Software Development Environments and CASE Technology,
Proceedings of European Symposium, Königswinter, Germany, pp. 81–91.
Domain-Specific Modeling 7-19
Balasubramanian, K., J. Balasubramanian, J. Parsons, A. Gokhale, and D. Schmidt. 2005. A platform-
independent component modeling language for distributed real-time and embedded systems.
IEEE Real-Time and Embedded Technology and Applications Symposium, San Francisco, California,
pp. 190–199.
Bézivin, J. 2005. On the unification power of models. Journal of Software and System Modeling, 4(2):
171–188.
Bézivin, J., G. Hillairet, F. Jouault, I. Kurtev, and W. Piers. 2005. Bridging the gap between the MS/DSL tools
and the Eclipse Modeling Framework. OOPSLA Software Factories Workshop, San Diego, California.
Booch, G., J. Rumbaugh, and I. Jacobson. 1998. The Unified Modeling Language User Guide. Redwood
City: Addison-Wesley.
Budinsky, F., D. Steinberg, E. Merks, R. Ellersick, and T. Grose. 2004. Eclipse Modeling Framework.
Redwood City: Addison-Wesley.
Chen, M. and J. Nunamaker. 1989. METAPLEX:An integrated environment for organization and informa-
tion systems development. Proceedings of the Tenth International Conference on Information Systems,
Boston, Massachusetts, pp. 141–151.
Clements, P. and L. Northrop. 2002. Software Product Lines: Practices and Patterns. Redwood City: Addison-
Wesley.
Czarnecki, K. and U. Eisenecker. 2000. Generative Programming: Methods, Tools, and Applications.
Redwood City: Addison-Wesley.
Davis, V., J. Gray, and J. Jones. 2005. Generative approaches for application tailoring of mobile devices.
43rd ACM Southeast Conference, Kennesaw, Georgia, pp. 237–241.
de Lara, J. and H. Vangheluwe. 2002. Using AToM3 as a meta-Case tool. Proceedings of the International
Conference on Enterprise Information Systems, Ciudad Real, Spain, pp. 642–649.
DSMForum. The Domain-Specific Modeling Forum, http://www.dsmforum.org/
Gokhale, A., D. Schmidt, B. Natarajan, J. Gray, and N. Wang, 2004. Model-Driven Middleware. In
Middleware for Communications, Q. Mahmoud (Ed.), New York: Wiley, Chap. 7, pp. 163–187.
Gray, J., M. Rossi, and J.-P. Tolvanen. 2004. Preface: Special issue on domain-specific modeling. Journal of
Visual Languages and Computing, 15(3–4): 207–209.
Greenfield, J., K. Short, S. Cook, and S. Kent. 2004. Software Factories: Assembling Applications with
Patterns, Models, Frameworks, and Tools. New York: Wiley.
Henriques, P. R., M. J. V. Pereira, M. Mernik, M. Lenic, J. Gray, and H. Wu. 2005. Automatic generation of
language-based tools using LISA, IEE Proceedings—Software, 152(2): 54–69.
Johnson, L. (James). 1998. A view from the 1960s: How the software industry began. IEEE Annals of the
History of Computing, 20(1): 36–42.
Kelly, S., M. Rossi, and J.-P. Tolvanen. 2005. What is needed in a MetaCASE environment? Journal of
Enterprise Modeling and Information Systems Architectures, 1(1): 25–35.
Karsai, G., A. Lang, and S. Neema. 2005. Design patterns for open tool integration. Journal of Software and
System Modeling, 4(2): 157–170.
Karsai, G., J. Sztipanovits, Á. Lédeczi, and T. Bapty. 2003. Model-integrated development of embedded
software. Proceedings of the IEEE, 91(1): 145–164.
Kotteman, J. and B. Konsynski. 1984. Information systems planning and development: Strategic postures
and methodologies. Journal of Management Information Systems, 1(2): 45–63.
Lédeczi, Á., A. Bakay, M. Maroti, P. Volgyesi, G. Nordstrom, J. Sprinkle, and G. Karsai. 2001. Composing
domain-specific design environments. IEEE Computer, 34(11): 44–51.
Long, E., A. Misra, and J. Sztipanovits. 1998. Increasing productivity at Saturn. IEEE Computer, 31(8):
35–43.
Mernik, M., J. Heering, and A. Sloane. 2005. When and how to develop domain-specific languages. ACM
Computing Surveys, 37(4): 316–344.
MetaCase. MetaEdit+ 4.5 User’s Guide. http://www.metacase.com
Microsoft DSL. Visual Studio Launch: Domain-Specific Language (DSL) Tools: Visual Studio 2005 Team
System. http://msdn.microsoft.com/vstudio/dsltools/
7-20 Handbook of Dynamic System Modeling
Nokia Python. Python for Series 60: API reference. http://www.forum.nokia.com
Nokia S60. S60 SDK Documentation. http://www.forum.nokia.com
Peterson, J. 1977. Petri Nets. Computing Surveys, 9(3): 223–252.
Pocock, J. VSF and its relationship to open systems and standard repositories. 1991. In Software
Development Environments and CASE Technology, A. Endres and H. Weber (Eds.), Berlin:
Springer-Verlag.
Pohjonen, R., and S. Kelly. 2002. Domain-specific modeling. Dr.DobbsJournal, 27(8): 26–35.
Spinellis, D. 2001. Notable design patterns for domain specific languages. Journal of Systems and Software,
56(1): 91–99.
Sztipanovits, J. and G. Karsai. 1997. Model-integrated computing. IEEE Computer, 30(4): 110–111.
Teichroew, D., P. Macasovic, E. Hershey, and Y. Yamamoto. 1980. Application of the entity-relationship
approach to information processing systems modeling. In Entity-Relationship Approach to Systems
Analysis and Design, P. P. Chen (Ed.), Amsterdam: North-Holland.
van Deursen, A., P. Klint, and J. Visser. 2000. Domain-specific languages: An annotated bibliography. ACM
SIGPLAN Notices, 35(6): 26–36.
8
Agent-Oriented Modeling
in Simulation: Agents for
Modeling, and Modeling
for Agents
Adelinde M. Uhrmacher
University of Rostock
Mathias Röhl
University of Rostock
8.1 Introduction .................................................................. 8-1
8.2 Agents for Modeling in Simulation .............................. 8-3
Using the Agent Metaphor for Understanding in Simulation
•
Using the Agent Metaphor for Designing in Simulation
8.3 Modeling and Simulation for Agents ........................... 8-6
Modeling and Simulation for Understanding
Multiagent Systems
•
Simulation for Designing
Multiagent Systems
8.4 Conclusion .................................................................... 8-10
8.1 Introduction
The relations between agents, modeling, and simulation are manifold (Uhrmacher et al., 2001). In relating
agents and simulation research, we will concentrate on using agents as a metaphor to model the system of
interest and on using virtual dynamic environments to analyze the behavior of multiagent software systems.
Thereby, modeling aspects rather than the many challenges of an efficient execution shall be the focus.
Before starting our exploration, we will shortly introduce agents and discuss some characteristics that
also influence the relation between agents and simulation.
A common perspective originates agents in artificial intelligence (AI) and distributed artificial intelli-
gence (DAI) methods; even if most existing agent-oriented approaches seem to be complacent with agents
that utilize only a small portion of intelligence (Wooldridge and Jennings, 1998). The goal of AI is to
let machines do things that would require intelligence if done by humans: intelligence being typically
interpreted as the ability to learn and understand, to solve problems, and to make decisions (Russell
and Norvig, 2003). The interaction between AI software and environment was typically mediated by the
user: an intelligent machine should help humans to make decisions (Negnevitsky, 2002). Real-time expert
systems aimed at online diagnosis were among the first to address issues of a direct interaction with a
dynamic, continuous environment including sensing and acting, timeliness of reactions, incompleteness,
and uncertainty of available information. This interaction with an environment which is continuous, not
entirely accessible, and dynamic has become an intrinsic part of the agent metaphor and has challenged
and propelled research in knowledge representation, evaluation, planning, and learning likewise.
While AI starts from individual cognition and individual systems, DAI examines the properties of
distributed, interacting AI programs. Whereas individual AI systems are increasingly designed as single
agent systems working in dynamic environments, e.g., Pollack et al. (2003), DAI focuses on multiagent
systems (O’Hare and Jennings, 1996): “DAI is the study, construction, and application of multiagent
8-1
8-2 Handbook of Dynamic System Modeling
systems, that is, systems in which several interacting, intelligent agents pursue some set of goals or perform
some set of tasks” (Weiss, 2000). One motivation for DAI was that intelligent behavior might more easily
come into being by the coordination of multiple entities. Intelligent behavior as an emergent phenomenon
holds some natural attraction, because at first glance it seems to release researchers from the problem to
implement intelligent behavior explicitly. However, it still has to be decided how entities on microlevel
should look like to enforce the desired effect on macrolevel and what the communication mechanisms and
conventions of a “civilized” discourse for effective problem solving are. This discussion has been circling
around reactiveness and deliberativeness and their role in realizing intelligence (Brooks, 1991; Etzioni,
1993). Whereas in the latter the entities constitute knowledgeable agents with symbolic representation
and reasoning skills, based on explicit knowledge about themselves and their environment, the former do
not possess such an explicit model, their behavior is determined by simply “reacting” to environmental
changes. How to combine the ability to react and the deliberativeness to solve problems effectively is one
of the major challenges in designing agents for dynamic, uncertain environments.
Sociology has had an impact on agent-based research from the outset, interpreting multiagent sys-
tems as societies. The functioning of societies and what role individual behavior plays is the subject of
individualistic social theory. One argumentation line explains the development of societies as structured
exchange relations between independently acting individuals. Social order and cooperation emerges from
the unintended interaction of multiple agents in a framework of decentralized coordination. Another argu-
mentation line emphasizes contracts, norms, and intentional cooperation in achieving desirable goals in
the society and thus reflects a view of agents as being“deliberative”rather than“reactive”(Conte et al., 2001;
Gilbert and Troitzsch, 2005). “Reactive”agents and the functioning of societies is also the subject of biolog-
ical studies on ant and bee societies, insights which were also used in developing software agent solutions,
e.g., in network routing. Thus, social theories have an impact in designing better, e.g., more robust and effi-
cient software systems. In the opposite direction, multiagent systems as a modeling metaphor support the
testing of sociological hypotheses by simulation. Thereby, the knowledge about social systems is enhanced.
Rather the efficient and reliable handling of multiple, concurrent, and interacting individuals than the
achievement of the desired intelligent overall behavior motivated the involvement of the area of distributed
systems in multiagent research. This becomes most obvious in the field of mobile agents, where agents are
no longer dependent on one computer to be executed. Mobile code and data migrate from one computer
to the next. Thereby, they cope more easily with network connections that are only temporarily available
and have a limited bandwidth (Tanenbaum and van Steen, 2002). Typically, distributed systems require
a balance between decentralized and central strategies, which requires answering how much a single node
must know, who is in control, and what cooperation strategies to apply. This leads us back to central
questions in DAI and social theories.
By illuminating the background of agents, we have already revealed their central characteristics. The
least common denominator for most researchers and users is to associate agents with autonomy, which
refers to the ability to act without permanent guidance.
Some kind of intelligence is needed if agents shall decide for themselves what they need to do to satisfy
their design objectives. In this context, reactive, proactive, and social abilities are required (Wooldridge,
2000).
Since the beginning of agent-based development, the question of differentiation has loomed: is it an
agent or just a program, an object, or a component for reuse? Although a general answer to this question
seems elusive, compared with objects, agents embody a stronger notion of autonomy in the sense that they
have controlover their actions: agents can say“no”and“go”(Odell, 2002). Thus, agents can be interpreted as
reflective concurrent objects and a community of agents as a special type of concurrent, distributed system.
Components can be used to implement agents (Melo et al., 2004); however, with components neither an
own thread of control is associated, nor a functioning in a dynamic environment (Casagni and Lyell, 2003).
Most agent definitions make use of the term “environment.” For agents it is central to be able to operate
robustly in rapidly changing, unpredictable, and open environments (Wooldridge, 2002). This dynamic
environment, the described properties, and the different backgrounds shape the multiple facets of the
relationship that has formed between simulation and agents.
Agent-Oriented Modeling in Simulation 8-3
A simulation is an experiment based on a model and performed on a computer, aimed at exploring
the behavior of a dynamic system. If the dynamic system itself or parts of it are interpreted as agents, the
modeling is shaped accordingly to distinguish between these different autonomously interacting entities.
The resulting model design is necessarily nonmonolithic, and similarities between agent-based modeling
and multilevel, individual-based, and/or object-oriented modeling are plentiful (Uhrmacher, 1997).
Another dimension that relates agents to simulation is the question whether agent-oriented software
approachescanbe utilized in realizing and implementing flexible simulation environments,e.g., to facilitate
reusing models and interoperating between different simulation systems. In the latter case, agents are not
subject of modeling and simulation but a metaphor used to develop flexible simulation systems.
Agent-based systems are often mission critical (or even safety critical) and, like other software systems,
must be tested and evaluated before being deployed. Thus, a third dimension in relating agents and
simulation is that simulation can help designing multiagent systems. It is used as an experimental technique
for evaluation.
Whereas in the last case simulation helps to develop software agents, in the former two cases agents are
used for modeling and designing simulation systems. Thus, we find both directions: simulation for agents
and agents for simulation (Uhrmacher et al., 2001; Yilmaz and Ören, 2005). As a metaphor, agents improve
understanding and designing certain systems. This also applies to simulation. Simulation is typically used
in certain areas for a better understanding, in other areas to support the concrete design of systems.
Furthermore, both agents and simulation are used for entertainment and training.
In the following, our exploration shall be focused on how the agent metaphor is used for modeling
and thereby enhances the understanding or design of the system that is simulated, and subsequently how
simulation is used as an experimental technique to improve the understanding and to support the design
of software agents.
8.2 Agents for Modeling in Simulation
The multiagent metaphor, perceiving a dynamic system as a community of autonomously interacting
entities, has started permeating many application areas of modeling and simulation. Modeling means
structuring the knowledge about a given system. In psychology, sociology, and biology, where little is
known about the system of interest, modeling and simulation are used for falsifying or supporting theories
(Gilbert and Troitzsch, 2005). The more is known about a system, the more modeling and simulation are
aimed at designing or manipulating systems. This design-oriented approach is traditionally found when
dealing with “man-made” systems, e.g., in manufacturing and traffic systems. At first glance, agents as a
metaphor seems similar to other metaphors used before. However, at second glance it shows multiple facets,
as, although having often an anthropomorphic flavor, the ingredients of agents are not commonly agreed
upon. On the one side, this has made deriving a uniform agent modeling formalism or reference model for
agents illusive, on the other, it has propelled the propagation of the metaphor in diverse application fields.
8.2.1 Using the Agent Metaphor for Understanding in Simulation
Generally, simulation of biological, ecological, or social systems focuses on analyzing and predicting rather
than on designing systems. These systems are typically not well understood, component libraries as in
technical domains are not available, and thus typically modeling starts from scratch. The question when
to use agents for modeling is only one facet of the central question in modeling: at which level of detail
shall the system be described (Gilbert and Troitzsch, 2005)? Whereas simplicity of a model has long been
interpreted as a quality in itself, this seems no longer be commonly agreed upon, neither in sociology or
economy (Axtell, 2000) nor in biology (Chen et al., 2004).
If we are interested in the activities of a small number of actors with frequent stochastic fluctuations
and stepwise motions, we would likely opt for a discrete, stochastic model to describe the involved actors
individually. In contrast, behaviors that involve a large amount of entities are typically described at the
macrolevel. Quantitative changes are represented traditionally and effectively by differential equations.
8-4 Handbook of Dynamic System Modeling
Sometimes it makes sense to aggregate and other times to explicitly and individually track entities within
the simulation resulting in individual-based simulations. Individual-based simulation belongs to the
class of multilevel simulation where phenomena observed at the macrolevel are produced by the entities
located on microlevel (Knorr-Cetina and Cicourel, 1981; Bunge, 1979). When the individuals in the
model are usefully characterized as having some sort of cognitive processes, individual-based turns into
an agent-based approach (Gilbert, 2005).
Thus, agent-based models shift the focus to the individuals’ intentions, desires, and beliefs (Ferber,
1999). Although intentions, like the wish to reproduce or to allay hunger and thirst, might direct the
behavior of individuals, these decision processes are often not part of the model, as they are not of main
interest. So, the appropriateness of the agent metaphor depends on the system to be described and on the
objective of the simulation study, for example, we can treat a light switch as a (very cooperative) agent;
however, “... it does not buy us anything, since we essentially understand the mechanism sufficiently to
have a simpler, mechanistic description of its behaviour”(Shoham, 1993). Agent-based models are neither
ipso facto preferable to other modeling approaches nor vice versa. The complexity of the model should be
related to the complexity of the problem (Edmonds and Möhring, 2005).
As do multilevel simulations in general, agent-based approaches turn the attention to interacting indi-
viduals and the emerging macropatterns on the institutional level (David et al., 2003). In addition, they
support the simulation of heterogeneous social communities that embrace reactive and deliberative actors
likewise (Doran et al., 1996). In combination with cellular automata, agent-based models allow to capture
the interplay of deliberative decisions and spatial dynamics, e.g., the growth of cities (Batty, 2005). Thereby,
agent-based models move the interrelations between decision processes based on norms and preferences
and the dynamics of communities into the focus of exploration. Let us illustrate this with an example.
A premodern town has been described based on agents (Ewert et al., 2003). Three actor groups, i.e.,
merchants, craftsmen, and laborers, form the town’s population and are modeled as agents which behave
according to the assumption of utility and profit maximization. They are interacting as consumers and
suppliers via several markets, e.g., a grain market, a consumer good market, and a labor market. The local
authorities are modeled as a planning agent which decides upon a course of interventions into market and
social structures.
Disasters are induced into the model, provoking reactions of actors according to their preferences
and intentions. Macrolevel effects can be observed that are not intended by the individual actors, but
are characteristic for premodern mortality crises. Thus, this simulation model allows to experiment
with actors’ intentions and preferences, to mimic disasters leading to mortality crises, and to trace the
courses of economic and demographic developments in the aftermath of such crises. The local authorities
are described as a typical belief-desire-intention (BDI) agent (Rao and Georgeff, 1995), whereas the
other actors are utility-based agents (Russell and Norvig, 2003). Figure 8.1 shows the beliefs of the local
authorities about the situation at hand, the current desires, and the actions that are planned to take. The
local authorities belief that laborers are not contented and the price for grain is high, whereas for labor
it is low. To content the laborers and turn prices to normal, stored grain is supplied to the market and
labor is demanded via a job program by the local authorities. Because these actions also take effect on the
merchant’s and craftsmen’s contentedness, the local authorities have to decide on further interventions on
the tax and the guild system.
The project revealed that the desires of the local authorities have a significant influence on the pace of
disaster discovery—especially that short-term leveraging in favor of single actor groups, e.g., merchants,
may even intensify a crisis in the long run. However, the central problems in an agent-based modeling
and simulation remain: How to justify the made assumptions and validate the chosen model (Doran,
1997)? Whereas the utility-based agents could be based upon theories in microeconomy, the design of the
local authorities was based on knowledge about frequent intervention schemes in premodern towns and
speculation. Only a face validation of the model was possible. Still the model and simulation increased
the understanding of the system and inspired some “Gedankenexperimente” that a less expressive model
would not have motivated.
Thus, agent-based simulation appears what some areas have been waiting for, i.e., “...to provide the
social sciences with conceptual and experimental tools, namely the capacity to model, and make up in
Agent-Oriented Modeling in Simulation 8-5
Supply grain
Demand labor
Intentions
Start
Price (grain, high)
Cont (laborers)
Cont (merchants)
Price (labor, low)
Cont (craftsmen)
Lower consume tax
Cont (merchants)
Install guild limit
Cont (craftsmen)
Finish
Cont (merchants)
Cont (craftsmen)
Cont (laborers)
Price (grain, high)
Price (labor, low)
Desires
Cont (merchants)
Cont (craftsmen)
Cont (laborers)
Actions
Demand Grain()
Supply Grain()
Increase ConsumeTax()
. . .
Planner
Beliefs
FIGURE 8.1 Sample plan generation by a deliberative agent that represents the local authorities in a premodern
town.
parallel, reactive and cognitive systems, and the means to observe their interactions and emerging effects”
(Conte and Castelfranchi, 1995).
8.2.2 Using the Agent Metaphor for Designing in Simulation
Simulation is also used for designing systems, i.e., to explore the implications of different design alter-
natives. If the performance of the system under study depends on the behavior of human individuals or
institutions, the agent metaphor can be exploited. As in the previous section, the agent metaphor is used
for modeling. However, it is no longer the objective of the simulation study to get insights into the behavior
and motivations of human or biological communities, but to mimic the behavior sufficiently well to allow
a good design of the technical system.
A human behavior representation (HBR) is a “model that mimics either the behavior of a single human
or the collective action of a team of humans” (Pew and Mavor, 1998). Research on HBRs has strongly
been driven by the military community, namely the U.S. Department of Defense Modeling and Simulation
Office (DMSO), and lately by research on home security. Typically, an HBR model is understood primarily
as a “representation of the decision making processes [...] of humans” (Wise et al., 2001), and “the details
of how individual humans actually accomplish tasks—that is, the psychological theory—is [...] irrelevant
as long as the behavioral output seems realistic” (Pew and Mavor, 1997). In contrast to work in related
fields, such as human modeling or human factors research, HBR research does neither try to output
any new evidence on human cognition nor does it need to realistically mimic physiological processes.
Nevertheless, the fields are interrelated: HBR design is based on psychological and medical findings (Wise
et al., 2001; Silverman, 2003).
Traffic simulation is one of the prominent areas where agents are employed to describe the behavior of
individuals (Helbing and Nagel, 2004) and help exploring the effects of different traffic control strategies
and thereby the design of traffic systems. To enhance the validity of traffic simulations, human behavior
representation plays a central role. Typically, a physical motion model (including information about streets,
intersections, surface, and speed limits) is combined with a mental model, which represents individual car
8-6 Handbook of Dynamic System Modeling
drivers. Over the years models of the individuals have been gradually enriched. Classical traffic simulations
use origin–destination matrices that aggregate individual mobility. Current approaches take a hierarchical
approach. Overall behavior patterns are selected, appropriate locations assigned, timings determined,
and finally routes calculated (Balmer et al., 2004). These are more realistic than traffic models based on
averaged behavior and they are easily extensible and amenable to parallel execution. An important agent
feature for traffic simulation is learning: route choice may be revised day today and within the day given
the situation at hand.
Human behavior modeling in traffic systems exploits the agent metaphor to simulate realistic individual
behavior and thereby stimulate emergent phenomena (e.g., traffic jams). Herein, agents work without
explicit communication and use implicit coordination and social laws (Klügl and Bazzan, 2004).
Whereas to model humans seem the natural place to employ the agent metaphor, also technical sys-
tems sometimes lend themselves to be perceived as communities of interacting autonomous entities. If
characteristics like distribution, heterogeneity, and self-organization match, the system to be designed
can be thought of as a multiagent system. If agents and related concepts become the key abstractions for
structuring these systems, they shape also modeling these systems.
The agent metaphor is especially useful if autonomous entities should be developed that are situated
within an environment, e.g., to develop suitable decentral control strategies for manufacturing systems
(Parunak, 1999), or if heterogeneous entities are involved and coordination and communication becomes
important, e.g., to manage supply chains efficiently (Baumgaertel et al., 2003), which involve different alter-
native producers. Adopting the agent metaphor in modeling those systems helps reducing the complexity
by decomposing the whole system into smaller pieces.
In contrast to human behavior representation, these approaches take no advantage of intensive cog-
nition abilities of an individual agent, but use a set of more light-weight agents for distributed problem
solving (Parunak, 1997). Herein, the autonomy of the agents is complemented with social abilities and
communication becomes the enabling factor for coordination. For example, controlling manufacturing
processes based on unmanned transportation vehicles is a nontrivial problem involving routing, collision
avoidance, and deadlocks avoidance. Centralized approaches to control manufacturing processes are com-
putationally complex and time-consuming. Weyns et al. (2005b) suggest a decentralized control based on
autonomous, cooperative agents to realize flexible and open manufacturing systems. Flexibility is gained
from agents that are able to locally commit to transport jobs and react to opportunities as they appear.
Openness stems from the easiness of adding (or removing) vehicles to (from) the model and the facility.
So far, we have concentrated on the agent metaphor that is used in describing the system under study.
However, as the last example has shown, using the metaphor in modeling for designing can imply that the
system to be designed is perceived as a community of agents. If this system comprises software, obviously
pieces of the software to be designed are interpreted as agents. Thus,we arrive at the point where simulation
is used to test software agents. In the next section, we will no longer emphasize the view of using the agent
metaphor for modeling, but approach the field from the point of view that there are software agents that
shall be evaluated and tested in virtual dynamic environments.
8.3 Modeling and Simulation for Agents
Simulation provides a means for systematically analyzing the behavior of agents in dynamic virtual
environments (Helleboogh et al., 2006). The development of agents faces problems associated with tra-
ditional distributed concurrent systems. Additional difficulties arise from complex interactions between
autonomous problem-solving components (Jennings et al., 1998). Agent-based systems are often mission
critical (or even safety critical) and, like other software systems, must be tested and evaluated before being
deployed. However, their autonomy and the open heterogeneous nature of the environment in which
they operate make testing and evaluation difficult. Often, existing formal notations are either too weak to
express the structure and state of the agent and its environment, or if formalization is possible, the resulting
formulations are intractable. Consequently, it can be difficult to verify their properties. One alternative is to
Agent-Oriented Modeling in Simulation 8-7
test them in virtual environments. Thereby, the design of multiagent systems might become an application
area for simulation tools similar to the design of manufacturing systems or network protocols.
We wish to now explore the role of simulation to help understanding and designing agents. This
discussion will be based on a controversy put forward in a publication by Paul Cohen, Steve Hanks, and
Martha Pollack at the beginning of the 1990s. They discussed the role of controlled experimentation in
agent design in general and that of small world testing in particular (Hanks et al., 1993). In the following
discussion, the focus will change from agents to their environment.
8.3.1 Modeling and Simulation for Understanding Multiagent Systems
Test beds offer sets of test scenarios are aimed at revealing prototypical problems in dynamic environments.
They fill the gap between purely synthetic benchmarks and the deployment of agent systems within real
environments. Since the beginning of research on agents, a series of test beds have been developed that
provide dynamic environments to conduct controlled experimentation with agents in well-defined settings
(Hanks et al., 1993). Test beds are simplified problem domains and facilitate testing in the small, i.e., rather
isolated questions can be explored. The primary intent is not to confront the agent with a valid model of
the concrete environment the agent shall dwell in. Instead, it aims at presenting a simplistic world in which
properties of a concrete agent or a simplified version of an agent can be analyzed in isolation—of course,
finding such “correct” simplifications is a very crucial part in the experimentation process. Test beds help
to explain and understand why agents behave as they do by illuminating behavior facets of a given agent
architecture.
To assess the behavior of an agent architecture,experimenting with one test scenario will hardly suffice. In
general, software systems are not evaluated based on one benchmark result only. The implementation and
application of dynamic scenarios requires more effort than that of conventional benchmarks. Accordingly
rare are the examples where an agent architecture has been systematically tested in several dynamic
scenarios.
Many scenarios have been developed together with the agent architectures to be tested. Thus, agent
architecture and test environment are often closely coupled. There are only few examples where one
scenario has been used to test different agent architectures. One of them is the T
ILEWORLD (Pollack and
Ringuette, 1990) scenario that was developed to investigate commitment strategies. T
ILEWORLD consists
of a grid of cells with tiles, obstacles, holes, and agents on it. The agents’ task is to fill holes with tiles.
The developed plans of how to optimally fill the different holes are subject to change as the environment
changes by its own dynamics (holes and tiles appear randomly).
T
ILEWORLD has been picked up by several other research groups to evaluate agent architectures (Philips
and Bresina, 1991; Kinny and Georgeff, 1991; Goldman and Rosenschein, 1994; Clark et al., 1997). In
the course of adopting the T
ILEWORLD to test single- or multiagent systems, however, it has been adapted
to the researchers’ objectives and needs, which hampers comparing different agent architectures based on
the results achieved. Therefore, it has not the role of a benchmark, but provides a type of scenario in
which design alternatives can be tested. The extension of the original T
ILEWORLD scenario to analyze the
behavior of multiagent systems (Ephrati et al., 1995) brings it close to another type of scenario which
permeates the literature: variants of predator prey models explicitly designed for multiagent systems (Agre
and Chapman, 1987; Doran et al., 1994; Wooldridge and Vandekerckhove, 1994; Luck et al., 1997). In this
context, the interaction, coordination, and cooperation strategies are of central interest.
Cooperation, i.e., teamwork, and fast reactions are at the bottom of another test scenario for multiagent
systems, which has gained popularity since the International Joint Conference on Artificial Intelligence
1997 in Japan: the soccer game. In addition to a robot league, a simulation league is held (Kitano et al.,
1997; Tambe et al., 1999), in which a soccer simulator provides the common environment for evaluating
different strategies of virtual robots.
In 1999, another scenario has been proposed to test agent architectures: RoboCup-Rescue (RCR) (Kitano
and Tadokoro, 2001) and spurred a lot of research activities. The challenges are the number of agents
(100 and more), a heterogeneous, partly hostile environment, real-time pressure, uncertain and limited