On the Modeling, Refinement and Integration of Decentralized Agent Coordination
– A Case Study on Dissemination Processes in Networks
Jan Sudeikat1 and Wolfgang Renz
Multimedia Systems Laboratory (MMLab),
Faculty of Engineering and Computer Science, Hamburg University of Applied Sciences,
Berliner Tor 7, 20099 Hamburg, Germany
{jan.sudeikat | wolfgang.renz}@haw-hamburg.de
Abstract—The establishment of self-organizing processes in
distributed software systems allows to equip applications with
adaptive features that rise from the (inter-)actions of agents.
In this paper, we address the systematic design of the coaction
of system elements to enforce the rise of these processes in
Multi-Agent Systems (MAS). A systemic programming model
is utilized that supports the conception and realization of
feedback loop patterns by modeling causal interdependencies
between agent activities. The integration of these pattern in
agent-based software systems is guided by a reference architecture and a prototype implementation provides a framework to
automate their enactment. Based on this programming model,
the systematic design of decentralized agent coordination is
approached by the incremental refinement of coupled feedback
loop structures. This development approach is exemplified in
two simulation scenarios, where epidemic information dissemination is integrated in MAS.
Keywords-decentralized coordination; systemic modeling; coordination architecture;
I. I NTRODUCTION
The increasing size and complexity of today’s distributed
software systems demands novel engineering approaches. A
recurring problem is to enable the adaptiveness of inherently decentralized system architectures and the utilization
of self-organizing processes has been proposed [1]. SelfOrganization describes concerted phenomena, where the
coaction of autonomous system entities gives rise to global
structures [2]. These phenomena can be found in physical,
biological, social as well as artificial systems [3] where
structures are established and adapted.
Agent-based development approaches facilitate the construction of self-organizing systems by providing concepts and tools to realize software applications as sets of
autonomous software elements, i.e. Multi-Agent Systems
(MAS) [4]. In addition, interactions in system environment(s) are supported [5].
The construction of collective phenomena, e.g. selforganizing processes, faces the fundamental challenge how
1 Jan Sudeikat is doctoral candidate at the Distributed Systems and
Information Systems (VSIS) group, Department of Informatics, Faculty of
Mathematics, Informatics and Natural Sciences, University of Hamburg,
Vogt–Kölln–Str. 30, Germany, [email protected]
to revise local entity designs to enforce the manifestation of
inter-agent processes that give rise to global system properties. The major tools to bridging this gap are simulationbased development processes [6], design patterns [7, 8] and
formal modeling techniques [9].
In this paper, we want to stimulate further softwaretechnological utilizations of self-organized coordination. Coordinating processes are modeled as networks of mutual interdependencies between system elements. In natural and artificial self-organizing systems, the activities/configurations
of individual system elements, e.g. particles, cells, and
software agents, influence each other. The exhibited interdependencies form feedback loops [2] that steer the collective,
localized adjustment of system elements. In recent works,
a systemic modeling level to MAS has been proposed [10],
that supplements agent-oriented modeling techniques with a
description-level that focuses on these interdependencies to
express decentralized coordination processes. A corresponding programming model comprises a configuration language
[10] and reference architecture [11] to enact distributed
feedbacks loops in MAS.
In this submission, we argue that the utilization of the systemic programming model enables the systematic conception of decentralized coordination processes for autonomous
agents. First, the problematic, unintended system behavior
is modeled and these descriptions are incrementally refined
to a detailed coordination process that can be enacted
automatically, i.e. without modifying the original agent
implementations. Based on a generic model of the separation
of agent and coordination development [12], we discuss the
incremental refinement of externalized coordination models.
This refinement process is exemplified in a case study, where
the epidemic dissemination of information is integrated in
agent-based application designs. These MAS are used to
simulate application behaviors.
This paper is structured as follows. In the next section,
the systemic programming model is outlined. In Section III,
the iterative development of appropriate coordination models
is discussed. This process is exemplified (Section IV). We
discuss related work (Section V), before we conclude and
give prospects for future work.
II. A S YSTEMIC P ROGRAMMING M ODEL FOR
D ECENTRALIZED AGENT C OORDINATION
Development practices for self-organizing applications are
dominated by the tailoring of problem solving processes to
specific problem instance and blending system entities with
coordination-related activities (cf. Section V). The considerable expertize and effort that is required to conceive selforganizing coordination [2] justifies our interest in fostering
their software technological utilization, i.e. systematic conception, share and reuse. In our previous works, we advocate
that the coordination strategy itself should be considered as
a first class design element and the systemic programming
model, proposed in [10, 11], allows developers to describe
coordination in externalized, application-independent formats and automate their enactment in MAS.
A. Systemic Modelling and Configuration
In [10] a graph-based modeling approach is proposed that
refines System Dynamics (SD) [13] modeling concepts to
describe the dynamics of MAS. SD is an interdisciplinary
modeling approach that describes the feedback structures of
systems in terms of interrelated system variables. Variables
characterize the state of the system and causal interdependencies indicate their rates of change, as variables influence
each other. A prominent graph-based modeling technique
is the Causal Loop Diagram (CLD), where variables are
represented as nodes that are connected via positive or negative causalities. Positive causalities indicate that connected
variables change in the same direction, e.g. that increases in
originating variables causes increases in connected variables.
Vice versa indicate negative relations that variable changes
propagate in opposite directions, e.g. that an increase in originating variables causes the decrease of connected values.
Cyclic relationships indicate two types of feedback loops.
Reinforcing (+) feedbacks amplify changes while balancing
(-) feedbacks damp the fluctuations [13].
A MAS-specific refinement, is the Agent Causal Behavior
Graph [10, 12] ACBG :=< Vacbg , Eacbg >, where Vacbg
is a set of nodes and Eacbg is a set of directed edges
(Eacbg ⊆ Vacbg × Vacbg ). Nodes represent the state variables
that characterize MAS configurations. These variables denote the numbers of agents that exhibit specific behaviours.
The nodes are typed to distinguish different agent-oriented
concepts of entity-behaviors, e.g. the adoption of roles [14].
The relations between system elements can by described
by positive/negative causal interdependencies (see above) or
additive/subtractive influences. The incremental construction
of these models is supported by refinement/abstraction operations [15], these comprise the attachment of (sub-)graphs
and replacing nodes or links with (sub-)graphs. Graphs can
be abridged by stacking nodes of the same type that participate in conjoint relations. By default, incoming links to
these stacks affect all member variables and affected nodes
can be constrained by annotating links with set definitions.
Hierarchies of system variables support the traceability of
refinements and are expressed by placing (sub-)variables
within super-variables. Variable are composed of the values
of enclosed variables. Links to the super-variable affect all
enclosed links and links from a super-variable can transmit
changes of any enclosed variable. Besides, links are also allowed to connect enclosed variables directly. These notations
are exemplified in the Figures 4, 8.
In [10], ACBGs have been supplemented with a description level that enables the detailed configuration of the
declared influences among system entities. The automated
enactment (cf. Section II-B) of these influences is enabled by
configuring the information flows, e.g. realized by specific
interaction techniques [7], as well as the local responses
to the perceived data. The mapping of coordination models
to agent realizations and the detailed configuration of the
coordination model is discussed in [12].
B. A Reference Architecture for the Integration of Decentralized Coordination in Distributed Systems
The construction of self-organizing applications requires
system architectures that allow to plan for the realization
of the mutual entity interdependencies, e.g. distributed feedback loops, among system elements. This requires the exchange of information and the ability to adjust local element
configurations, as responding to the perceived information.
The major importance of providing the context information
that are necessary for the individual, local adaptation has
been noticed, e.g. in [16] where an architectural strategy
has been proposed that supports the design of self-adaptive
applications by situated autonomous agents.
Here, we outline a reference architecture, i.e. a blueprint
for families of application architectures [17], that automates
the enactment of decentralized coordination strategies, i.e.
ACBGs (cf. Section II-A), in MAS [12, 18]. Figure 1 (I) illustrates the conceptual, layered structure of this architecture
[12]. The Application Layer realizes the system functionality
and comprises autonomous agents. The coordination of these
agents is encapsulated by an underlying Coordination Layer
that comprises these agents and a set of Coordination Media
(CM) that are realized by coordination infrastructures (e.g.
[5]). These realize specific interaction models, e.g. digital
pheromones or token distribution algorithms etc. [7], and
thus provide abstractions that enable and govern interactions. The architecture encapsulates these infrastructures
and separates activities that concern the coordination, e.g.
communication, from agent models.
Coordination is enacted by equipping agent instances with
a Coordination Endpoint, i.e. an agent module that is able
to observe and influence the agent execution (cf. Figure
1, II 1). Using this decentralized approach, coordination is
provided by a middleware service that is accessed via CEmodules. CEs establish information flows between agents
as these modules inform each other about the observations
of behavior adjustments by exchanging Coordination Information (CI, cf. figure 1, II 2). Perceptions of CI are
interpreted by CEs that influence the agent execution by
initializing agent behaviors. Behaviors are triggered by the
dispatching of agent reasoning events, e.g. goal adoptions
or belief modification. These modules follow the conceptual
model from [19] that is concretized as a tool to bring by
interdependencies of agent behaviors (cf. section V). It is to
note that these influences respect agent autonomy, since the
dispatching of events suggests local adjustments and agents
have the authority to drop inappropriate behaviors (e.g. cf.
[19]). The observed and suggested behavior adjustments are
defined in terms of agent reasoning events that are specified
by sets of Systemic Coordination Specification (cf. Figure 1
II 3), e.g. ACBGs. These provide a generic interface between
the enactment architecture and agent models.
Figure 1.
DeCoMAS operating principle.
The interplay of the exchange of CI and the local adjustment of agent behaviors manifests the feedback loop structure that is specified by Systemic Coordination Specification
(cf. figure 1 II, 3). Their automated enactment is configured
by (1) specifying the data that are exchanged between CEs,
(2) parameterizing the Medium realizations to control the
dynamics of the information exchanges and (3) specifying
how CEs adjust the local activities of agents [10]. The
adjustments are encapsulated in Adaptivity Components that
encapsulate the procedural logic to observe and modify agent
states. This architecture has been prototypically realized [11]
on top of the Jadex1 agent platform.
III. S YSTEMATIC C ONSTRUCTION OF C OORDINATION
The presence of non-linear and cyclic interdependencies
among system elements enables software systems to exhibit self-organizing phenomena [2]. The anticipation of
the resulting system behavior is typically difficult, even
for comparatively simple systems of feedback loops (e.g.
discussed in [13]). Therefore, the systematic development of
self-organizing applications requires developers to alternate
between top-down design and bottom-up analysis activities
[6]. Design-related activities address the incremental refinement of element and coordination models, while analysisrelated activities focus on the validation that the conceived
application system is able to exhibit the intended behavior.
In [15] it has been argued that the development of
(externalized) coordination models can be separated from
the construction of the coordinated application elements.
The incremental development of coordination models (cf.
Figure 2) follows the alternation between design and analysis
activities and comprises the activities Coordination Strategy
Definition, i.e. the top-down refinement of an objective
coordination model, and the Coordination Strategy Validation that check whether the conceived model is capable
to exhibit the intended behavior (e.g. following [9, 15]).
This illustration follows the Software Process Engineering
Meta-Model2 (SPEM) [20] a standard from the Object
Management Group3 (OMG) that, among others, provides
concepts to the partitioning and communication of software engineering processes. Applications of this standard
comprise the definition and partitioning of agent-oriented
development methodologies (e.g. [21]). According to this
model, development processes are composed of Activities
that create and modify Artifacts. Artifacts describe the work
products of a software engineering process. These comprise
design models and executable software elements. Activities
are composed of Tasks, i.e. assignable units of work that are
composed of sets of development Steps.
The Adaptivity Requirements Activity guides the elicitation of the intended adaptivity of the system to be. Based
on the description of the application domain and initial
models of the conceived MAS (Organizational / MAS Environment), these requirements (Adaptation Requirement) are
derived [22]. Subsequently, requirement models and system
descriptions are (top-down) refined (Coordination Strategy
Definition) to a proposal of an appropriate structure of
agent-interdependencies (Coord. Strategy Definition). Prior
to its implementation, this model is (bottom-up) analysed
to validate the dynamical properties that arise from the
proposed element interdependencies [15]. Tools for this
analysis comprise the formal modeling of emergents, e.g.
by the stochastic situational calculus [9] and the behavioral
analysis via stochastic simulation techniques [23]. After the
applicability of the coordination model has been shown,
developers embed it in MAS (Coord. Strategy Integration)
[12]. This Activity comprises the detailed configuration of
the coordination models (cf. Section II-B) and results in an
executable MAS that is augmented with coordination (System Implementation). Simulations of these realizations check
the system behavior and enable quantitative parametrization
of system elements.
The construction of the coordination model is composed
2 http://www.omg.org/technology/documents/formal/spem.htm
1 http://jadex.informatik.uni-hamburg.de/bin/view/About/Overview
3 http://www.omg.org/
model may describe processes of the system environment
or process within a given MAS design that are to be
modified. Secondly, a so-called Solution Dynamic is derived.
Additional feedback loops are introduced as to balance the
unintended behaviors. In section IV-B, this is exemplified
for a scenario where an inevitable, but unsolicited s-shaped
grows is balanced by the introduction of an balancing feedback loop. In the subsequent Steps, system state variables
and their interdependencies are refined. Optionally, wellknown coordination pattern (e.g. [8]) may be integrated
and/or combined, in order to enable the realization of the
solution dynamic, as exemplified in [25]. The detailing of the
solution dynamic leads to the definition of the Coordination
Strategy model.
Figure 2. The systematic development of externalized coordination models
that combines top-down modeling and bottom-up analysis, following [15]
of four fundamental Tasks. First, the descriptions of the
application domain and/or the conceived MAS, e.g. initially
specified as a set of interdependent actors [24], is transferred
to a systemic description. This descriptions is given in
CLDs [13], or ACBGs. ACBGs are appropriate when an
initial design of the structure of the agent-based application
is available. Secondly, the resulting model is refined to a
coordination strategy. The refinement indicates additional
agent states and activities. A subsequent Tasks checks
whether these require the modifications of the agent models
or can be added within Adaptivity Components (cf. Section
II-B). Finally, the interaction mechanisms [7] are identified
and configured. In incremental development processes, these
Tasks are iterated in order to refine coordination, e.g. when
agent models are detailed or the system requirements are
adjusted.
The refinement Task (Systemic Coordination Refinement)
is illustrated in Figure 3. Inputs to the refinement process is
a model of the application dynamic (Systemic Application
Description). This may be an ACBG or a CLD depending
on the available level of detail. The refinement particularly
addresses the incremental detailing of ACBGs. Additionally,
development teams may maintain a library of field-tested
coordination strategies (Archetype Coordination Strategies).
These provide reusable structures, where the dynamic properties are known in advance [8, 25].
Initially, the model of the application dynamic is examined to identify the original, e.g. un-coordinated, dynamical
properties of the future application (Identify Problem Dynamic). This activity leads to a model of the Problem Dynamic, i.e. the unintended and problematic system behavior
that is to be adjusted by the application realization. This
Figure 3. The refinement of a systemic coordination model, described by
a stereotyped UML Activity Diagram.
IV. E MBEDDING E PIDEMIC I NFORMATION
D ISSEMINATION
Epidemic Algorithms provide mechanisms to the dissemination of information in distributed systems [26]. These
algorithms mimic the spread of infections in populations and
the dynamics of these metaphoric epidemics can ensure that
data are shared among large numbers of system elements.
A. Convention Emergence
Epidemic algorithms can be used to address agreement
problems in MAS (e.g. discussed in [27, 28]). In these
settings, agents start with arbitrary local settings and have
to agree on convention values. These conventions emerge
in agent populations when (1) individuals mutually inform
each other about their local values and (2) adjust their
local configuration. If the size of the system and/or the
communication overhead permits the broadcast of local
values, agents can be arranged in (overlay) networks that
constrain communications. Local adjustment policies model
the suggestibility of individuals. Several reasoning techniques are appropriate, often combinations of majority rules
and bounded memories of past communications are applied
(e.g. see [27, 28]). When both modeling levels are wellmatched, the diverse configurations converge.
Figure 4 illustrates the causal structure, i.e. ACBG, of
this convergence process. External factors actuate agents
to execute arbitrary Activities. Their observation causes
the communication of local convention value to connected
agents (inform convention value). Perceptions trigger individual reconfigurations (Convention Adjustment), according
to the local adjustment policies. The local configuration
feeds back to the agent activities. Configurations may control
how activities are proceeded or constrain individuals. These
causal relationships form a reinforcing (+) and a balancing
(-) feedback loop. The system history decides which value
dominates. In the realized simulation model, two configuration types are available (A, B) and reconfigurations alternate
between these (A → B, B → A). The local configuration
(source.type) can be used to control the available activities
(destination.type).
Figure 4.
Convention Emergence: Externalized coordination model
This decentralized agreement strategy has been realized
with the systemic programming model (cf. Section II).
Agents are equipped with Adaptivity Components that, based
on a fixed memory size of 9 communications, adjust the
local value when the majority of the perceptions differs
from the local setting. A Coordination Medium realization
provides the network topology, i.e. the agent Coordination
Endpoints (CEs) register themselves at the medium when
agents are initialized. These are provides with the addresses
of virtually connected agents that CEs are allowed to inform.
The medium can be configured to exhibit different network
topologies.4 Figure 5 exemplifies the exhibited dynamics.
300 agents are randomly assigned an initial, local configuration. These agents are arranged in a random graph
and the communication of configuration values is randomly
triggered (cf. Figure 4]).
Figure 5. Sample Convention Emergence. 300 agents reach agreement
(averaged over 10 runs) in a random graph (p = 0.2).
The time that is needed for the convergence depends on
several parameters, most importantly the network topology
and the local communicativeness of the agents. Here, we
briefly discuss their impact. The stochastic properties of
complex graphs have been studied in literature. Of particular
interest are randomly generated and power law distributed
graphs [29]. In our simulations, random graphs follow the
Erdős-Rényi binomial model3 (cf. [29], p. 8) that connects
each pair of N nodes with a fixed probability p. The
expected number of edges is E(N ) = p N (N2−1) . Power
law distributed graphs were generated3 according to [30].
The node degree, i.e. the number of edges of a node, is
distributed by a function that follows a power law, i.e. the
probability that a node has k edges follows P (k) ∼ k −γ .
In Figure 6, we compare the effects of these network types
on the exhibited convergence times. The y-axis denotes the
time needed till 95% of the agents agreed on a local value.
The x-axis shows communicatiness of the CEs, i.e. the percentrage of connected nodes that are informed. It can be seen
that both graph types behave comparatively. Convergence
is quickly achieved for mid-level values and increasing the
number of informed agents, i.e. the commmunicativeness,
above 70% rewards minor impact.
However, comparing the number of edges between the
nodes (cf. Table I), it can be seen that power law distributed
topologies more effectively disseminate the information that
is needed to reach convergence. These graphs are set to
comprise less edges (between 3500 and 5000, cf. figure 6)
and therefore reduce the communication overhead.
The examined examined scenario exemplifies the coordination of agents by the enactment of an externalized coordination model. In the following section, we exemplify the
4 using the Java Universal Network/Graph Framework (JUNG):
http://jung.sourceforge.net/
5 averaged over 100 generated graphs
Figure 6. Comparison of the convergence time that is exhibited by 200
agents in different graph topologies, in each case averaged by 10 runs.
Figure 7. The problem model is supplemented with an opposing feedback.
Graph Type
Random (p=0.2 / 200 nodes)
Random (p=0.3 / 200 nodes)
Random (p=0.5 / 200 nodes)
Power Law (200 nodes)
# of Edges
approx. 3992.7 5
approx. 5975.9 5
approx. 9949.5 5
set to fixed values
Table I
T HE NUMBERS OF EDGES IN THE SIMULATED GRAPH TOPOLOGIES .
systematic conception of coordination models, that is driven
by the adjustment of problematic dynamics (cf. Section III).
B. Supplementing a Patching Process
In a hypothetical scenario, we assume a network of
agents to be subject to malicious infections. Infected spread
randomly and the design objective is to realize an opposing
process that contains these virtual epidemics. The Problem Dynamic (cf. Section III) of the system describes the
spreading of infections (cf. Figure 7). Agents exhibit two
roles. They are Susceptible to infections or Infectious as they
have already been infected. The local interactions between
these roles are characterized by a fluctuating infection rate.
This rate reduces the number of susceptible agents (negative
link) and increases the number of infectious agents (positive
link). It depends on the availability of susceptible and
infectious agents (positive links) and declines when the
number of susceptible and/or infectious agents is reduced.
These causalities form a pair of feedback loops. A balancing
feedback gradually reduces the amount of susceptible agents
and a reinforcing feedback increases the number of infected
agents. Infected agents do not recover by themselves thus the
system tends to a steady state where all agents are infected.
The proposed Solution Dynamic (cf. Section III) supplements two balancing feedback loop that limits the number
of Infectious and susceptible agents. Two processes recover
infected agents and patch susceptible agents. The affected
agents enter a Unsusceptible state and are immune for
future infections. This is an early conception of the intended
dynamics.
Figure 8 illustrates the finally enacted coordination strat-
egy that details the enactment of the additional feedback
loops of the Solution Dynamic. Two agent roles have been
added that realize the patching of susceptible agents and the
recovery of infected agents. These are realized as Adaptivity
Components (cf. Section II-B) in the agent programming
language and are capable to modify the agent state. In
the simulation model, these mimic the patching of agent
instances at run-time. The Unsusceptible agent role has been
refined to two roles that denote whether how the agent has
been rendered unsusceptible (U by recovery, U by patching).
The recovery process of infectious agents is initialized by
the manual recovery of an infected agent (Manual Recovery (administration)). This describes external, administrative
intervention that triggers the process to recover (role: recovery) a single infected agent. This agent will enter the
corresponding unsusceptible state (U by recovery) and all
Unsusceptible agents forward the received patch (forward
patch links), i.e. they inform other agents about the update
and the reception of this update triggers the local agent
activities (patching,recovery) that makes them also enter the
Unsusceptible states. These causalities form two reinforcing
feedback loops that increase the numbers of recovered
and patched agents, respectively. Therefore, the infection
process, that reinforces infections, is countered with two
processes that reinforce unsusceptibility. Parameterizations
of the local agent activities and the communication technique
control which feedback loops dominate.
In our MAS simulations, all agents are initially susceptible
and one, randomly selected, agent is infected. Infected
agents randomly infect other population members at a fixed
rate. After a fixed time delay, the initially infected agent
is recovered to mimic a manual intervention. Subsequently,
this agent spreads the patch, according to the discussed
coordination model. Figure 9 shows a sample simulation
run in a scenario, where the infection spreads quickly. The
patch distribution then opposes the epidemic by converting
infected nodes.
Figure 8. Coordination model: The enacted ACBG that supplements a
MAS with the Solution Dynamic, i.e. the recovery / patching of agents.
Figure 9. Sample patching process. 200 agents (averaged over 10 runs)
are patched by a power law distributed graph (5000 edges, r = 10000).
V. R ELATED W ORK
Decentralized, self-organizing processes provide powerful
tools to the coordination of large-scale applications [1].
The properties of self-organizing processes (see e.g. [8])
and the interaction techniques to their realisation (see e.g.
[7]) are well understood. However, their software technological utilization, e.g. their share and reuse, found limited
consideration. Instead development practices are dominated
by blending system elements with highly specialized algorithms. Two contributing factors are addresses in this paper.
First, proposals for systematic development processes, e.g.
[6], notice the need for bottom-up analysis activities and
rely on simulations of system implementations to anticipate
the effects of agent coordination. Here, we propose the
incremental refinement of coordination strategies, prior to
their implementation (cf. Section III). This development
stance is based on the ability to anticipate the qualitative
dynamics of systemic coordination models by analysing their
causal structure and/or their simulation/iteration [15].
Secondly, the treatment of coordination models as first
class design elements demands support to minimise the effort to their integration in applications. Particularly for agentbased applications, sophisticated coordination frameworks
allow to decouple communication partners, e.g. [5, 31], but
developers have to manually integrate the activities that are
conceptually related to coordination into component designs.
Approaches to automate the utilization of agent-interaction
techniques, as to bring about agent coordination, found
yet minor attention. An example is Interaction-Oriented
Programming (IOP) [32, 33], that has been proposed to automate externalized coordination models. In [32], a declarative
approach is used to control and configure the participation
in interaction protocols. In [19] a conceptual coordination
service model interacts with agent models by observing and
dispatching exposed events of the agent execution.
The here, presented coordination framework extends and
combines these works. It provides a practical tool-set that
realizes the enactment of ACBG models (cf. section II-A).
This tool-set allows developers to separate coordination,
i.e. the establishment of information flows and the local
adaptivity of agent models, from the core agent functionality.
The focus on systemic coordination models provides a
higher abstraction level that allows to arrange configurations
of interactions into structures of feedback-loops.
VI. C ONCLUSION
In this paper, we discussed the refinement of decentralized
coordination models. This refinement is based on a systemic
modeling approach to decentralized agent coordination and
a layered coordination architecture that automates the enactment of coordination models. This systematic procedure
has been defined in a standard software engineering notation
and has been exemplified in a case study where coordinating processes, e.g. epidemic information dissemination, are
integrated in MAS.
Future work, addresses the analysis of ACBG-based coordination models, e.g. by the (semi-)automation of required
simulations. In addition, we plan to detail the integration of
the proposed coordination development in established agentoriented development methodologies.
ACKNOWLEDGMENTS
J.S. would like to thank the Distributed Systems and
Information Systems (VSIS) group at Hamburg University,
particularly Winfried Lamersdorf, Lars Braubach, Alexander
Pokahr and Ante Vilenica for inspiring discussion.
R EFERENCES
[1] G. D. M. Serugendo, M. P. Gleizes, and A. Karageorgos,
“Self-organisation and emergence in mas: An overview,” in
Informatica, vol. 30, 2006, pp. 45–54.
[2] M. Prokopenko, Advances in Applied Self-organizing Systems.
Springer, 2008, ch. Design vs. Self-organization, pp. 3–17.
[3] J. C. Mogul, “Emergent (mis)behavior vs. complex software
systems,” HP Laboratories, Tech. Rep. HPL-2006-2, 2005.
[4] N. R. Jennings, “Building complex, distributed systems: the
case for an agent-based approach,” Comms. of the ACM, vol.
44 (4), pp. 35–41, 2001.
[5] M. Viroli, T. Holvoet, A. Ricci, K. Schelfthout, and F. Zambonelli, “Infrastructures for the environment of multiagent
systems,” Autonomous Agents and Multi-Agent Systems,
vol. 14, no. 1, pp. 49–60, 2007.
[6] B. Edmonds, “Using the experimental method to produce
reliable self-organised systems,” in Engineering Self Organising Sytems: Methodologies and Applications, ser. LNAI, no.
3464, 2004, pp. 84–99.
[7] T. DeWolf and T. Holvoet, “Decentralised coordination
mechanisms as design patterns for self-organising emergent systems,” in Engineering Self-Organising Systems, vol.
4335/2007, 2007, pp. 28–49.
[8] M. Mamei, R. Menezes, R. Tolksdorf, and F. Zambonelli,
“Case studies for self-organization in computer science,” J.
Syst. Archit., vol. 52, no. 8, pp. 443–460, 2006.
[9] M. Randles, H. Zhu, and A. Taleb-Bendiab, “A formal approach to the engineering of emergence and its recurrence,”
in Proc. of the Sec. Int. Workshop on Engineering Emergence
in Decentralised Autonomic Systems (EEDAS 2007), 2007.
[10] J. Sudeikat and W. Renz, “MASDynamics: Toward systemic
modeling of decentralized agent coordination,” in Kommunikation in Verteilten Systemen, 2009, pp. 79–90.
[11] ——, “Decomas: An architecture for supplementing mas
with systemic models of decentralized agent coordination,”
in Proc. of the 2009 IEEE/WIC/ACM Int. Conf. on Intelligent
Agent Technology, 2009, accepted.
[12] ——, “Programming adaptivity by complementing agent
function with agent coordination: A systemic programming
model and development methodology integration,” Communications of SIWN, vol. 7, pp. 91–102, 2009.
[13] J. D. Sterman, Business Dynamics - Systems Thinking and
Modeling for a Complex World. McGraw–Hill, 2000.
[14] X. Mao and E. Yu, “Organizational and social concepts
in agent oriented software engineering,” in Agent-Oriented
Software Engineering V, vol. 3382, 2004, pp. 1–15.
[15] J. Sudeikat, M. Randles, W. Renz, and A. Taleb-Bendiab,
“A hybrid modeling approach for selforganizing systems
development,” Comms. of SIWN, vol. 7, pp. 127–134, 2009.
[16] D. Weyns and T. Holvoet, “An architectural strategy for selfadapting systems,” in SEAMS ’07: Proceedings of the 2007
International Workshop on Software Engineering for Adaptive
and Self-Managing Systems, 2007.
[17] P. Kruchten, The Rational Unified Process: An Introduction,
ser. The Addison-Wesley Object Technology Series. Addison
Wesley Professional, 2003.
[18] J. Sudeikat and W. Renz, “On the encapsulation and reuse of
decentralized coordination mechanisms: A layered architecture and design implications,” in Communications of SIWN,
vol. 4, no. ISSN 1757-4439, 2008, pp. 140–146.
[19] M. P. Singh, “A customizable coordination service for autonomous agents,” in ATAL ’97: Proceedings of the 4th International Workshop on Intelligent Agents IV, Agent Theories,
Architectures, and Languages, 1998, pp. 93–106.
[20] Object Management Group, “Software & systems process
engineering meta-model specification version 2.0,” available
online: http://www.omg.org/spec/SPEM/2.0/PDF, April 2008.
[21] M. Cossentino, S. Gaglio, A. Garro, and V. Seidita, “Method
fragments for agent design methodologies: from standardisation to research,” Int. J. Agent-Oriented Software Engineering,
vol. 1, no. 1, pp. 91–121, 2007.
[22] J. Sudeikat and W. Renz, “On expressing and validating
requirements for the adaptivity of self–organizing multi–agent
systems,” System and Information Sciences Notes, vol. 2,
no. 1, pp. 14–19, 2007.
[23] L. Gardelli, M. Viroli, and A. Omicini, “On the role of
simulations in engineering self-organising mas: The case of
an intrusion detection system in tucson,” in Engineering SelfOrganising Systems. Springer, 2006, pp. 153–166.
[24] P. Bresciani, P. Giorgini, F. Giunchiglia, J. Mylopoulos, and
A. Perini, “Tropos: An agent-oriented software development
methodology,” Journal of Autonomous Agents and MultiAgent Systems, vol. 8, pp. 203–236, 2004.
[25] J. Sudeikat and W. Renz, “Toward systemic mas development:
Enforcing decentralized self-organization by composition and
refinement of archetype dynamics,” in Proc. of Engineering
Environment-Mediated Multiagent Systems, 2008, pp. 39–57.
[26] P. T. Eugster, R. Guerraoui, A.-M. Kermarrec, and L. Massoulieacute;, “Epidemic information dissemination in distributed systems,” Computer, vol. 37, no. 5, pp. 60–67, 2004.
[27] K. Lakkaraju and L. Gasser, “Improving performance in
multi-agent agreement problems with scale-free networks,”
in Proceedings of 3rd International Workshop on Emergent
Intelligence on Networked Agents (WEIN09), 2009.
[28] D. Villatoro, N. Malone, and S. Sen, “Effects of interaction history and network topology on rate of convention
emergence,” in Proc. of 3rd Int. Workshop on Emergent
Intelligence on Networked Agents (WEIN09), 2009.
[29] R. Albert and A. L. Barabasi, “Statistical mechanics of
complex networks,” Rev. of Modern Physics, vol. 74, 2002.
[30] D. Eppstein and J. Wang, “A steady state model for graph
power laws,” CoRR, vol. cs.DM/0204001, 2002.
[31] A. Gouaich and F. Michel, “Towards a unified view of
the environment(s) within multi-agent systems,” Informatica
(Slovenia), vol. 29, no. 4, pp. 423–432, 2005.
[32] G. Muller, “Interaction-oriented programming,” in 7th IEEE
Int. Workshops on Enabling Technologies: Infrastructure for
Collaborative Enterprises (WET ICE ’98), 1998, pp. 138–142.
[33] M. P. Singh, “Conceptual modeling for multiagent systems:
Applying interaction-oriented programming?” in Conceptual
Modeling, 1999, pp. 195–210.