Abstract—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. I.

The concept of an agent is increasingly used in contemporary software applications, particularly those involving the Internet, autonomous systems, or cooperation. However, with dependability and safety in mind, it is vital that the mechanisms for representing and implementing agents are clear and consistent. Hence there has been a strong research effort directed at using formal logic as the basis for agent descriptions and agent implementation. Such a logical basis not only presents the clarity and consistency required but also allows for important techniques such as logical verification to be applied. We present a roadmap of research into the use of computational logic in agent-based systems and survey much of the recent work in these areas. Even though, with such a rapidly changing field, it is impossible to cover every development, we aim to give the reader sufficient background to understand the current research problems and potential future developments in this maturing area.

Abstract. We describe the Gwendolen BDI (Belief, Desires and Intentions) agent programming language. Gwendolen is implemented in the Agent Infrastructure Layer (AIL), a collection of Java classes intended for use in model checking agent programs in a variety of languages. The Gwendolen language was developed to test key features of the AIL and its integration with the model checker, JPF, and also to provide a default semantics for the AIL classes. 1

Abstract. Our overall aim is to provide a verification framework for practical multi-agent systems. To achieve practicality, we must be able to describe and implement heterogeneous multi-agent systems. To achieve verifiability, we must define semantics appropriately for use in formal verification. Thus, in this paper, we tackle the problem of implementing heterogeneous multi-agent systems in a semantically clear, and appropriate, way. 1

Abstract—The actor programming model offers a promising model for developing reliable parallel and distributed code. Actors provide flexibility and scalability: local execution may be interleaved, and distributed nodes may operate asynchronously. The resulting nondeterminism is captured by nondeterministic processing of messages. To automate testing, researchers have developed several tools tailored to specific actor systems. As actor languages and libraries continue to evolve, such tools have to be reimplemented. Because many actor systems are compiled to Java bytecode, we have developed Basset, a general framework for testing actor systems compiled to Java bytecode. We illustrate Basset by instantiating it for the Scala programming language and for the ActorFoundry library for Java. Our implementation builds on Java PathFinder, a widely used model checker for Java. Experiments show that Basset can effectively explore executions of actor programs; e.g., it discovered a previously unknown bug in a Scala application. I.

Abstract. Agent-Oriented Software Engineering (AOSE) methodologies are proposed to develop complex distributed systems based upon the agent paradigm. The natural implementation for such systems has usually the form of Multi-Agent Systems (MAS). As these systems are increasingly applied in mission-critical services, assurances need to be given to their owners and users that they operate properly. Although the relevance of the link between requirements engineering and testing has long been recognized, current Agent-Oriented Software Engineering (AOSE) methodologies partially address it. Some of them offer specification-based formal verification, allowing software developers to correct errors at the beginning of the development process, others exploits Object-Oriented (OO) testing techniques, upon a mapping of agent-oriented abstractions into OO constructs. However, a structured testing process for AOSE methodologies that complements formal verification is still missing. In this paper we introduce a testing framework for the AOSE methodology Tropos. It specifies a testing process model that complements the agent-oriented requirements and design models and strengthens the mutual relationship between goal analysis and testing. Furthermore, it provides a systematic way of deriving test cases from goal analysis. We call this approach goal-oriented testing. 1

We present a proof-technique for reducing the nondeterminism of abstract agent specifications in a BDI framework by means of refinement. We implement the operational semantics of agent specifications in rewrite systems such that we can automatically check if refinement between (fair) executions of agents holds.

We present a family of sound and complete logics for reasoning about deliberation strategies for SimpleAPL programs. SimpleAPL is a fragment of the agent programming language 3APL designed for the implementation of cognitive agents with beliefs, goals and plans. The logics are variants of PDL, and allow us to prove safety and liveness properties of SimpleAPL agent programs under different deliberation strategies. We show how to axiomatize different deliberation strategies for SimpleAPL programs, and, for each strategy we consider, prove a correspondence between the operational semantics of SimpleAPL and the models of the corresponding logic. We illustrate the utility of our approach with an example in which we show how to verify correctness properties for a simple agent program under different deliberation strategies.

Multi-agent Systems are seen as being an appropriate technology to develop complex distributed software systems. The development of such systems requires a methodology that can guide developers to build and maintain such complex software systems. From the software engineering perspective, the systematic development of software should follow several phases. The number and purpose of the phases depend on the problem domain and the methodology. In general, it is easy to find requirement elicitation, system analysis, architectural design, implementation, and validation/verification phases in most software development methodologies. Various agent-oriented methodologies have been proposed, such as GAIA (Zambonelli et al. 2003), Prometheus (Padgham and Winikoff 2004), Tropos (Bresciani et al. 2003), MaSE (DeLoach et al. 2001), SODA (Omicini 2000), MAS-CommonKADS (Iglesias et al. 1998), and INGENIAS (Gomez-sanz et al. 2003). Each of these methodologies focuses on the role of agent abstractions on certain phases of the multi-agent system development. However, the main focus

Abstract Models of agents or multiagent systems in a certain application area can be made at different levels of abstraction. The aim of this paper is to clarify different types of abstraction levels for agent systems by expliciting different dimensions of abstraction. The three dimensions of considered are: the process abstraction dimension, the temporal dimension, and the agent cluster dimension. Thus a three-dimensional framework is obtained in which different types of multi-agent system models can be classified. For a number of multiagent system models in different application areas from the literature it is discussed how they fit in the framework. 1