outset modular agent architectures in order to cope with these heterogeneity issues.

 

SHORTCOMINGS OF CLASSICAL AGENT ARCHITECTURES

Agent-oriented software engineering has been studied from different perspectives, including agent-oriented methodologies and languages for higher-level development phases, conceptual modeling, and implementation frameworks [ 2, 3]. Although sepa- ^{Architectural} _Problem ration of concerns is widely recog- Architectural nized as crucial to the development ^scattering of maintainable multi-agent soft- _{Architectural} ware [ 5, 6, 12], existing approaches ^tangling do not scale up to support the separation of agent properties in heterogeneous architectures.

Developers must rely on traditional
architectural patterns, such as the High architectural
coupling and low

Mediator pattern [ 4] and the Lay- cohesion ers pattern [ 4], in order to build their systems. As illustrated in Figure 1, these solutions define architectural abstractions, such as mediators and layers, and composition rules to support the isolation of agent concerns and their further composition.

However, these solutions impose
rigid connections on the architec-
tural components, which make the
construction of heterogeneous agent ^{Limited evolvability}
and maintainability

types difficult and not scalable to cope with the complexity of multiple interactive agent concerns. These existing architectural proposals are applicable to simple agent architec- Shortcomings of tures and with few agenthood prop- ^{existing architectural} erties. The constraints on the ^styles. composition rules imposed by those solutions do not scale up to master the intrinsic crosscutting character of agent properties in heterogeneous contexts. Figure 1 illustrates this problem in terms of a layered agent architecture (Figure 1a) and a mediator-based agent architecture (Figure 1b), represented with a simplified UML notation.

The layered architecture imposes a bidirectional communication only between adjacent layers; that is, the architectural components of a software agent. In order to make proper internal decisions and adapt the agent knowledge accordingly, the autonomy and adaptation components must be aware of received messages and external stimulus coming from the surrounding

environment. As illustrated in Figure 1a, this requirement forces the software architects to add interaction-related interfaces into the other layers so that the autonomy and adaptation components have access to the perceived stimulus and messages. As a result, the interaction concern (represented in blue) crosscuts the modularity of the kernel and adaptation components.

The situation is not different in the mediator-based

 

Description

The occurrence of architectural elements, such as interfaces, that belong to one agent concern in architectural components encapsulating other agent concerns. For example, the interaction-related interfaces are scattered over the agent architectures in Figure 1.

The mix of multiple agent concerns together in the same module. For instance, tangling is evident in the agent kernel of Figures 1a and 1b as both are implementing interfaces associated with different agent concerns.

Hindering of The inability of the architect being able to reason and make decisions about an agent
modular architecture’s module while looking only at its functionality and its interfaces. For
reasoning example, the architects treating the collaboration and interaction concerns in Figure 1a
need to consult the definitions and interfaces of other modules, leading to an
expanded or global reasoning rather than a modular reasoning.

The presence of an overly strong connection between architecture components (high coupling), and the lack of closeness between the internal functionalities and interfaces of a specific component (low cohesion). In Figure 1b, for example, the system coupling is increased, and the cohesion of each component (for example, the Kernel) is decreased.

The evidence of complexity increase in the component interfaces. For example, the number of interfaces of several components in Figures 1a and 1b is augmented due to the crosscutting nature of the interaction concern.

The inability of directly mapping in the architecture description the separation of agent concerns achieved in the requirements description. For example, the mobility-specific requirement cannot be directly traced to the Mobility component (Figure 1b) as it also affects the boundaries of the Kernel component.

Poor modularization The incapacity of the architectural decisions and rationale associated with one agent of design decisions concern being documented in a localized manner. The rationale and design decisions and rationale related to the interaction concern are typically tangled and scattered over the architecture artifacts in the same way as interaction-specific interfaces and functionalities.

Inflexible design The rigidness in the composition rules to support alternative compositions between agent components in order to smoothly produce heterogeneous architectures. This inflexibility is visible both in the mediator and layered solutions.

The adversities associated with including, changing, or removing the design elements associated with an agent crosscutting concern as they crosscut several architectural components. For instance, this problem would occur recurrently in changing or replacing the collaboration and interaction components in Figure 1a. In fact, in a previous study [ 6] we have observed a poor stability of a typical mediator-based agent architecture implementation in the presence of maintenance and evolution scenarios.

Architectural interface bloat

Poor traceability from requirements to architecture

solution. This architectural style requires all the inter-component communications being intermediated by a central component, which is also in charge of encapsulating the agent’s basic functionality. As illustrated in Figure 1b, this architectural approach also fails to isolate the interaction concern and leads to the intermingling of the agent kernel functionality and the message-processing functionality. Note that a similar problem occurs with the mobility concern as the communication with the autonomy component needs to be settled by the agent kernel. Hence, the inability of traditional architectural styles and respective composition rules in capturing the crosscutting feature of agent concerns in heterogeneous architectures leads to several negative consequences, such as architectural tangling and bloated interfaces, which are described in detail in the table here.