Action and Perception in Agent Programming Languages: From Exogenous to Endogenous Environments

Agents are an important technology that have the potential to take over contemporary methods for analysing, designing, and implementing complex software. The Belief-Desire-Intention (BDI) agent paradigm has proven to be one of the major approaches to intelligent agent systems, both in academia and in industry. Typical BDI agent-oriented programming languages rely on user-provided “plan libraries” to achieve goals, and online context sensitive subgoal selection and expansion. These allow for the development of systems that are extremely flexible and responsive to the environment, and as a result, well suited for complex applications with (soft) real-time reasoning and control requirements. Nonetheless, complex decision making that goes beyond, but is compatible with, run-time context-dependent plan selection is one of the most natural and important next steps within this technology. In this paper we develop a typical BDI-style agent-oriented programming language that enhances usual BDI programming style with three distinguished features: declarative goals, look-ahead planning, and failure handling. First, an account that mixes both procedural and declarative aspects of goals is necessary in order to reason about important properties of goals and to decouple plans from what these plans are meant to achieve. Second, lookahead deliberation about the effects of one choice of expansion over another is clearly desirable or even mandatory in many circumstances so as to guarantee goal achievability and to avoid undesired situations. Finally, a failure handling mechanism, suitably integrated with both declarative goals and planning, is required in order to model an adequate level of commitment to goals, as well as to be consistent with most real BDI implemented systems.

This paper presents the support for interaction protocols that has been recently added to the JADEL programming language. JADEL is an agent-oriented programming language designed to ease the development of JADE agents and multi-agent systems by offering general-purpose agent-oriented abstractions to the programmer. The first part of the paper presents JADEL and motivates the need for a new agent-oriented programming language. Then, the agent-oriented abstractions that JADEL has been providing since its first version-namely agents, behaviours and communication ontologies-are described. The new support for interaction protocols is finally presented, and a simple example of a JADEL multi-agent system that uses interaction protocols is reported. The paper is concluded with an overview of the current state of JADEL and related tools.

Normative organisations provide a means to coordinate the activities of individual agents in multiagent settings. The coordination is realized at run time by creating obligations and prohibitions (norms) for individual agents. If an agent cannot meet an obligation or violates a prohibition, the organisation imposes a sanction on the agent. In this paper, we consider norm-aware agents that deliberate on their goals, norms and sanctions before deciding which plan to select and execute. A norm-aware agent is able to violate norms (accepting the resulting sanctions) if it is in the agent's overall interests to do so, e.g., if meeting an obligation would result in an important goal of the agent becoming unachievable. Programming norm-aware agents in conventional BDI-based agent programming languages is difficult, as they lack support for deliberating about goals, norms, sanctions and deadlines. We present the norm-aware agent programming language N-2APL. N-2APL is based on 2APL and provides support for beliefs, goals, plans, norms, sanctions and deadlines. We give the syntax and semantics of N-2APL, and show that N-2APL agents are rational in the sense of committing to a set of plans that will achieve the agent's most important goals and obligations by their deadlines while respecting its most important prohibitions.

This paper summarizes the current state of development of JADEL, a novel programming language that eases the implementation of agents and multi-agent systems. First, the introduction of a novel agent programming language is motivated and the approach that was used to design JADEL is presented. Then, the characteristic features of JADEL are described by means of a didactic example. The paper is concluded with a short discussion about current and planned developments of JADEL.

Social and organizational aspects of agency have become a major issue in the Multi-Agent Systems (MAS) domain. Recent applications of MAS on Web and Ambient Computing enforce the need of using these dimensions in the programming of MAS. The aim is to ensure the governance of such systems while preserving their decentralization and openness. In this talk, we present how multi-agent organisations provide software abstractions, models and tools that contribute to this aim. We focus on the MOISE framework that we have developped during these last years. This framework proposes an organisation programming language for defining multi-agent organisations, that are managed and supported by organisational artifacts at the system programming level and by organisation-awareness mechanisms at the agent programming level. This framework is included in the JaCaMo platform, integration of Jason Agent Programming Language, CarTaGo environment platform and MOISE. We illustrate different features of Organisation Oriented Programming of MAS using different application examples. We will highlight also how it integrates in a broader perspective of multi-agent oriented programming of decentralized and open systems.

Intelligent agents have been regarded as a new notion to build complex software systems. In this paper, we propose an agent-based software development process based on Belief-Desire-Intention (BDI) agent model as a new software development process. The Belief-Desire-Intention (BDI) model has been used as a fundamental ingredient to the new agent-based modeling method. In our agent system proposed here, each agent is made flesh by assigning its own belief, desire and intention. Here we have shown a seamless software development modeling technique consistently based on the BDI model. Even though there are many valuable arguments to define agents beside the BDI model, we currently use the BDI model only to simplify the agent modeling because we try to develop a more realistic agent-based modeling technique. We will extend this work to support other key concepts in agent computing.Here we propose a new approach comparing it with our previous approach to support the BDI agent-based modeling techniques. The previous approach finds intentions, desires and beliefs from two different kinds of use cases - external use cases and internal use cases - and supporting tools. The new approach finds in sequence desires, intentions and beliefs by using not only different kinds of use cases, sequence diagram, activity diagrams, and dataflow diagrams. To prove the usability of our software development process, we also provide a case study to clarify the description of our BDI agent software development process. This paper also introduces a brief structure of a CASE tool that we are currently developing to support the BDI agent software development process.

Agent-oriented programming is a programming model proposed to design complex programs. To simplify the implementation of agent systems, several new agent-oriented programming languages (AOPL) have been proposed. Usually, these languages are developed using informal techniques and implemented in an ad hoc manner. The lack of formal methods and adequate analysis tools makes the design of these languages a hard and error prone task. This paper shows the advantages of using action semantics and related tools in the project of new AOPLs. Action semantics is a formalism used to describe programming languages that produces specifications that can be easily extended and reused in new projects. To demonstrate this action semantics approach, we have developed a specification of some basic agent concepts as well as a tool that aids the validation and execution of action semantics specifications. Using this approach, the programming language designer obtains a powerful design environment to propose and test new kinds of agent concepts, components and constructors.

The mainstream approach to design of BDI-inspired agent programming languages is to choose a set of agent-oriented features with a particular semantics and their subsequent implementation in the programming language interpreter. The language designer's choices thus impose strong constraints on the architecture of the implemented agents as well as only a limited toolbox of high-level language constructs for encoding the agent program. As an alternative, we propose a purely syntactic approach to designing an agent programming language. On the substrate of Behavioural State Machines (BSM ), a generic modular programming language for hybrid agents, we show how an agent designer can implement high-level agent-oriented constructs in the form of code patterns (macros). To express the semantics of agent programs in the logic-agnostic programming language of BSM, we propose LTL program annotations and subsequently introduce DCTL*, an extension of the CTL* logic with features of dynamic logic, for reasoning about traces of BSM program executions. We show how DCTL* specifications can be used to prove relevant properties of code patterns. Moreover, DCTL* allows for natural verification of BSM agent programs.

The Belief Desire Intention (BDI) model of agency is a popular and mature paradigm for designing and implementing multiagent systems. There are several agent implementation platforms that follow the BDI model. In BDI systems, the agents typically have to pursue multiple goals, and often concurrently. The way in which the agents commit to achieving their goals forms their intentions. There has been much work on scheduling the intentions of agents. However, most of this work has focused on scheduling the intentions of a single agent with no awareness and consideration of other agents that may be operating in the same environment. They schedule the intentions of the single-agent in order to maximise the total number of goals achieved. In this work, we investigate techniques for scheduling the intentions of an agent in a multiagent setting, where an agent is aware (or partially aware) of the intentions of other agents in the environment. We use a Monte Carlo Tree Search (MCTS) based approach and show that our intention-aware scheduler generates better outcomes in cooperative, neutral (selfish) and adversarial settings than the state-of-the-art schedulers that do not consider other agents' intentions.

Research on the use of software agents in P2P video streaming systems has recently emerged in order to meet the requirements such as time constraints, minimizing delay and efficient utilization of network resources. However parent selection and network awareness are not addressed properly in these leading studies. In order to fill this gap, we introduce the design and implementation of a Multi-agent System (MAS) for P2P video streaming in this paper. The construction of the MAS by applying a well-defined agent-oriented software engineering methodology is discussed. The internal structure of each agent in the proposed MAS is based on the well-known Belief-Desire-Intention (BDI) architecture. Experimental results show that the proposed MAS succeeds the related parent selection and promotes the system execution. BDI-based MAS design given in this paper can guide those researchers who aim to implement autonomous mesh-based P2P video streaming systems.

The research field of Agent-Oriented Software Engineering (AOSE) aims to find abstractions, languages, methodologies and toolkits for modeling, verifying, validating and prototyping complex applications conceptualized as Multiagent Systems (MASs). A very lively research sub-field studies how formal methods can be used for AOSE. This paper presents a detailed survey of six logic-based executable agent specification languages that have been chosen for their potential to be integrated in our ARPEGGIO project, an open framework for specifying and prototyping a MAS. The six languages are $\textsf{ConGolog}$, $\textsf{AGENT-0}$, the $\textsf{IMPACT}$ agent programming language, $\textsf{DyLOG}$, Concurrent $\textsf{METATEM}$ and ${\cal E}_{hhf}$. For each executable language, the logic foundations are described and an example of use is shown. A comparison of the six languages and a survey of similar approaches complete the paper, together with considerations of the advantages of using logic-based languages in MAS modeling and prototyping.

Although argumentation has been a prominent topic of research in artificial intelligence and in particular agent communication, there has been little work on practical (but provably sound) argumentation approaches integrated with agent programming languages. In this paper, we develop a formally-grounded mechanism for practical argumentation-based dialogues in an agent platform based on a multi-agent programming language. We formalise a protocol to govern such dialogues, where agents use an argumentation-based reasoning mechanism that has been implemented. We prove that dialogues following our protocol always terminate and that ideal solutions are reached under certain conditions. The protocol is simple but was shown to be useful in a multi-agent system application that supports teams of cooperating humans.

The belief-desire-intention (BDI) model is one of the most widely used for developing agents. One of its benefits is the flexibility of choosing among different plans to achieve a goal and, to leverage this benefit, a particular algorithm that makes this choice must be selected. Although many techniques have been proposed addressing the plan selection process -- as well as other aspects of BDI agents -- they require many customisations and adaptations to be used in particular applications, thus requiring expert knowledge to be adopted, which is a real barrier to the large-scale adoption of this kind of agent technology. We thus in this paper propose a model-driven approach that allows modelling agents based on an extended BDI model (inspired by the Tropos meta-model) and automatically generating source code that implements agents with the ability of selecting plans. As this plan selection process typically involves analysing plan side effects, e.g. cost of execution, in the context of current agent preferences, our approach uses a preference-based plan selection process over what we refer to as softgoals. This process relies on the multi-attribute utility theory, taking into account the uncertainty of plan outcomes. We evaluate our approach experimentally.

This report documents the programme and outcomes of Dagstuhl Seminar 12342 ``Engineering multiagent Systems''. The seminar brought together researchers from both academia and industry to identify the potential for and facilitate convergence towards standards for agent technology. As such it was particularly relevant to industrial research. A key objective of the seminar, moreover, has been to establish a road map for engineering multiagent systems. Various research areas have been identified as important topics for a research agenda with a focus on the development of multiagent systems. Among others, these include the integration of agent technology and legacy systems, component-based agent design, standards for tooling, establishing benchmarks for agent technology, and the development of frameworks for coordination and organisation of multiagent systems. This report presents a more detailed discussion of these and other research challenges that were identified. The unique atmosphere of Dagstuhl provided the perfect environment for leading researchers from a wide variety of backgrounds to discuss future directions in programming languages, tools and platforms for multiagent systems, and the road map produced by the seminar will have a timely and decisive impact on the future of this whole area of research.

The meaning of a communicative act in a multi-agent system can be characterised at a number of different levels. We argue that only one level of meaning is common across all applications: what we call the action-level semantics given by protocols or conversation policies. We define a general semantic framework for specifying the semantics of a class of Agent Communication Languages (ACLs) based on protocols. We then introduce sACL, a small ACL, and show how the action-level semantics of this language can be integrated with an intentional semantics. This enables us to specify the meaning of an individual communicative act in the context of the conversation in which it occurs, and to customise sACL for different application domains. We describe a development method for defining an ACL for a particular application, and give a reference architecture for the method using the Beliefs-Desires-Intentions (BDI) agent architecture.