Programming Multi-Agent Systems

Distributed partially observable Markov decision problems (POMDPs) have emerged as a popular decision-theoretic approach for planning for multiagent teams, where it is imperative for the agents to be able to reason about the rewards (and costs) for their actions in the presence of uncertainty. However, finding the optimal distributed POMDP policy is computationally intractable (NEXP-Complete). This paper is focussed on a principled way to combine the two dominant paradigms for building multiagent team plans, namely the “belief-desire-intention” (BDI) approach and distributed POMDPs. In this hybrid BDI-POMDP approach, BDI team plans are exploited to improve distributed POMDP tractability and distributed POMDP-based analysis improves BDI team plan performance. Concretely, we focus on role allocation, a fundamental problem in BDI teams – which agents to allocate to the different roles in the team. The hybrid BDI-POMDP approach provides three key contributions. First, unlike prior work in multiagent role allocation, we describe a role allocation technique that takes into account future uncertainties in the domain. The second contribution is a novel decomposition technique, which exploits the structure in the BDI team plans to significantly prune the search space of combinatorially many role allocations. Our third key contribution is a significantly faster policy evaluation algorithm suited for our BDI-POMDP hybrid approach. Finally, we also present experimental results from two domains: mission rehearsal simulation and RoboCupRescue disaster rescue simulation. In the RoboCupRescue domain, we show that the role allocation technique presented in this paper is capable of performing at human expert levels by comparing with the allocations chosen by humans in the actual RoboCupRescue simulation environment.

In the 10 years since the first ATAL workshop was held, Agent and Multi-Agent Systems have been a spectacular growth area of research in Computer Science. The field has certainly developed in terms of indicators such as number of publications, conferences and workshops. A view now expressed by many in the agent research community, and others, is that agents represent the ’next big thing’ in software development and are poised to supplant object-oriented approaches. But is there any realistic prospect of this happening? Is the state-of-the-art in agents and the focus of agent research really relevant to enterprise computing? What might enterprise-ready agent technology look like? What factors would drive enterprises to invest in such solutions? This talk will attempt to analyze underlying issues and offer some answers to these questions.

Agent-oriented system development aims to simplify the construction of complex systems by introducing a natural abstraction layer on top of the object-oriented paradigm composed of autonomous interacting actors. One main advantage of the agent metaphor is that an agent can be described similar to the characteristics of the human mind consisting of several interrelated concepts which constitute the internal agent structure. General consensus exists that the Belief-Desire-Intention (BDI) model is well suited for describing an agent’s mental state. The desires (goals) of an agent represent its motivational stance and are the main source for the agent’s actions. Therefore, the representation and handling of goals play a central role in goal-oriented requirements analysis and modelling techniques. Nevertheless, currently available BDI agent platforms mostly abstract from goals and do not represent them explicitly. This leads to a gap between design and implementation with respect to the available concepts. In this paper a generic representation of goal types, properties, and lifecycles is developed in consideration of existing goal-oriented requirements engineering and modelling techniques. The objective of this proposal is to bridge the gap between agent specification and implementation of goals and is backed by experiences gained from developing a generic agent framework.

For AOP (Agent Oriented Programming) to become a mature discipline, lessons must be learned from practical language implementations. We present AF-APL (AgentFactory – Agent Programming Language) as an Agent Oriented Programming Language that has matured with continued revisions and implementations, resulting in a language – which, although based on the more theoretical aspects of AO design – has incorporated many of the practical considerations of programming real world agents. We describe AF-APL informally, focusing on its experience driven features, such as commitment reasoning, a rich plan operator set, and an inherent asynchronous design. We present the default execution cycle for the AF-APL interpreter, looking in detail at the Commitment Management model. This model provides an agent with power to reason about its own actions, while maintaining basic constraints on computational tractability. In our development of the language, we learned many lessons that are not covered in the purer AO language definitions. Before concluding, we discuss a number of these lessons.

Autonomy is largely accepted as a major distinctive characteristic of agents with respect of other computation models. This is one of the main reasons why the agent community has been investigating from different perspectives constraints and the tight relationship between autonomy and constraints. In this paper, we take the software engineering standpoint and we exploit the results of the research on constraint programming to provide the developer with a set of tools for the realization of constraint-based multiagent systems. In detail, the purpose of this paper is twofold. In the first part it presents a model that regards multiagent systems in terms of constraint programming concepts. This model comprises an abstract picture of what a multiagent system is from the point of view of constraint programming and a language for modeling agents as solvers of constraint satisfaction and optimization problems. The second part of this paper describes an implemented toolkit that exploits this model to support the developer in programming and deploying constraint-based multiagent systems. This toolkit consists of a compiler and a runtime platform.

As agent systems become more sophisticated, there is a growing need for agent-oriented debugging, maintenance, and testing methods and tools. This paper presents the Tracing Method and accompanying Tracer tool to help debug agents by explaining actual agent behavior in the implemented system. The Tracing Method captures dynamic run-time data by logging actual agent behavior, creates modeled interpretations in terms of agent concepts (e.g. beliefs, goals, and intentions), and analyzes those models to gain insight into both the design and the implemented agent behavior. An implementation of the Tracing Method is the Tracer tool, which is demonstrated in a target-monitoring domain. The Tracer tool can help (1) determine if agent design specifications are correctly implemented and guide debugging efforts and (2) discover and examine motivations for agent behaviors such as beliefs, communications, and intentions.

This paper presents a mobile agents platform called SyMPA, compliant with the specifications of the MASIF standard from the OMG, that supports both stationary and mobile agents implemented using the high-level agent-oriented programming language CLAIM. Agents designed thanks to CLAIM are endowed with cognitive capabilities, are able to communicate with other agents and are mobile. The primitives of mobility are inspired from the ambient calculus. The paper is focused on SyMPA’s architecture, mobility, implementation and security elements.

Multi-agent systems are attractive means for developing complex software systems. However, multi-agent systems themselves tend to be complex, and certain difficulties exist in developing them. One of the difficulties is the gap between design and implementation especially for interaction protocols. In this paper, we propose a new interaction protocol description language called IOM/T. Interaction protocols described using IOM/T have clear correspondence with AUML sequence diagrams and the description can be consolidated into a single unit of IOM/T code. Then, we show how the process of implementing Java-based agent-platform code from AUML design can be carried out, and how IOM/T effectively bridges the gap between design and implementation.

A mobile agent application often involves a collection of agents working together for a common task. For cooperation among agents to succeed, an effective inter-agent communication framework is required. This paper describes the design of the communication mechanism in IMAGO Prolog. IMAGO Prolog is a variant of Prolog with an extended API for intelligent mobile agent applications. It deploys mobile messengers for inter-agent communication. Messengers are anonymous, thin agents dedicated to deliver messages. A messenger can move, clone, and make decisions for its assigned task: track down the receiving agent and reliably deliver messages in a dynamic, changing world. Moreover, agent communication language is purely declarative and consistent with the syntax, semantics and pragmatics of Prolog. As a result, mobile agents exchange information and achieve synchronization through first order logic terms and unification.

In this paper, we propose a framework for modelling agent organizations, Omni, that allows the balance of global organizational requirements with the autonomy of individual agents. It specifies global goals of the system independently from those of the specific agents that populate the system. Both the norms that regulate interaction between agents, as well as the contextual meaning of those interactions are important aspects when specifying the organizational structure. Omni integrates all this aspects in one framework. In order to make design of the multi-agent system manageable, we distinguish three levels of abstraction with increasing implementation detail. All dimensions of Omni have a formal logical semantics, which ensures consistency and possibility of verification of the different aspects of the system. Omni is therefore utmost suitable for the modelling of all types of MAS from open to closed environments.

This paper proposes a dialogue game in which coherent conversational sequences at the speech act level are described of agents that become aware they have an irresolvable disagreement and settle the dispute by agreeing to disagree. A disagreement is irresolvable from an agent’s perspective if the agent is aware that both parties have ran out of options to resolve the dispute, and that both parties are aware of this. A dialogue game is formulated in which agents can offer information that may unintentionally result in irreconcilable, mutually inconsistent belief states. Based on the agents’ cognitive states, dialogue rules and cognitive rules are defined that allow agents to come to an agreement to disagree. These rules are implemented in the programming language Prolog, resulting in an intuitive design for multi-agent systems.

The design of complex systems needs sophisticated coordination mechanisms. This paper proposes an approach based on multi-agent planning to coordinate such systems in the tactical aircraft simulation domain. This paper presents an integral cycle, from modelling to validation, that enables the building of feasible multi-agent plans as developped in a project named SCALA promoted at Dassault Aviation.