Marc-Philippe Huget

Model checking multi-agent systems with MABLE

MABLE is a language for the design and automatic verification of multi-agent systems. MABLE is essentially a conventional imperative programming language, enriched by constructs from the agent-oriented programming paradigm. A MABLE system contains a number of agents, programmed using the MABLE imperative programming language. Agents in MABLE have a mental state consisting of beliefs, desires and intentions. Agents communicate using request and inform performatives, in the style of the fipa agent communication language. MABLE systems may be augmented by the addition of formal claims about the system, expressed using a quantified, linear temporal belief-desire-intention logic. MABLE has been fully implemented, and makes use of the spin model checker to automatically verify the truth or falsity of claims.

Representing Agent Interaction Protocols with Agent UML

Several modeling techniques exist that represent agent interaction protocols. These techniques are based primarily on work done in distributed systems and do not consider features such as the agent autonomy. Agent Interaction Protocol designers are now considering specific modeling techniques that contain these features. In this paper, we present the second version of the Agent UML interaction diagrams dedicated to interaction protocols and based on UML 2.0.

Modularity in Interaction Protocols

Protocols or part of protocols are frequently reused through projects if they are sufficiently generic. For instance, the Contract Net protocol can be used verbatim or in other protocols such as the supply chain management. This reusability might be difficult to do due to the lack of reusability in current interaction protocol formalisms. In this paper, we present a new approach based on a modular architecture. A protocol is no longer monolithic but a composition of modules called micrc-protocols. This approach improves modularity and reusability in interaction protocol engineering. We apply this idea to the example of supply chain management.

Interaction protocol engineering

Several methodologies are supplied to multiagent system designers to help them defining their agents and their multiagent systems. These methodologies focus mainly on agents and on multiagent systems and barely consider how to design interaction protocols. A problem could emerge of this lack since interaction protocols are more and more complex. The aim of this article is to present our proposal of interaction protocol engineering which is based on the communication protocol engineering [10]. Interaction protocol engineering allows designers to define protocols from scratch. Our proposal is composed of five stages: analysis, formal description, validation, protocol synthesis and conformance testing.

Model Checking for Multiagent Systems: The MABLE Language and its Applications

We present MABLE, a fully implemented programming language for multiagent systems, which is intended to support the automatic verification of such systems via model checking. In addition to the conventional constructs of imperative programming languages, MABLE provides a number of agent-oriented development features. First, agents in MABLE are endowed with a BDI-like mental state: they have data structures corresponding to beliefs, desires, and intentions, and these mental states may be arbitrarily nested. Second, agents in MABLE communicate via ACL-like performatives: however, neither the performatives nor their semantics are hardwired into the language. It is possible to define the performatives and the semantics of these performatives independently of the system in which they are used. Using this feature, a developer can explore the design space of ACL performatives and semantics without changing the target system. Finally, MABLE supports automatic verification via model checking. Claims about the beha...

Representing agent interaction protocols with agent UML

Several modeling techniques exist to represent agent interaction protocols mostly based on work done in distributed systems. These modeling techniques do not take the agent features such as the autonomy into account. Agent Interaction Protocol designers are now considering specific modeling techniques that contain these features. In this paper, we present the second version of the Agent UML interaction diagrams dedicated to interaction protocols, and based on UML 2.0.

Extending agent UML sequence diagrams

Agents in multiagent systems need to interact in order to exchange information, cooperate or coordinate. This interaction is frequently done through interaction protocols based on distributed system communication protocols. Communication protocols are not directly used due to many differences between agents and objects or processes such as autonomy and interaction [23] [28]. Designers use formal description techniques to represent their protocols. These formal description techniques are either those coming from distributed systems or those specifically tailored to agents. In the last category, Agent UML [24] is certainly one of the most known. This paper presents Agent UML sequence diagrams and addresses several new stereotypes.

The AUML Approach

Since the earliest work in multiagent system development, the need has existed to have a methodology and a modeling notation. A recent approach chosen by several authors is based on UML. The main advantage of UML is to provide a recognized notation in software engineering methodology and strong tools for the development. The approach presented here is called Agent UML (AUML) that synthesizes a growing concern for agent-based modeling representations with the increasing acceptance of UML for object-oriented software development. This chapter covers the first phase (from 1999 to 2002) in the development of Agent UML with the sequence and agent class diagrams and describes future directions that follows Agent UML via the standardization at the FIPA.

Design agent interaction as a service to agents

A common feature of agents is their interaction ability. They need this interaction in order to fulfill their tasks or to cooperate for fulfilling them. This paper presents our approach where the interaction is defined within an interaction module. This interaction module handles protocols and manages interactions between agents. The interaction module is inserted into agents. The paper describes the requirements for such an interaction module and the advantages and drawbacks of the approach. Since a link is required between the reasoning part of the agents and the interaction module, we propose a language for the interconnection based on XML. A second domain of use of the interaction module is given: mobile agents. If the interaction module is defined as a service, agents can use it. In this case, agents do not have to bring an interaction module when moving from site to site.

Requirement analysis for interaction protocols

Designing agent interaction protocols need first to consider what the requirements are. This is done in the requirement analysis phase. The output of this phase is an informal document written in natural language. To our best knowledge, this phase is barely considered in the literature neither in communication protocol engineering nor in interaction protocol engineering. As a consequence, it is difficult for designers to do it easily. Experience seems to be the key. In order to help designers, we propose to structure the requirement analysis document into fields. These fields gather protocols features. This paper presents such document and applies the structuration to the electronic commerce protocol NetBill.