Evaluating multiagent systems: a record/replay approach
Marc-philippe Huget
Yves Demazeau2004, Proceedings. IEEE/WIC/ACM International Conference on Intelligent Agent Technology, 2004. (IAT 2004).
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
The adoption of multiagent systems by companies and users requires that it is possible to verify the properties of the multiagent systems. The main candidate of this verification is model checking but as sketched in the paper, it presents drawbacks such as combinatorial explosion or it does not take the environment into account. Model checking seems to be restricted to small systems with few agents. In this paper, we present a different approach used in testing called the Record/Replay mechanism. We add as well a post-mortem analysis. This paper describes the advantages of this approach and how we have implemented it in the MadKit platform
Related papers
An Approach to Model Based Testing of Multiagent Systems
The Scientific World Journal, 2015
Autonomous agents perform on behalf of the user to achieve defined goals or objectives. They are situated in dynamic environment and are able to operate autonomously to achieve their goals. In a multiagent system, agents cooperate with each other to achieve a common goal. Testing of multiagent systems is a challenging task due to the autonomous and proactive behavior of agents. However, testing is required to build confidence into the working of a multiagent system. Prometheus methodology is a commonly used approach to design multiagents systems. Systematic and thorough testing of each interaction is necessary. This paper proposes a novel approach to testing of multiagent systems based on Prometheus design artifacts. In the proposed approach, different interactions between the agent and actors are considered to test the multiagent system. These interactions include percepts and actions along with messages between the agents which can be modeled in a protocol diagram. The protocol di...
Model Checking Multiagent Systems Model Checking Multiagent Systems
Model checking is a very successful technique which has been applied in the design and veriication of nite state concurrent reactive processes. In this paper we show how this technique can be lifted to be applicable to multiagent systems. Our approach allows us to reuse the technology and tools developed in model checking, to design and verify multiagent systems in a modular and incremental way, and also to have a very eecient model checking algorithm.
Model checking multi-agent systems
2006
Abstract A multi-agent system (MAS) is usually understood as a system composed of interacting autonomous agents. In this sense, MAS have been employed successfully as a modelling paradigm in a number of scenarios, especially in Computer Science. However, the process of modelling complex and heterogeneous systems is intrinsically prone to errors: for this reason, computer scientists are typically concerned with the issue of verifying that a system actually behaves as it is supposed to, especially when a system is complex.
Multi-agent systems implementation and testing
2004
The need of software tools for designing and testing complex distributed multi-agent systems is considerable. Over the past few years we have been developing a theoretical and practical methodology for designing, implementing and testing multi-agent systems. As part of this effort an agent-oriented CASE tool, which aims at simplifying the multi-agent system designer's work, and a testing framework, which provides a uniform and automated approach to the testing of multi-agent systems, have been designed and implemented. The aim of this paper is to give an overview of that work with particular attention to the recent results achieved. Therefore the paper mainly focuses on the testing tool and the issues connected with the diagrammatic notations, which should support developers when moving from the design phase towards the implementation phase of multi-agent systems.
Multiagent Systems Verification via Model Checking
Model checking is a very successful technique which has been applied in the design and verification of finite state concurrent reactive processes. In this paper we show how this technique can be lifted to be applicable to multiagent systems. Our approach allows us to reuse the technology and tools developed in model checking, to design and verify multiagent systems in a modular and incremental way, and also to have a very efficient model checking algorithm.
VaToMAS-Verification and Testing of Multi-Agent Systems (Dagstuhl Seminar 13181)
This report documents the program and the outcomes of Dagstuhl Seminar 13181 "VaToMAS-Verification and Testing of Multi-Agent Systems".
MCMAS: A model checker for multi-agent systems
2006
This paper presents mcmas, a model checker for Multi-Agent Systems (MAS). Differently from traditional model checkers, mcmas permits the automatic verification of specifications that use epistemic, correctness, and cooperation modalities, in addition to the standard temporal modalities.
An Unexpected Journey: Towards Runtime Verification of Multiagent Systems and Beyond
2019
The Trace Expression formalism derives from works started in 2012 and is mainly used to specify and verify interaction protocols at runtime, but other applications have been devised. More speci cally, this thesis describes how to extend and apply such formalism in the engineering process of distributed arti cial intelligence systems (such as Multiagent systems). This thesis extends the state of the art through four di erent contributions: 1. Theoretical: the thesis extends the original formalism in order to represent also parametric and probabilistic speci cations (parametric trace expressions and probabilistic trace expressions respectively). 2. Algorithmic: the thesis proposes algorithms for verifying trace expressions at runtime in a decentralized way. The algorithms have been designed to be as general as possible, but their implementation and experimentation address scenarios where the modelled and observed events are communicative events (interactions) inside a multiagent syste...
Validation and Verification of Multi-Agent Systems
Citation: Manson, S. M. (2003). Validation and verification of multi-agent models for ecosystem management. In Complexity and Ecosystem Management: The Theory and Practice of Multi-Agent Approaches. M. Janssen (ed). Northampton, Massachusetts: Edward Elgar Publishers, pp. 63-74. PREPRESS VERSION 2 5.1 INTRODUCTION
Verifying Multi-agent Programs by Model Checking
Autonomous Agents and Multi-Agent Systems, 2006
This paper gives an overview of our recent work on an approach to verifying multi-agent programs. We automatically translate multi-agent systems programmed in the logic-based agent-oriented programming language AgentSpeak into either Promela or Java, and then use the associated Spin and JPF model checkers to verify the resulting systems. We also describe the simplified BDI logical language that is used to write the properties we want the systems to satisfy. The approach is illustrated by means of a simple case study.
Model checking agentspeak
2003
This paper introduces AgentSpeak(F), a variation of the BDI logic programming language AgentSpeak(L) intended to permit the model-theoretic verification of multi-agent systems. After briefly introducing AgentSpeak(F) and discussing its relationship to AgentSpeak(L), we show how AgentSpeak(F) programs can be transformed into Promela, 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 AgentSpeak(F) 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 AgentSpeak(F) were verified.
Model checking for multiagent systems: The MABLE language and its applications
2006
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.
A Publish-Subscribe based Architecture for Testing Multiagent Systems
Multiagent systems (MASs) have been applied to several application domains, such as e-commerce, unmanned vehicles, and many others. In addition, a set of different techniques has been integrated into multiagent applications. However, few of these applications have been commercially deployed and few of these techniques have been fully exploited by industrial applications. One reason is the lack of procedures guaranteeing that multiagent systems would behave as desired. Most of the existing test approaches only test agents as single individuals and do not provide ways of inspecting the behavior of an agent as part of a group, and the behavior of the whole group of agents. Accordingly, we modeled and developed a publishsubscribe-based architecture to facilitate the implementation of systems to test MASs at the agent and group levels. To illustrate and evaluate the use of the proposed architecture, we developed an MAS-based application and performed functional and performance ad-hoc tests.
Model checking multi-agent systems with MABLE
2002
Abstract 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.
An integrated approach for the development and validation of multi-agent systems
… Journal of Computer Systems Science & …, 2005
In this paper, an integrated approach for the development and validation through simulation of multi-agent systems is proposed and exemplified through a case study concerning with an agent-based consumer-driven e-Marketplace. The approach centres on the instantiation of a software development process by using the method engineering paradigm. As a distinctive feature this process specifically includes a simulation phase which makes it possible the validation of a multi-agent system under development before its actual deployment and execution. In particular, the integrated approach uses the Gaia methodology for the analysis and the design, the Agent UML and the Distilled StateCharts for the detailed design, the MAO Framework for the neutral-platform implementation of software agents, and a Java-based discrete-event simulation framework for the simulation.
Specification and Verification of Multi-agent Systems
2010
... & Computing Sciences Padualaan 14 3584 CH Utrecht The Netherlands [email protected] John-Jules Ch. Meyer Utrecht University Dept. Information & Computer Sciences Padualaan 14 3584 CH Utrecht The Netherlands [email protected] Koen V. Hindriks Delft University of ...
MCMAS: A model checker for the verification of multi-agent systems
2009
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.
Automated Verification of Multi-Agent Programs
2008 23rd IEEE/ACM International Conference on Automated Software Engineering, 2008
In this paper, we show that the flexible modelchecking of multi-agent systems, implemented using agentoriented programming languages, is viable thus paving the way for the construction of verifiably correct applications of autonomous agents and multi-agent systems. Model checking experiments were carried out on AJPF (Agent JPF), our extension of Java PathFinder that incorporates the Agent Infrastructure Layer, our unifying framework for agent programming languages. In our approach, properties are specified in a temporal language extended with (shallow) agent-related modalities. The framework then allows the verification of programs written in a variety of agent programming languages, thus removing the need for individual languages to implement their own verification framework. It even allows the verification of multi-agent systems comprised of agents developed in a variety of different (agent) programming languages. As an example, we also provide model checking results for the verification of a multi-agent system implementing a well-known task sharing protocol.
Report from Dagstuhl Seminar 13181: VaToMAS – Verification and Testing of Multi-Agent Systems
http://drops.dagstuhl.de/opus/volltexte/2013/4174/
Related topics
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.