The “Snake-In-The-Box” problem is a hard combinatorial search problem, first described more than 50 years ago, which consists in finding longest induced paths in hypercube graphs. Solutions to the problem have diverse and some quite surprising practical applications, but optimal solutions are known only for problems of small dimension, as the search space grows super-exponentially in the hypercube dimension. Incomplete search algorithms based on Evolutionary Computation techniques have been considered the state-of-the-art for finding near-optimal solutions, and have until recently held most significant records. This study presents the latest results of a new technique, based on Monte-Carlo search, which finds significantly improved solutions compared to prior techniques, is considerably faster, and, unlike EC techniques, requires no tuning.

Agents situated in dynamic environments can be supplied in advance with a repertoire of plans that permit them to rapidly generate appropriate sequences of actions in response to important events. When agents can form teams, new problems emerge regarding the representation and execution of joint actions. In this paper we introduce a language for representing joint plans for teams of agents, we describe how agents can organize the formation of a suitably skilled team to achieve a joint goal, and we explain how such a team can execute these plans to generate complex, synchronized team activity. The formalism provides a framework for representing and reasoning about joint actions in which various approaches to co-ordination and commitment can be explored.

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 technologies are now being applied to the development of large-scale commercial and industrial software systems. Such systems are complex, involving hundreds, perhaps thousands of agents, and there is a pressing need for system modelling techniques that permit their complexity to be effectively managed, and principled methodologies to guide the process of system design. Without adequate techniques to support the design process, such systems will not be sufficiently reliable, maintainable or extensible, will be difficult to comprehend, and their elements will not be re-usable. In this paper, we present techniques for modelling agents and multi-agent systems which adapt and extend existing Object-Oriented representation techniques, and a methodology which provides a clear conceptual framework to guide system design and specification. We have developed these techniques for systems of agents based upon a particular Belief-Desire-Intention architecture, but have sought to provide a framework for the description of agent systems that is sufficiently general to be applicable to other agent architectures, and which may be extended in various ways.

Algebraic specification techniques can be applied to many aspects of software agents and multi-agent systems. This paper presents an algebraic framework, the Ψ- calculus, suitable for specifying the computations of complex agents that have a sense–compute–act computation cycle and that employ stored plan execution as the basis of behaviour generation. The framework provides a complete operational semantics of a plan-based programming language for such agents, covering all aspects of computation from the execution of basic plan steps through to the top-level control cycle which determines how external interactions occur. The semantics is specified compactly in process algebraic style by a hierarchy of rewrite rules, and has safety, guarantee and compositionality properties that facilitate reasoning about agent program behaviour.

The construction of large-scale embedded software systems demands the use of design methodologies and modelling techniques that support abstraction, inheritance, modularity, and other mechanisms for reducing complexity and preventing error. If multi-agent systems are to become widely accepted as a basis for large-scale applications, adequate agent-oriented methodologies and modelling techniques will be essential. This is not just to ensure that systems are reliable, maintainable, and conformant, but to allow their design, implementation, and maintenance to be carried out by software analysts and engineers rather than researchers. In this paper we describe an agent-oriented methodology and modelling technique for systems of agents based upon the Belief-Desire-Intention (BDI) paradigm. Our models extend existing Object-Oriented (OO) models. By building upon and adapting existing, well-understood techniques, we take advantage of their maturity to produce an approach that can be easily learnt and understood by those familiar with the OO paradigm.

The Procedural Reasoning System (PRS) is the best established agent architecture currently available. It has been deployed in many major industrial applications, ranging from fault diagnosis on the space shuttle to air traffic management and business process control. The theory of PRS-like systems has also been widely studied: within the intelligent agents research community, the belief-desire-intention (BDI) model of practical reasoning that underpins PRS is arguably the dominant force in the theoretical foundations of rational agency. Despite the interest in PRS and BDI agents, no complete attempt has yet been made to precisely specify the behaviour of real PRS systems. This has led to the development of a range of systems that claim to conform to the PRS model, but which differ from it in many important respects. Our aim in this paper is to rectify this omission. We provide an abstract formal model of an idealised dMARS system (the most recent implementation of the PRS architecture), which precisely defines the key data structures present within the architecture and the operations that manipulate these structures. We focus in particular on dMARS plans, since these are the key tool for programming dMARS agents. The specification we present will enable other implementations of PRS to be easily developed, and will serve as a benchmark against which future architectural enhancements can be evaluated.

Multi-Agent Systems technologies are migrating from research labs to software engineering centres. If these technologies are to realize their potential, it will become increasingly important to develop and employ methodologies, accessible to software engineers, for specifying, analysing, designing, and verifying multi-agent systems. The panelists, who represented a broad range of approaches and experience in MAS theory and practice, addressed the following questions.

This paper examines Active Databases and Agent Systems, comparing their purpose, structure, functionality, and implementation. Our presentation is aimed primarily at an audience familiar with active database technology. We show that they draw upon very similar paradigms in their quest to supply reactivity. This presents opportunities for migration of techniques and formalisms between the two fields.

The Procedural Reasoning System (PRS) is the best established agent architecture currently available. It has been deployed in many major industrial applications, ranging from fault diagnosis on the space shuttle to air traffic management and business process control. The theory of PRS-like systems has also been widely studied: within the intelligent agents research community, the belief-desire-intention (BDI) model of practical reasoning that underpins PRS is arguably the dominant force in the theoretical foundations of rational agency. Despite the interest in PRS and BDI agents, no complete attempt has yet been made to precisely specify the behaviour of real PRS systems. This has led to the development of a range of systems that claim to conform to the PRS model, but which differ from it in many important respects. Our aim in this paper is to rectify this omission. We provide an abstract formal model of an idealised dMARS system (the most recent implementation of the PRS architecture), which precisely defines the key data structures present within the architecture and the operations that manipulate these structures. We focus in particular on dMARS plans, since these are the key tool for programming dMARS agents. The specification we present will enable other implementations of PRS to be easily developed, and will serve as a benchmark against which future architectural enhancements can be evaluated.

Agentis is a framework for the implementation of commercial, interactive, process-driven application systems, and is based upon an underlying agent technology (presently dMARS) that provides core agent functionality. These systems are intended to be programmed by the business process owner - application functionality is defined by a set of procedure and data definitions in an abstract process description language called GEM, and the framework is designed to allow these specifications to be easily modified and extended by their owner after the system has been implemented and commissioned. The tool set that supports the specification process has an industry-standard look-and-feel and is designed to be intuitive to non-technical users such as business analysts. Its use is supported by a methodology that guides specification refinement, helping to take agent-oriented programming out of the research lab and into the world of commerce and industry. The Agentis framework provides structure and functionality not provided by the underlying dMARS system. Key conceptual components are an agent model that defines standard agent types, and an agent interaction model based on explicit notions of services and tasks, a strictly typed agent communication language, a set of protocols that provide reliable, concurrent provision of services and tasks, and conventions for structuring agents into a hierarchy and controlling their activity. Concrete components are built-in agents that provide services for system management and monitoring, and standard interfaces that facilitate the integration of the Agentis system with other system components such as middleware, databases, user interfaces, web browsers and servers, and legacy systems. In a companion paper to this one, we have described and formally specified the interaction protocols that are a key element of the interaction model [3]. In this paper we motivate and present the design of the Agentis interaction model and describe its functionality.

It is well recognized that Agent Communication Languages (ACL's) are a critical element of Multi-Agent Systems and a key to their successful application in commerce and industry. The field of protocol engineering, which addresses the problems of specifying and verifying machine communication languages and testing implementations, has developed powerful theoretical and automated techniques for doing this, and more importantly, a mature understanding of the requirements that communication language and protocol specifications should meet. Unfortunately, those developing and promulgating ACL's appear not to have taken advantage of this body of knowledge. An examination of the current ACL specifications being developed by the Foundation for Intelligent Physical Agents (FIPA) reveals a confusing amalgam of different formal and informal specification techniques whose net result is ambiguous, inconsistent and certainly under-specified. Allowances must be made, as these are draft specifications, but rather than providing a verified foundation for reliable communication between heterogeneous agents, they seem likely to lead to a host of unreliable and incompatible implementations, or to be ignored in favour of more pragmatic and robust approaches. In this paper, we propose a set of requirements against which an ACL specification can be judged, briefly explore some of the shortcomings of the FIPA ACL and their origins, and contrast it with a small ACL which was designed with reliability and ease of verification as prime objectives.

individual motivation such as obligations and norms may be present. This leads us to propose an extended BDI architecture in which obligations, norms and desires are distinguished from goals and explicitly represented. In this paper we consider suitable logical representations for and properties of these elements, and describe the basic method of operation of the architecture, focusing on how goal generation and goal maintenance may occur.

A strength of agent architectures such as PRS and dMARS, which are based on stored plan execution, is that their plan languages offer an easily understood, visual representation of behaviour that permits their underlying architectural complexity to be partially abstracted and effectively exploited. Unlike visual representations of behaviour used in methodologies such as UML for programming in Object Oriented languages such as \textsfJava, plan graphs constitute a direct, executable specification of agent behaviour rather than a model which guides implementation refinement. Previously, such languages have lacked a formal semantic basis. This paper presents key elements of a new visual programming language ViP which has a complete and exact semantics based upon a recently described agent process algebra -- the &PSgr; calculus.

Traditional models of agents based on Beliefs, Desires and Intentions usually only include either desires or goals. Therefore the process whereby goals arise from desires is given scant attention. In this paper we argue that the inclusion of both desires and goals in the same model can be important, particularly in a Multi-Agent System context, where other sources of individual motivation such as obligations and norms may be present. This leads us to propose an extended BDI architecture in which obligations, norms and desires are distinguished from goals and explicitly represented. In this paper we consider suitable logical representations for and properties of these elements, and describe the basic method of operation of the architecture, focusing on how goal generation and goal maintenance may occur.

Many papers about agents mention BDI as a reference logical model for agents, but this model does not offer a thorough formal account of the connections between the different modalities of Beliefs, Desires and Intentions. Of course, work such as that of Rao and Georgeff [14] and of Cohen and Levesque [5] has pointed to some specific constraints, but does not offer a complete logical theory that explains all possible connections between, e.g., goals and intentions. Another point of concern often voiced is the long-standing gap between the BDI logical model and practical agent implementations. Judged by its applicability, it might seem that the BDI model is becoming less important, due to the looseness of its connection to practical systems, and because of its failure to guide research into implementation directions in any obviously useful way.

Ψ is a novel algebraic language for the specification of agents, such as BDI agents, which employ a sense-compute-act computation cycle and stored plan execution as the basis of agent behaviour. It generalizes and extends agent architectures such as PRS and dMARS in several ways, and possesses a complete operational semantics covering all aspects of agent computation from intention step execution to the top-level control cycle. This is specified uniformly in process algebraic style by rewrite rules, and has certain safety, guarantee and compositionality properties which facilitate reasoning about agent program behaviour.

Agent programming languages based on a sense-compute-act cycle and stored plan execution, such as PRS and dMARS, lack any formal semantics; this and the actual computational models which they employ can make it difficult or impossible to reason about agent behaviour. In this paper we present the Ψ calculus, a novel algebraic language which generalizes and extends these languages and remedies several of their shortcomings. Ψ has a complete operational semantics covering all aspects of agent computation from intention step execution to the top-level control cycle, specified uniformly in process algebraic style, and has certain desirable safety, guarantee and compositionality properties which facilitate reasoning about agent program behaviour.

This article presents Gaia: a methodology for agent-oriented analysis and design. The Gaia methodology is both general, in that it is applicable to a wide range of multi-agent systems, and comprehensive, in that it deals with both the macro-level (societal) and the micro-level (agent) aspects of systems. Gaia is founded on the view of a multi-agent system as a computational organisation consisting of various interacting roles. We illustrate Gaia through a case study (an agent-based business process management system).