John Thangarajah

Detecting & exploiting positive goal interaction in intelligent agents

Rational agents typically pursue multiple goals in parallel. However most existing agent systems do not have any infrastructure support for reasoning about either positive or negative interactions between goals. Negative interactions include such things as competition for resources, which if unrecognised can lead to unnecessary failure of both goals requiring the resource. Positive interactions include situations where there is potentially a common subgoal of two goals. This paper looks at mechanisms for identifying potential common subgoals, and attempting to schedule the actions of the agent to take advantage of this. Potential common subgoals are identified by maintaining summaries of definite and potential effects of goals and plans to achieve those goals. Template summaries for goal types are produced at compile time, while instance summaries are maintained and updated at execution time to allow the agent to choose and schedule its plans to take advantage of potential commonality where possible. This increases the ability of the agent to act in a rational manner, where rational is loosely defined as the sensible behaviour exhibited by humans.

Representation and reasoning for goals in BDI agents

A number of agent-oriented programming systems are based on a framework of beliefs, desires and intentions (BDI) and more explicitly on the BDI logic of Rao and Georgeff. In this logic, goals are a consistent set of desires, and this property is fundamental to the semantics of the logic. However, implementations based on this framework typically have no explicit representation of either desires or goals, and consequently no mechanisms for checking consistency. In this paper we address this gap between theory and practice by giving an explicit representation for a simple class of desires. The simplicity of this class makes it both straightforward and efficient to check for consistency. We provide a general framework for conflict resolution based on a preference ordering of sets of goals, and we illustrate how different rules for specifying consistent goal sets (corresponding to different preference orderings) relate to existing commitment strategies. We also report on some implementation experiments which confirm that the cost of consistency maintenance is not significant.

On proactivity and maintenance goals

Goals are an important concept in intelligent agent systems, and can take a variety of forms. One such form is maintenance goals, which, unlike achievement goals, define states that must remain true, rather than a state that is to be achieved. Maintenance goals are generally restricted to acting as trigger conditions for goals or plans, and often take no part in any deliberation process. These goals are reactive and are only acted upon when the maintenance conditions are no longer true. In this paper, we study maintenance goals that are proactive, in that the agent system needs to not only react when the maintenance conditions fail, but also anticipate the failures of these conditions, and act in order to avoid them failing. This can be done by performing actions that prevent the condition from failing, or suspending goals that will cause the maintenance conditions to fail. We provide a representation for maintenance goals that captures both their reactive and proactive aspects, algorithms that identify in advance where maintenance conditions may not hold, and mechanisms for enabling preventative actions in such situations. We also provide some experimental results on an implementation of these ideas.

Model-Based Test Oracle Generation for Automated Unit Testing of Agent Systems

Software testing remains the most widely used approach to verification in industry today, consuming between 30-50 percent of the entire development cost. Test input selection for intelligent agents presents a problem due to the very fact that the agents are intended to operate robustly under conditions which developers did not consider and would therefore be unlikely to test. Using methods to automatically generate and execute tests is one way to provide coverage of many conditions without significantly increasing cost. However, one problem using automatic generation and execution of tests is the oracle problem: How can we automatically decide if observed program behavior is correct with respect to its specification? In this paper, we present a model-based oracle generation method for unit testing belief-desire-intention agents. We develop a fault model based on the features of the core units to capture the types of faults that may be encountered and define how to automatically generate a partial, passive oracle from the agent design models. We evaluate both the fault model and the oracle generation by testing 14 agent systems. Over 400 issues were raised, and these were analyzed to ascertain whether they represented genuine faults or were false positives. We found that over 70 percent of issues raised were indicative of problems in either the design or the code. Of the 19 checks performed by our oracle, faults were found by all but 5 of these checks. We also found that 8 out the 11 fault types identified in our fault model exhibited at least one fault. The evaluation indicates that the fault model is a productive conceptualization of the problems to be expected in agent unit testing and that the oracle is able to find a substantial number of such faults with relatively small overhead in terms of false positives.

Using three AOSE toolkits to develop a sample design

At the 8th Agent-Oriented Software Engineering Workshop, the developers of tools supporting three popular agent-oriented methodologies (Tropos, Prometheus and Organization-based Multiagent Systems Engineering (O-MaSE)) demonstrated their tools using a common multi-agent system design case study: the Conference Management System. The methodologies are representative of the state-of-the-art in agent-oriented software methodologies, as they are some of the earliest and most mature agent-oriented methodologies currently available. The paper briefly summarises the three methodologies and their associated tools and then works through the analysis, architectural design and detailed design phases of the Conference Management system case study using each methodology and tool. The paper compares the models and concepts used during each phase and provides a discussion on the similarities and differences between them.

Aborting tasks in BDI agents

Intelligent agents that are intended to work in dynamic environments must be able to gracefully handle unsuccessful tasks and plans. In addition, such agents should be able to make rational decisions about an appropriate course of action, which may include aborting a task or plan, either as a result of the agents own deliberations, or potentially at the request of another agent. In this paper we investigate the incorporation of aborts into a BDI-style architecture. We discuss some conditions under which aborting a task or plan is appropriate, and how to determine the consequences of such a decision. We augment each plan with an optional abort-method, analogous to the failure method found in some agent programming languages. We provide an operational semantics for the execution cycle in the presence of aborts in the abstract agent language CAN, which enables us to specify a BDI-based execution model without limiting our attention to a particular agent system (such as JACK, Jadex, Jason, or SPARK). A key technical challenge we address is the presence of parallel execution threads and of sub-tasks, which require the agent to ensure that the abort methods for each plan are carried out in an appropriate sequence.

Designing institutional multi-agent systems

The vision of agents working together on the Internet, in virtual organizations, is one that is increasingly common. However, one of the issues is the regulation of the participating agents and their behaviour. A substantial body of work exists that investigates agent societies and agent organizations, including work on electronic institutions, such as Islander and Ameli. However, although such work provides concrete tools for specifying and enacting institutions, there is a lack of clear documented guidance to designers who are using these tools. In this paper we describe a methodology for developing an institutional structure for multi agent systems. This methodology captures the knowledge and experience within the Islander group, and integrates it with the Prometheus methodology.

Open agent systems

E-institutions are envisioned as facilities on the Internet for heterogeneous software agents to perform their interactions and thus forming truly open agent systems. We investigate how these heterogeneous agents can determine whether an institution is one in which they can participate. We propose a layered approach which is supported through a (traditional) middle agent that is part of the environment. Starting with a basic compatibility of message types, each extra layer ensures a higher degree of compatibility, but requires also extra sophistication in both the information required and the matching algorithms. In this paper, we describe reasoning about how an agent should take on a specific role, message matching, and protocol compatibility. We explore the issues in the context of an actual accommodation agent built in JACK, and a travel agency institution built in ISLANDER.

AUML protocols and code generation in the Prometheus design tool

Prometheus is an agent-oriented software engineering methodology. The Prometheus Design Tool (PDT) is a software tool that supports a designer who is using the Prometheus methodology. PDT has recently been extended with two significant new features: support for Agent UML interaction protocols, and code generation.

Computationally Effective Reasoning About Goal Interactions

It is important that intelligent agents are able to pursue multiple goals in parallel, in a rational manner. In this work we have described the careful empirical evaluation of the value of data structures and algorithms developed for reasoning about both positive and negative goal interactions. These mechanisms are incorporated into a commercial agent platform and then evaluated in comparison to the platform without these additions. We describe the data structures and algorithms developed, and the X-JACK system, which incorporates these into JACK, a state of the art agent development toolkit. There are three basic kinds of reasoning that are developed: reasoning about resource conflicts, reasoning to avoid negative interactions that can happen when steps of parallel goals are arbitrarily interleaved, and reasoning to take advantage of situations where a single step can help to achieve multiple goals. X-JACK is experimentally compared to JACK, under a range of situations designed to stress test the reasoning algorithms, as well as situations designed to be more similar to real applications. We found that the cost of the additional reasoning is small, even with large numbers of goal interactions to reason about. The benefit however is noticeable, and is statistically significant, even when the amount of goal interactions is relatively small.