2APL: a practical agent programming language

This article presents a BDI-based agent-oriented programming language, called 2APL (A Practical Agent Programming Language). This programming language facilitates the implementation of multi-agent systems consisting of individual agents that may share and access external environments. It realizes an effective integration of declarative and imperative style programming by introducing and integrating declarative beliefs and goals with events and plans. It also provides practical programming constructs to allow the generation, repair, and (different modes of) execution of plans based on beliefs, goals, and events. The formal syntax and semantics of the programming language are given and its relation with existing BDI-based agent-oriented programming languages is discussed.     

Model checking rational agents

Agent-oriented programming techniques seem appropriate for developing systems that operate in complex, dynamic, and unpredictable environments. We aim to address this requirement by developing model-checking techniques for the (automatic or semiautomatic) verification of rational-agent systems written in a logic-based agent-oriented programming language. Typically, developers apply model-checking techniques to abstract models of a system rather than the system implementation. Although this is important for detecting design errors at an early stage, developers might still introduce errors during coding. In contrast, developers can directly apply our model-checking techniques to systems implemented in an agent-oriented programming language, automatically verifying agent systems without the usual gap between design and implementation. We developed our techniques for AgentSpeak, a rational-agent programming language based on the AgentSpeak (L) abstract agent-oriented programming language. AgentSpeak shares many features of the agent-oriented programming paradigm. Similarly, we've developed techniques for automatically translating AgentSpeak programs into the model specification language of existing model-checking systems. In this way, we reduce the problem of verifying that an AgentSpeak system has certain BDI logic properties to a conventional LTL model-checking problem.     

Toward a programming theory for rational agents

An important problem in agent verification is a lack of proper understanding of the relation between agent programs on the one hand and agent logics on the other. Understanding this relation would help to establish that an agent programming language is both conceptually well-founded and well-behaved, as well as yield a way to reason about agent programs by means of agent logics. As a step toward bridging this gap, we study several issues that need to be resolved in order to establish a precise mathematical relation between a modal agent logic and an agent programming language specified by means of an operational semantics. In this paper, we present an agent programming theory that provides both an agent programming language as well as a corresponding agent verification logic to verify agent programs. The theory is developed in stages to show, first, how a modal semantics can be grounded in a state-based semantics, and, second, how denotational semantics can be used to define the mathematical relation connecting the logic and agent programming language. Additionally, it is shown how to integrate declarative goals and add precompiled plans to the programming theory. In particular, we discuss the use of the concept of higher-order goals in our theory. Other issues such as a complete axiomatization and the complexity of decision procedures for the verification logic are not the focus of this paper and remain for future investigation. Part of this research was carried out while the first author was affiliated with the Nijmegen Institute for Cognition and Information, Radboud University Nijmegen.     

Declarative planning in procedural agent architectures

Practical agent languages and their corresponding architectures have often relied on a static plan library with more or less direct trigger-response activation mechanisms as a source for agent behaviours for the sake of runtime efficiency. Although efficient, such a language design choice severely limits an agent’s ability to reason about its goals and adapt to unforeseen circumstances after being deployed. This effectively delegates the task of planning to the designers themselves, who must design plan libraries able to cope with every foreseeable situation an agent might find itself in by designing plans to deal with any contingency. In this paper we develop a formal conversion process from traditional BDI agent languages into declarative planning. Using this conversion process, we show how to integrate domain independent planning algorithms into the BDI interpreter, allowing a designer to program an agent not only through the trigger-response mechanism used in traditional languages, but also in terms of declarative goals. Our contribution here is twofold: firstly we increase an agent’s ability to cope with unforeseen situations and secondly we unburden an agent designer from having to define multiple plan combinations that could be easily generated by a planner.     

Intentional learning agent architecture

Dealing with changing situations is a major issue in building agent systems. When the time is limited, knowledge is unreliable, and resources are scarce, the issue becomes more challenging. The BDI (Belief-Desire-Intention) agent architecture provides a model for building agents that addresses that issue. The model can be used to build intentional agents that are able to reason based on explicit mental attitudes, while behaving reactively in changing circumstances. However, despite the reactive and deliberative features, a classical BDI agent is not capable of learning. Plans as recipes that guide the activities of the agent are assumed to be static. In this paper, an architecture for an intentional learning agent is presented. The architecture is an extension of the BDI architecture in which the learning process is explicitly described as plans. Learning plans are meta-level plans which allow the agent to introspectively monitor its mental states and update other plans at run time. In order to acquire the intricate structure of a plan, a process pattern called manipulative abduction is encoded as a learning plan. This work advances the state of the art by combining the strengths of learning and BDI agent frameworks in a rich language for describing deliberation processes and reactive execution. It enables domain experts to specify learning processes and strategies explicitly, while allowing the agent to benefit from procedural domain knowledge expressed in plans.     

Extending BDI plan selection to incorporate learning from experience

An important drawback to the popular Belief, Desire, and Intentions (BDI) paradigm is that such systems include no element of learning from experience. We describe a novel BDI execution framework that models context conditions as decision trees, rather than boolean formulae, allowing agents to learn the probability of success for plans based on experience. By using a probabilistic plan selection function, the agents can balance exploration and exploitation of their plans. We extend earlier work to include both parameterised goals and recursion and modify our previous approach to decision tree confidence to include large and even non-finite domains that arise from such consideration. Our evaluation on a pre-existing program that relies heavily on recursion and parametrised goals confirms previous results that naive learning fails in some circumstances, and demonstrates that the improved approach learns relatively well.     

Goals in conflict: semantic foundations of goals in agent programming

This paper addresses the notion of (declarative) goals as used in agent programming. Goals describe desirable states, and semantics of these goals in an agent programming context can be defined in various ways. We focus in this paper on the representation of conflicting goals. In particular, we define two semantics for goals, one for unconditional goals and one for conditional goals. The first is based on propositional logic, and the latter is based on default logic. We establish relations between and properties of these semantics. This title was inspired by the title of the PhD thesis of Harrenstein: Logic in conflict: logical explorations in strategic equilibrium [25].     

Aborting,suspending, and resuming goals and plans in BDI agents

Intelligent agents designed to work in complex, dynamic environments such as e-commerce must respond robustly and flexibly to environmental and circumstantial changes, including the actions of other agents. An agent must have the capability to deliberate about appropriate courses of action, which may include reprioritising tasks—whether goals or associated plans—aborting or suspending tasks, or scheduling tasks in a particular order. In this article we study mechanisms to enable principled suspend, resuming, and aborting of goals and plans within a Belief-Desire-Intention (BDI) agent architecture. We give a formal and combined operational semantics for these actions in an abstract agent language (CAN), thus providing a general mechanism that can be incorporated into several BDI-based agent platforms. The abilities enabled by our semantics provides an agent designer greater flexibility to direct agent operation, offering a generic means to manage the status of goals. We demonstrate the reasoning abilities enabled on a document workflow scenario.     

Planning Intelligent Responses in a Natural Language System

Intelligent help systems cannot merely respond passively to the user'scommands and queries. They need to be able to volunteer information,correct user misconceptions, and reject unethical requests when appropriate.In order to do these things, a system must be designed as an intelligentagent. That is, a system needs to have its own goals and then plan forthese goals. A system which did not have its own goals would never refuseto help users perform unethical actions.Such an intelligent agent has been implemented in the UCEgo component of UC(Wilensky et al. 1984; Wilensky et al. 1988) (UNIX Consultant), a natural languagesystem that helps the user solve problems in using the UNIX operatingsystem. UCEgo provides UC with its own goals and plans. By adoptingdifferent goals in different situations, UCEgo creates and executesdifferent plans, enabling it to interact appropriately with the user.UCEgo adopts goals when it notices that the user either lacks necessaryknowledge, or has incorrect beliefs. In these cases, UCEgo plans tovolunteer information or correct the user's misconception as appropriate.These plans are pre-stored skeletal plans that are indexed under the types ofsituations in which they are typically useful. Plan suggestion situationsinclude the goal which the plan is used to achieve, the preconditions of theplan, and appropriateness conditions for the plan. Indexing plans bysituations improves efficiency and allows UC to respond appropriately to theuser in real time.Detecting situations in which a plan should be suggested or a goal adoptedis implemented using if-detected daemons. These daemons provide asingle mechanism which can be used both for detecting goals and suggestingplans. Different methodologies for the efficient implementation ofif-detected daemons are discussed.     

Automatic generation of communication and teamwork within multi-agent teams

Teamwork and communication are two important processes within multi-agent systems designed to act in a coherent and coordinated manner. Modeling teamwork involves interleaving steps within shared plans that will allow agents to work together towards common goals. These steps involve reasoning about roles, responsibilities, and joint-intentions in order to coordinate activity amongst individuals. Communication facilitates teamwork. There are various complex forms of communication such as synchronization, coordination, and cooperation that allow for members of teams to use teamwork to their advantage. Explicitly defining every possible communication point within a team plan is too cumbersome and inflexible. In this paper, we describe a method to automatically decompose a team plan into a collection of individual agent plans, inserting all of the necessary communication points needed to properly generate coordinated behavior. This approach could be used to more accurately and easily model teamwork in multi-agent systems.     

A Resource Logic for Multi-Agent Plan Merging

In a multi-agent system, agents are carrying out certain tasks by executing plans. Consequently, the problem of finding a plan, given a certain goal, has been given a lot of attention in the literature. Instead of concentrating on this problem, the focus of this paper is on cooperation between agents which already have constructed plans for their goals. By cooperating, agents might reduce the number of actions they have to perform in order to fulfill their goals. The key idea is that in carrying out a plan an agent possibly produces side products that can be used as resources by other agents. As a result, an other agent can discard some of its planned actions. This process of exchanging products, called plan merging, results in distributed plans in which agents become dependent on each other, but are able to attain their goals more efficiently. In order to model this kind of cooperation, a new formalism is developed in which side products are modeled explicitly. The formalism is a resource logic based on the notions of resource, skill, goal, and service. Starting with some resources, an agent can perform a number of skills in order to produce other resources which suffice to achieve some given goals. Here, a skill is an elementary production process taking as inputs resources satisfying certain constraints. A service is a serial or parallel composition of skills acting as a program. An operational semantics is developed for these services as programs. Using this formalism, an algorithm for plan merging is developed, which is anytime and runs in polynomial time. Furthermore, a variant of this algorithm is proposed that handles the exchange of resources in a more flexible way. The ideas in the paper will be illustrated by an example from public transportation.     

Reputation-based decisions for logic-based cognitive agents

Computational trust and reputation models have been recognized as one of the key technologies required to design and implement agent systems. These models manage and aggregate the information needed by agents to efficiently perform partner selection in uncertain situations. For simple applications, a game theoretical approach similar to that used in most models can suffice. However, if we want to undertake problems found in socially complex virtual societies, we need more sophisticated trust and reputation systems. In this context, reputation-based decisions that agents make take on special relevance and can be as important as the reputation model itself. In this paper, we propose a possible integration of a cognitive reputation model, Repage, into a cognitive BDI agent. First, we specify a belief logic capable to capture the semantics of Repage information, which encodes probabilities. This logic is defined by means of a two first-order languages hierarchy, allowing the specification of axioms as first-order theories. The belief logic integrates the information coming from Repage in terms if image and reputation, and combines them, defining a typology of agents depending of such combination. We use this logic to build a complete graded BDI model specified as a multi-context system where beliefs, desires, intentions and plans interact among each other to perform a BDI reasoning. We conclude the paper with an example and a related work section that compares our approach with current state-of-the-art models.     

Data structures for order-sensitive predicates in parallel nondeterministic systems

We study the problem of guaranteeing correct execution semantics in parallel implementations of logic programming languages in presence of built-in constructs that are sensitive to order of execution. The declarative semantics of logic programming languages permit execution of various goals in any arbitrary order (including in parallel). However, goals corresponding to extra-logical built-in constructs should respect the sequential order of execution to ensure correct semantics. Ensuring this correctness in presence of such built-in constructs, while efficiently exploiting maximum parallelism, is a difficult problem. In this paper, we propose a formalization of this problem in terms of operations on dynamic trees. This abstraction enables us to: (i) show that existing schemes to handle order-sensitive computations used in current parallel systems are sub-optimal; (ii) develop a novel, optimal scheme to handle order-sensitive goals that requires only a constant time overhead per operation. While we present our results in the context of logic programming, they will apply equally well to most parallel non-deterministic systems. Received: 20 April 1998 / 3 April 2000     

Formalisations of Capabilities for BDI-Agents

Intentional agent systems are increasingly being used in a wide range of complex applications. Capabilities has recently been introduced into some of these systems as a software engineering mechanism to support modularity and reusability while still allowing meta-level reasoning. This paper presents possible formalisations of capabilities within the framework of beliefs, goals and intentions and indicates how capabilities can affect agent reasoning about its intentions. We define a style of agent commitment which we refer to as a self-aware agent which allows an agent to modify its goals and intentions as its capabilities change. We also indicate which aspects of the specification of a BDI interpreter are affected by the introduction of capabilities and give some indications of additional reasoning which could be incorporated into an agent system on the basis of both the theoretical analysis and the existing implementation.     

An Automated Teamwork Infrastructure for Heterogeneous Software Agents and Humans

Agent integration architectures enable a heterogeneous, distributed set of agents to work together to address problems of greater complexity than those addressed by the individual agents themselves. Unfortunately, integrating software agents and humans to perform real-world tasks in a large-scale system remains difficult, especially due to three main challenges: ensuring robust execution in the face of a dynamic environment, providing abstract task specifications without all the low-level coordination details, and finding appropriate agents for inclusion in the overall system. To address these challenges, our Teamcore project provides the integration architecture with general-purpose teamwork coordination capabilities. We make each agent team-ready by providing it with a proxy capable of general teamwork reasoning. Thus, a key novelty and strength of our framework is that powerful teamwork capabilities are built into its foundations by providing the proxies themselves with a teamwork model.Given this teamwork model, the Teamcore proxies addresses the first agent integration challenge, robust execution, by automatically generating the required coordination actions for the agents they represent. We can also exploit the proxies' reusable general teamwork knowledge to address the second agent integration challenge. Through team-oriented programming, a developer specifies a hierarchical organization and its goals and plans, abstracting away from coordination details. Finally, KARMA, our Knowledgeable Agent Resources Manager Assistant, can aid the developer in conquering the third agent integration challenge by locating agents that match the specified organization's requirements. Our integration architecture enables teamwork among agents with no coordination capabilities, and it establishes and automates consistent teamwork among agents with some coordination capabilities. Thus, team-oriented programming provides a level of abstraction that can be used on top of previous approaches to agent-oriented programming. We illustrate how the Teamcore architecture successfully addressed the challenges of agent integration in two application domains: simulated rehearsal of a military evacuation mission and facilitation of human collaboration.     

软件Agent的继承性研究

Agent作为一种受限的智能对象,对Agent的继承特性进行深入研究并将继承机制嵌入到AOP(agent-oriented programming)中则具有重要意义.文章基于BDI Agent模型,对软件Agent的继承性和复制行为进行了研究.从单继承和多继承两个方面给出了Agent继承的语义,将Agent实例的动态复制机制形式地划分为功能分割、逻辑分割、择优分割和返祖分割这4类,分析了每类分割方式的作用,并基于电子市场系统应用背景给出了相应的实例.     

A BDI agent system for the cow herding domain

We describe the current state of our multi-agent system for agents playing games in grid-like domains. The framework follows the BDI model of agency and is used as the main project for a seminar course on agent-oriented programming and design. When it comes to design, the Prometheus methodology has been used by relying on the Prometheus design tool (PDT) that supports the methodology. In terms of programming language, we have used the JACK agent platform. We believe the domains developed as part of the Multi-Agent Programming Contest are the right type of settings for evaluating our research, in that it provides enough complexity to explore various aspects of multi-agent development while being sufficiently bounded to make the development effort worthwhile.     

浅谈用BDI模型开发智能NPC游戏角色

现代计算机游戏是一个非常复杂的软件系统,已经越来越多地运用AI技术来更好的满足玩家的需求.虽然BDI模型越来越受到人们的关注,但是BDI模型并没有广泛地应用在游戏的开发上.针对这方面的矛盾,出现了面向Agent的方法.通过一个游戏演示了它的可能性,该演示表明这种面向Agent的方法可以有效地解决这对矛盾.