Programming Multi-Agent Systems

In this paper we describe eJason, a prototype implementation of Jason, the well-known agent-oriented programming language, in Erlang, a concurrent functional programming language. The reason for choosing Erlang as the implementation vehicle is the surprising number of similarities between Jason and Erlang, e.g., both have their syntactical roots in logic programming, and share an actor-based process and communication model. Moreover, the Erlang runtime system implements lightweight processes and fast message passing between processes. Thus, by mapping Jason agents and agent-to-agent communication onto Erlang processes and Erlang process-to-process communication, we can create a very high-performing Jason implementation, potentially capable of supporting up to a hundred thousand concurrent actors. In this paper we describe in detail the implementation of Jason in Erlang, and provide early feedback on the performance of the implementation.

Agent communication has been standardized by FIPA in order to ensure interoperability of agent platforms. In practice only few deployed agent applications exist and agent technology remains a niche technology that runs its own isolated technology stack. In order to facilitate the integration of agents with well-established and used technologies the connection of agents with web services plays an important role. This problem has traditionally been tackled by creating translation elements that accept FIPA or web service requests as input and produce the opposite as output. In this paper we will show how a generic integration of web services can be achieved for agents that follow our active components approach. Active components allow encapsulating agent behavior in black box components that may act as service providers and consumers with explicit service interfaces. Thus, the integration approach will directly make use of these services. Concretely, the presented approach aims at answering two important questions. First, how can specific functionality of an existing agent system be made available to non-agent systems and users? Second, how can an agent system seamlessly integrate existing non agent functionality? The first aspect relates to the task of service publication while the latter refers to external service invocation. In this paper a generic conceptual approach for both aspects will be presented and it will be further shown how a specific integration with both WSDL and RESTful web services can be achieved. Example applications will be used to illustrate the approach in more details.

This paper presents four requirements for BDI-based agent programming languages to facilitate the implementation of autonomous robot control systems. The first requirement is to support the integration of these languages with robotic frameworks. The second requirement is real-time reaction and response to events. The real-time reactivity problem in the BDI architecture is discussed and a distributed BDI architecture is proposed to approach this problem. The third requirement is to extend the BDI architecture with sensory management components for the management of sensory events and detecting complex events. The fourth requirement is the representation of complex plans and the coordination of the parallel execution of plans. These requirements are derived from an extensive survey of current autonomous robot programming tools and architectures and a study of a home-care application scenario for the NAO robot.

We propose a new cognitive robot control architecture in which the cognitive layer can be programmed by means of the agent programming language Goal. The architecture exploits the support that agent-oriented programming offers for creating cognitive robotic agents, including symbolic knowledge representation, deliberation via modular, high-level action selection, and support for multiple, declarative goals. The benefits of the architecture are that it provides a flexible approach to develop cognitive robots and support for a clean and clear separation of concerns about symbolic reasoning and sub-symbolic processing. We discuss the design of our architecture and discuss the issue of translating sub-symbolic information and behavior control into symbolic representations needed at the cognitive layer. An interactive navigation task is presented as a proof of concept.

Building smart environments with Robotic ecologies, comprising of distributed sensors, actuators and mobile robot devices facilitates and extends the nature and form of smart environments that can be developed, and reduces the complexity and cost of such solutions. While the potentials of such an approach makes robotic ecologies increasingly popular, many fundamental research questions remain open. One such question is how to make a robotic ecology self-adaptive, so as to adapt to changing conditions and evolving requirements, and consequently reduce the amount of preparation and pre-programming required for their deployment in real world applications. This paper presents a framework for the specification and the programming of robotic ecologies. The framework extends an existing agent system and integrates it with the pre-existing and dominant traditional robotic and middleware approach to the development of robotic ecologies. We illustrate how these technologies complement each other and offer a candidate technology to pursue adaptive robotic ecologies.

The Agent Conversation Reasoning Engine (ACRE) is intended to aid agent developers to improve the management and reliability of agent communication. To evaluate its effectiveness, a problem scenario was created that could be used to compare code written with and without the use of ACRE by groups of test subjects.

This paper describes the requirements that the evaluation scenario was intended to meet and how these motivated the design of the problem. Two experiments were conducted with two separate sets of students and their solutions were analysed using a combination of simple objective metrics and subjective analysis. The analysis suggested that ACRE by default prevents some common problems arising that would limit the reliability and extensibility of conversation-handling code.

As ACRE has to date been integrated only with the Agent Factory multi agent framework, it was necessary to verify that the problems identified are not unique to that platform. Thus a comparison was made with best practice communication code written for the Jason platform, in order to demonstrate the wider applicability of a system such as ACRE.

Messages are considered to be a primary means of communication between agents in multi-agent systems. Since multi-agent systems are used for a wide variety of applications, it also includes applications like simulation and calculation of computer generated graphics which need to employ a large number of messages or very large messages. In addition, another set of applications target hardware which is resource constrained in either bandwidth or processing capacity. As a result, these applications have different requirements regarding their messages than other agent message formats. This paper proposes useful properties of agent messages and evaluates them with regard to different types of applications. Based on this evaluation a message format for Jadex called Jadex Binary is proposed which emphasizes properties which are not traditionally the focus of agent message formats and compare it to well-known formats based on those properties.

Agent programs are increasingly widely used for large scale, time critical applications. In developing such applications, the performance of the agent platform is a key concern. Many logic-based BDI-based agent programming languages rely on inferencing over some underlying knowledge representation. While this allows the development of flexible, declarative programs, repeated inferencing triggered by queries to the agent’s knowledge representation can result in poor performance. In this paper we present an approach to query caching for agent programming languages. Our approach is motivated by the observation that agents repeatedly perform queries against a database of beliefs and goals to select possible courses of action. Caching the results of previous queries (memoization) is therefore likely to be beneficial. We develop an abstract model of the performance of a logic-based BDI agent programming language. Using our model together with traces from typical agent programs, we quantify the possible performance improvements that can be achieved by memoization. Our results suggest that memoization has the potential to significantly increase the performance of logic-based agent platforms.

This paper investigates the issue of adaptability of behaviour in the context of agent-oriented programming. We focus on improving action selection in rule-based agent programming languages using a reinforcement learning mechanism under the hood. The novelty is that learning utilises the existing mental state representation of the agent, which means that (i) the programming model is unchanged and using learning within the program becomes straightforward, and (ii) adaptive behaviours can be combined with regular behaviours in a modular way. Overall, the key to effective programming in this setting is to balance between constraining behaviour using operational knowledge, and leaving flexibility to allow for ongoing adaptation. We illustrate this using different types of programs for solving the Blocks World problem.

The Multi-Agent Programming Contest, MAPC, is an annual, community-serving competition that attracts groups from all over the world. Its aim is to facilitate advances in programming multiagent systems (MAS) by (1) developing benchmark problems, (2) enabling head-to-head comparison of MAS’s and (3) supporting educational efforts in the design and implementation of MAS’s. We report about its eighth edition and give a detailed overview of the participants strategies and the overall contest.

In this paper we describe the SMADAS system used for the Multi-Agent Programming Contest in 2012. This contest offers an useful context to evaluate tools, techniques, and languages for programming MAS. It is also a good opportunity to learn agent programming and test new features we are developing in our projects. Throughout the paper we highlight the main strategies of our team and comment on the advantages and disadvantages of our system as well as some improvements that still could be done. One important result from this experience regards the agent programming language we used, it provides suitable abstractions for the development of complex system and shows an increment in its maturity since no bugs was discovered this year.

We provide a brief description of our Python-DTU system, including the overall design, the tools and the algorithms that we used in the Multi-Agent Programming Contest 2012, where the scenario was called Agents on Mars like in 2011. Our solution is an improvement of our Python-DTU system from last year. Our team ended in second place after winning at least one match against every opponent and we only lost to the winner of the tournament. We briefly describe our experiments with the Moise organizational model. Finally we propose a few areas of improvement, both with regards to our system and to the contest.

We describe our contribution to the Multi-Agent Programming Contest 2012, which has been developed by students and researchers of the DAI-Labor at TU Berlin, Germany, using the JIAC V agent framework and the agile JIAC methodology.

The Multi-Agent Programming Contest is to stimulate research in the area of multi-agent systems. In 2012, for the first time, a team from Sun Yat-sen University, Guangzhou, China, participated in the contest. The team is called AiWYX, and consists of a single member, who has just finished his undergraduate study. The system mainly exploits three strategies: strengthening action preconditions, task allocation optimization, and surrounding larger zones with shorter boundaries. With these strategies, our team is able to conquer large zones as early as possible, optimize collaboration, and ensure efficiency. The system was implemented in C++, and in this paper, we will introduce the design and architecture of AiWYX, and discuss the algorithms and implementations for these strategies.