As a result, architects of software
agents are faced with basic concerns, such as the agent services that
are made available to the clients,
and a number of additional concerns on top of the basic concerns.
The internal architecture of a single agent encompasses multiple properties, including autonomy, interaction, adaptation, collaboration, learning, and
mobility. Hence, architects of agent-based systems are
also concerned with issues such as making an agent
interact appropriately, handling the agent’s adaptive
behavior, structuring the agent’s autonomous behavior, designing the agent roles and protocols for interagent collaboration purposes, and incorporating
learning mechanisms into the agent’s structure in a
modular manner.
Not surprisingly, separation of concerns is at the
core of the development of agent-based software systems [ 5, 12]. The reuse and maintenance of agent elements depend largely on the ability of used
architectural abstractions to support the separate handling of agent-specific concerns since an early state of
design. The applied architectural styles must enable
the modularization of each agent concern and their
proper composition, so that the achieved segregation
significantly limits the impact of a change and
improves the chances for architecture reuse in other
software projects. This separation of concerns needs to
be guaranteed throughout the different development
phases, especially from the architectural to the implementation phase. The architectural separation will be
lost if the implementation abstractions are not able to
preserve it. In fact, the sole use of existing well-known
agent platforms, such as JADE and JACK [ 12], do not
provide advanced mechanisms to achieve separation of
concerns, which are restricted to exploit the object-oriented composition and decomposition mechanisms
[ 5]. On the other hand, even though such advanced
implementation mechanisms are delivered, the benefits of separation of agent concerns would be hindered
if existing architectural abstractions do not allow the
achievement of proper system modularization from
the design outset.
HETEROGENEITY IN AGENT ARCHITECTURES
Although separation of concerns is critical to architects of agent-based software, it is often difficult to
achieve in realistic systems for several reasons. First,
these systems typically encompass heterogeneous
types of agents [ 2]. The internal architecture of distinct agent types differs widely from each other since
they incorporate distinct properties [ 8]. Second,
each property is orthogonal and interacts with the
agent’s basic functionality and often with other
agent properties. These properties typically crosscut
several modules of an agent architecture, independently from the adopted internal model, such as the
constraint-oriented model or the BDI (
Belief-Desire-Intention) model [ 10], and from the agent’s
cognitive level, such as reactive agents, deliberative
agents, or even hybrid agents. Third, these crosscutting agent-specific concerns are related in dramatically different ways that depend on the agents’ types
and the application requirements [ 6]. For example,
in a given agent-based application, the mobility
behavior of an agent may only directly affect the
basic functionality of the agent, while it may also
crosscut the collaboration and interaction concerns
in a second application.
As a consequence, agent-based applications require
an architectural approach that is flexible enough to
support adjustable composition of agent concerns and
the construction of heterogeneous agent architectures
according to the application demands. This flexibility
requirement is even more stringent in open agent-based systems due to their adaptive and open nature.
In these contexts, the agent architecture needs to be
modular enough to support the dynamic reconfiguration of its internal elements. For example, roles potentially need to be changed as the agent moves to new
environments. The degree of autonomy and the learning strategies may also need to be adapted or disabled
according to the dynamic execution contexts. While
part of the system-level reconfiguration facilities are
typically provided by specific middleware implementations, many of the agent concerns and their composition are essentially application-dependent. Software
architects need to prepare and conceive at the design
Agent-based applications require an architectural approach that is flexible
enough to support adjustable composition of agent concerns and the construction of
heterogeneous agent architectures according to the application demands.