Programming Multi-Agent Systems

Multiagent systems have been proposed in the literature as a suitable architectural and implementation approach for cross-enterprise collaboration, due to their support for decentral decision-making and peer-to-peer coordination, loosely coupled interaction, modeling support for the notion of electronic institutions, and built-in adaptability mechanisms. While we agree with this general view, we argue that different application domain and different market constellations require different types of architecture. In this paper we look at the specific problem of selecting an information and communication technology (ICT) architecture for cross-enterprise business process (CBP) design and enactment. Therefore we identify three important architectural patterns for CBP enactment. We then propose a decision method for architecture selection based on the analytic hierarchy process (AHP) approach. Finally we illustrate the method by applying it to two application scenarios with differing characteristics. Robustness of the decision method is analyzed by performing a sensitivity analysis.

Goal Oriented Teams (GORITE) is a Java framework for implementation of Goal Oriented Process Models in a Team Oriented Paradigm. The GORITE concept combines a Team Oriented view of software systems with Goal Oriented process modelling, and offers an effective approach to complex and large-scale software. A Java developer would use GORITE for implementing their Team Oriented design, and whilst the framework makes this a straight-forward task, it relies on the Java developer utilising background skills in Team and Goal Oriented Programming to form the design. The Goal Oriented Programming side of GORITE provides a BDI (Belief - Desire - Intention) style execution machinery for goal oriented process models. Technically the goal hierarchies, which define how goals are achieved by means of achieving sub goals, are data structures that are interpreted in order to carry out the process steps that achieving the goals require. The Team Oriented Programming paradigm takes systems design to a new level. As design concept it extends the Agent Oriented Programming paradigm by including explicit modelling of the organisation of agents that comprise an application, whilst allowing for openness in actual composition. This paper is a presentation of the GORITE framework, with a primary focus on illustrating how the GORITE elements are used for capturing Goal Oriented Teams designs, and with less focus on the methodological philosophy underpinning this style of programming.

This paper presents a novel way of incorporating accounting features into agents. Network management techniques and methods are investigated and adopted to the agent case. We then use an example to show how sophisticated accounting technologies can be used. The example has been implemented using the JIAC platform.

We show how protocols (or interaction patterns) can be derived from norms using landmarks. The resulting protocols can be used by agents to perform their interactions while being certain to stay within the norms governing an e-institution without having to have a capability for normative reasoning. It can also be used by normative agents as a default protocol to be used, but from which they can deviate in specific circumstances.

This paper presents an ontology-based approach to promote the interoperability among agents that represent their knowledge through Bayesian networks. This research relies on Semantic Web foundations to achieve knowledge interoperability in the context of multiagent systems. Our first step was the specification of an ontology that formalizes the structures of the Bayesian network representation. It was developed using OWL, which is a W3C recommendation for ontology language. Once handled the issue of the knowledge representation, we specify how a Bayesian agent operates such representation. Thus, we define a model of internal architecture to support Bayesian agents in the knowledge sharing and maintenance tasks. The utilization of the architecture is exemplified through a case study developed in the context of a multiagent educational portal (PortEdu). The case study demonstrates the interoperability resulted from the architecture integration with Bayesian agents hosted in PortEdu.

In human society, almost any cooperative working context accounts for different kinds of object, tool, artifact in general, that humans adopt, share and intelligently exploit so as to support their working activities, in particular social ones. According to theories in human sciences, such entities have a key role in determining the success or failure of the activities, playing an essential function in simplifying complex tasks and—more generally—in designing solutions that scale with activity complexity. Analogously to the human case, we claim that also (cognitive) multi-agent systems (MAS) could greatly benefit from the definition and systematic exploitation of a suitable notion of working environment, composed by different sorts of artifacts, dynamically constructed, shared and used by agents to support their working activities. Along this line, in this paper we introduce and discuss a programming model called A&A (Agents and Artifacts), which aims at directly modelling and engineering such aspects in the context of cognitive MAS. Besides the conceptual framework, we present the current state of prototyping technologies implementing A&A principles—CARTAGO platform in particular—, and show how they can be integrated with existing cognitive MAS programming frameworks, adopting the Jason programming platform as the reference case.

This paper discusses the need for an effective and practical BDI-based agent-oriented programming language with formal semantics. It proposes an alternative by presenting the syntax and semantics of a programming language, called 2APL (A Practical Agent Programming Language). This programming language facilitates the implementation of multi-agent systems consisting of individual cognitive agents. 2APL distinguishes itself from other BDI-based agent-oriented programming languages by having formal semantics while realising an effective integration of declarative and imperative style programming. This is done by introducing a set of practical programming constructs, including both declarative goals and events (which are used interchangeably in other programming languages), and specifying their operational semantics.

We describe the design of an intermediate language (AIL) for BDI-style programming languages. AIL is not intended as yet another programming language, but is meant to provide a common semantic basis for a number of BDI programming languages in order to support both formal verification and the transfer of concepts and developments. We examine some of the key features of AIL, unifying a wide variety of structures appearing in the operational semantics of BDI programming languages. In particular, we highlight issues in the treatment of events, goals, and intentions, which are central to the design of these languages.

There is a huge gap between agent programming languages used for industrial applications and those developed in academia. While the former are mostly extensions of mainstream programming languages (e.g. Java), the latter are often very specialized languages, based on reactive rules. These specialized languages enjoy clear semantics and come with a number of knowledge representation features, but lack important aspects such as code re-use, modularity, encapsulation etc.

This paper deals with the design of multi-agent systems. We demonstrate the goal-oriented agent model called Goal Decomposition Tree on an already studied multi-agent example, that of robots which must clean pieces of garbage on Mars. As we show, the model allows to prove that the agents’ behaviour indeed achieves their goal. We then compare our approach to other ones.

Programming multi-agent systems is a hard task and requires tools to assist in the process of testing, validation and verification of both MAS specifications and source code. In this paper, we propose the use of causality graphs, adapted to the context of debugging multi-agents systems, to track causality of events produced in interactions among agents in a group. We believe that simple sequence diagrams are not enough to visually track what are the predecessors or causes of a given new event (i.e. an unexpected message or the observation that a message did not came). We propose this kind of graph as an alternative. We redefine the concept of causality graph for this particular field and propose an algorithm for generation of such a graph.

This paper shows how multiagent systems can be modeled by a combination of UML statecharts and hybrid automata. This allows formal system specification on different levels of abstraction on the one hand and expressing real-time system behavior with continuous variables on the other hand. It is shown, how multi-robot systems can be modeled by hybrid and hierarchical state machines and how model checking techniques for hybrid automata can be applied. An enhanced synchronization concept is introduced that allows synchronization taking time and avoids state explosion to a certain extent.

This paper summarises the Agent Contest 2007 which was organized in association with ProMAS’07. The aim of this contest is to stimulate research in the area of multi-agent systems by identifying key problems and collecting suitable benchmarks that can serve as milestones for evaluating new tools, models, and techniques to develop multi-agent systems. The first two editions of this contest were organized in association with CLIMA conference series. Based on the experiences from the previous two editions ([8,9]), the contest scenario has been slightly extended to test the participating multi-agent systems on their abilities to coordinate, cooperate, and their team work and team strategy issues in a dynamic environment where teams compete for the same resources. Six groups from Germany, Brazil, England, Australia and The Netherlands did participate in this contest. The actual contest took place prior to the ProMAS’07 workshop and the winner, a group from the technical university of Berlin, was announced during ProMAS’07.

This document gives an overview of a multi-agent system formed by a team of gold miners to compete in the Multi-Agent Programming Contest 2007 (the “gold miners” scenario). One of the main objectives has been to test and improve Jason , the interpreter for an agent programming language used to implement the MAS. Jason [2,4] is an agent platform based on an extension of an agent-oriented programming language called AgentSpeak(L) [6]. The language is inspired by the BDI architecture [7], hence based on notions such as beliefs, goals, plans, intentions, etc.

This paper describes our approach to the Multi-Agent Programming Contest in coordination with ProMAS and AAMAS 2007. The object of the contest is to mine as much gold as possible in competition with other teams in a multi-agent goldrush scenario. Our agents are implemented in 2APL, a BDI-based agent-oriented programming language. As required by the contest, we designed and specified our approach using a multi-agent methodology. Several methodologies were evaluated, and eventually we chose a combination of \(\mathcal{M}\)oise⁺ and Tropos.

This paper describes our contribution to the Multi-Agent Programming Contest organised as part of the ProMAS 2007 workshop. The objective of this contribution was the evaluation of a new lightweight agent architecture targeted at devices with different capabilities. Therefore, the agents developed in this work can run on mobile devices that makes our approach different from the other contributions to the competition.

A competition always shows the performance of the participants. We have developed the JIAC IV agent framework over years now and took this as a chance to see where we stand. This paper describes our approach to the contest scenario from a software engineering point of view, i. e. how we would solve similar problems of complex and distributed nature.

FLUX is a constraint logic programming system based on a general calculus for reasoning about actions. FLUX supports the development of agents that base their decisions on their own knowledge state and update this state in accordance with a declarative specification of their primitive actions and sensing capabilities. This is the second time we participate in the Multi-Agent Programming Contest with a team of FLUX agents, and in this paper we describe an improved system architecture for competing in the Gold Mining Domain.