An Introduction to MultiAgent Systems.

Negotiation is essential in settings where autonomous agents have conflicting interests and a desire to cooperate. For this reason, mechanisms in which agents exchange potential agreements according to various rules of interaction have become very popular in recent years as evident, for example, in the auction and mechanism design community. However, a growing body of research is now emerging which points out limitations in such mechanisms and advocates the idea that agents can increase the likelihood and quality of an agreement by exchanging arguments which influence each others' states. This community further argues that argument exchange is sometimes essential when various assumptions about agent rationality cannot be satisfied. To this end, in this article, we identify the main research motivations and ambitions behind work in the field. We then provide a conceptual framework through which we outline the core elements and features required by agents engaged in argumentation-based negotiation, as well as the environment that hosts these agents. For each of these elements, we survey and evaluate existing proposed techniques in the literature and highlight the major challenges that need to be addressed if argument-based negotiation research is to reach its full potential.

/pdf/argumentation-based-negotiation-49y6ojkxwb.pdf

Argumentation-based negotiation

While temporal logic in its various forms has proven essential to reason about reactive systems, agent-based scenarios are typically specified by considering high-level agents attitudes. In particular, specification languages based on epistemic logic [7], or logics for knowledge, have proven useful in a variety of areas including robotics, security protocols, web-services, etc. For example, security specifications involving anonymity [4] are known to be naturally expressible in epistemic formalisms as they explicitly state the lack of different kinds of knowledge of the principals.

/pdf/mcmas-a-model-checker-for-the-verification-of-multi-agent-11wqnfwtma.pdf

MCMAS: A Model Checker for the Verification of Multi-Agent Systems

Traditional (i.e. analytical) modelling practices in the social sciences rely on a very well established, although implicit, methodological protocol, both with respect to the way models are presented and to the kinds of analysis that are performed. Unfortunately, computer-simulated models often lack such a reference to an accepted methodological standard. This is one of the main reasons for the scepticism among mainstream social scientists that results in low acceptance of papers with agent-based methodology in the top journals. We identify some methodological pitfalls that, according to us, are common in papers employing agent-based simulations, and propose appropriate solutions. We discuss each issue with reference to a general characterization of dynamic micro models, which encompasses both analytical and simulation models. In the way, we also clarify some confusing terminology. We then propose a three-stage process that could lead to the establishment of methodological standards in social and economic simulations.

https://papers.ssrn.com/sol3/Delivery.cfm/SSRN_ID931875_code540974.pdf?abstractid=931875&mirid=1

A Common Protocol for Agent-Based Social Simulation

This paper introduces ASF, a variation of the BDI logic programming language ASL intended to permit the model-theoretic verification of multi-agent systems. After briefly introducing ASF and discussing its relationship to ASL, we show how ASF programs can be transformed into Prm, the model specification language for the Spin model-checking system. We also describe how specifications written in a simplified form of BDI logic can be transformed into Spin-format linear temporal logic formulae. With our approach, it is thus possible to automatically verify whether or not multi-agent systems implemented in ASF satisfy specifications expressed as BDI logic formulae. We illustrate our approach with a short case study, in which we show how BDI properties of a simulated auction system implemented in ASF were verified.

Model checking agentspeak

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.

http://www.sci.brooklyn.cuny.edu/~parsons/publications/conferences/aamas02a.pdf

Model checking multi-agent systems with MABLE

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.

Representing Agent Interaction Protocols with Agent UML

The work presented in this article is based upon a methodological approach for building Multi-Agent Systems specifications. The basic idea is to define such systems as a set of entities playing roles which have interactions between them. We present a mechanism for dynamic role-playing specification within a formal framework. The framework use a formalism which can express Multi-Agent Systems aspects. This formalism composes Object-Z and statecharts. The main features of this approach are: enough expressive power to obtain unbiased specifications, tools for specification analysis and refinement mechanisms allowing the refinement of a high level specification into a low level specification which can be easily implemented.

Agent UML class diagrams revisited

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...

/pdf/model-checking-for-multiagent-systems-the-mable-language-and-3omffccigs.pdf

Marc-Philippe Huget

Papers

Model checking multi-agent systems with MABLE

Representing Agent Interaction Protocols with Agent UML

Agent UML class diagrams revisited

Model checking for multiagent systems: the mable language and its applications

Fipa modeling: Interaction diagrams