Architecture-Based Design of Multi-Agent Systems

A well-known claim for multi-agent systems is that they are especially suited to develop software systems that are decentralized, can deal flexibly with dynamic conditions, and are open to system components that come and go. While we endorse this claim, developing real-world multi-agent systems taught us that achieving these goals is a complex engineering problem. Our experience with real-world multi-agent systems development can be captured succinctly in the following statement:

Developing multi-agent systems software is 95% software engineering and 5% multi-agent systems theory.

Architecture-based design of multi-agent systems puts software architecture at the center of the software development activities. In this chapter, we give an overview of the approach. We start by situating architecture-based design in a software development life cycle and we give an overview of the methods used in the different steps of architecture-based design of multi-agent systems. Next, we zoom in on the different steps in the approach, including requirements elicitation, architectural design, architecture documentation, and evaluation. For each step, we give the necessary background and we introduce the different techniques and methods that are used. We conclude with a brief explanation of how software architecture serves as a blueprint for system development and a summary.

An architectural pattern is a key concept in architectural design. It specifies a generic solution scheme for a recurring design problem. A solution scheme describes a set of components, their responsibilities and relationships, and the way in which they collaborate. Architectural patterns exhibit various properties: patterns address different quality requirements, they help to document the architectural design decisions, and facilitate communication between stakeholders through a common vocabulary. A coherent set of related architectural patterns that describe good design practices within a particular domain makes up a pattern language [37]. Making explicit the relationships among the patterns gives the architect guidance about how to combine the patterns to construct a software architecture for a concrete system.

Architectural design concerns the primary structures of a software system. Central in architecture design of a multi-agent system is the achievement of the system’s quality attributes based on design decisions. To make design decisions, architects use established practices such as architectural patterns. To be effective, a software architecture must be properly documented. Architectural views provide a proven approach to document the structures of a complex software system. Documenting specific concerns of multi-agent systems such as roles, organizations, and interaction protocols may require dedicated notations.

One of the major challenges in the software development of a distributed multi-agent system is the coordination necessary to align the behavior of the agents. Since coordination determines whether agents cooperate effectively, it has a direct impact on the satisfaction of a distributed application’s functional requirements. Furthermore, since coordination is realized primarily by communication, coordination has a large impact on quality attributes such as efficiency and resource usage.

Task assignment in multi-agent systems is a complex coordination problem, in particular in systems that are subject to dynamic and changing operating conditions. To enable agents to deal with dynamism and change, adaptive task assignment approaches are needed. In this chapter, we study two approaches for adaptive task assignment that are characteristic for two classical families of coordination mechanisms for task assignment. In particular, we study and compare a field-based approach for task assignment (FiTA) with a protocol-based approach (DynCNET). In FiTA, tasks emit computational fields in a virtual environment that attract idle agents. Agents follow the gradient of the combined field that guides them toward tasks. DynCNET is an extension of the well-known contract net protocol CNET [151], with “Dyn” referring to support for dynamic task assignment. Both FiTA and DynCNET enable task assignment in the system based on local interaction among agents and allow for adaptation of task assignment during delayed commencement. Yet, the approaches differ in the manner agents realize task assignment. In FiTA, agents use simple rules that guide them toward tasks, providing an emergent solution for task assignment. Contrarily, in DynCNET agents use explicit selection mechanisms and can negotiate about task assignment. Our focus is on systems with homogeneous tasks that can be executed by individual agents. We do not consider complex tasks, for instance composite tasks that have to be divided among agents, or a combination of related tasks that have to be executed by a single agent. This perspective allows us to focus on the basic challenges of task assignment in systems that are subject to dynamic and changing operating conditions.

Making the right architectural choices is crucial for successful development of a multi-agent system. Architectural evaluation allows examining a software architecture to determine whether it satisfies the important stakeholder requirements. Early evaluation of the software architecture enables adaptation of the architecture before the costs of correcting it become too high. The evaluation of a software architecture should involve an evaluation team and the stakeholders who have an interest in the architecture and the system that will be built from it.

Architecture-based design of multi-agent systems takes an architecture-centric perspective on the engineering of agent-based systems. The approach integrates multi-agent system concepts with state-of-the-art principles and methods of conventional software engineering. Although architectural design is considered as an explicit phase in several agent-oriented methodologies, none of them puts software architecture in the center of the engineering activities.

We started this book with the brave statement: “Developing multi-agent systems software is 95% software engineering and 5% multi-agent systems theory.” This chapter concludes the book by reviewing how architecture-based design of multi-agent systems underpins this statement. We start with a reflection on architecture-based design of multi-agent systems and its application to the AGV transportation system. Next, we report lessons learned from applying the approach in practice. From our experience, we propose opportunities to improve multi-agent system engineering practice and we give a number of suggestions for future research.