An important concept for intelligent agent systems is goals. Goals have two aspects: declarative (a description of the state sought), and procedural (a set of plans for achieving the goal). A declarative view of goals is necessary in order to reason about important properties of goals, while a procedural view of goals is necessary to ensure that goals can be achieved efficiently in dynamic environments. In this paper we propose a framework for goals which integrates both views. We discuss the requisite properties of goals and the link between the declarative and procedural aspects, then derive a formal semantics which has these properties. We present a high-level plan notation with goals and give its formal semantics.

This paper introduces a formally specified design of a compositional generic agent model (GAM). This agent model abstracts from specific application domains; it provides a unified formal definition of a model for weak agenthood. It can be (re)used as a template or pattern for a large variety of agent types and application domain types. The model was designed on the basis of experiences in a number of application domains. The compositional development method DESIRE was used to design the agent model GAM at a conceptual and logical level. It serves as a unified, precisely defined coneptual structure which can be refined by specialisation and instantiation to a large variety of other, more specific agents. To illustrate reuse of this agent model, specialisation and instantiation to model co-operative information gathering agents is described in depth. Moreover, it is shown how GAM can be used to describe in a unified and hence more comparable manner a large number of agent architectures from the literature.

Agent-based systems are increasingly being applied in a wide range of areas including telecommunications, business process modelling, computer games, control of mobile robots and military simulations. Such systems are typically extremely complex and it is often useful to be able to simulate an agent-based system to learn more about its behaviour or investigate the implications of alternative architectures. In this paper, we discuss the application of distributed discrete-event simulation techniques to the simulation of multi-agent systems. We identify the efficient distribution of the agents' environment as a key problem in the simulation of agent-based systems, and present an approach to the decomposition of the environment which facilitates load balancing.

Agent systems must have a strong foundation; one approach that has been successfully applied to other kinds of software is patterns. This paper presents a collection of patterns for agents. 2. MOTIVATION Almost all agent development to date has been "home grown" [4] and done from scratch, independently, by each development team. This has led to the following problems: . Lack of an agreed definition: Agents built by different teams have different capabilities. . Duplication of effort: There has been little reuse of agent architectures, designs, or components. . Inability to satisfy industrial strength requirements: Agents must integrate with existing software and computer infrastructure. They must also address security and scaling concerns. Agents are complex and ambitious software systems that will be entrusted with critical applications. As such, agent based systems must be engineered with valid software engineering principles and not constructed in an ad hoc fashion. Agent system...

Debugging multi-agent systems (which are concurrent, distributed, and consist of complex components) is difficult, yet crucial. We propose that the debugging process can be improved by following an agent-oriented design methodology, and then using the design artifacts in the debugging phase. We present an example of this scheme which uses interaction protocols to debug agent interaction. Interaction protocols are specified using AUML and are translated to Petri nets. The debugger uses the Petri nets to monitor conversations and to provide precise and informative error messages when protocols aren't correctly followed by the agents.

This paper shows how to use a decision-theoretic task scheduler in order to automatically generate efficient intention selection functions for BDI agent-oriented programming languages. We concentrate here on the particular extensions to a known BDI language called AgentSpeak(L) and its interpreter which were necessary so that the integration with a task scheduler was possible. The proposed language, called AgentSpeak(XL), has several other features which increase its usability; some of these are indicated briefly in this paper. We assess the extended language and its interpreter by means of a factory plant scenario where there is one mobile robot that is in charge of packing and storing items, besides other administrative and security tasks. This case study and its simulation results show that, in comparison to AgentSpeak(L), AgentSpeak(XL) provides much easier and efficient implementation of applications that require quantitative reasoning, or require specific control over intentions (e.g., for giving priority to certain tasks once they become intended).

Instead of establishing trust through defining compliancy-based standards like protocols augmented by cryptographic methods, it is shown that trust can emerge as a self-organizing phenomenon in a complex dynamical system. It is assumed that trust can be modeled on basis of an intrinsic property called trustworthyness in every individual i, which is an objective measure for other individuals wether it is desirable to engage in an interaction with i or not. Trustworthiness can not directly be perceived, building trust therefore relates to estimating trustworthiness. Subjective criteria like outer appearance are important for building trust as they allow to handle unknown agents for whom data from previous interactions does not exist. Here, trustworthiness is grounded in the strategies of agents who engage in an extended version of the iterated Prisoner's Dilemma. Trust is represented as preference to be grouped together with agents with a certain label to play a game. It is sho...

In this paper, we outline the relation between Knowledge Management (KM) as an application area on the one hand, and software agents as a basic technology for supporting KM on the other. We start by presenting characteristics of KM which account for some drawbacks of today's -- typically centralized -- technological approaches for KM. We argue that the basic features of agents (social ability, autonomy, re- and proactiveness) can alleviate several of these drawbacks. A classification schema for the description of agent-based KM systems is established, and a couple of example systems are depicted in terms of this schema. The paper concludes with questions which we think research in Agent-mediated Knowledge Management (AMKM) should deal with.

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.

Agents are a powerful technology with many significant applications. A key issue in getting the technology into mainstream software development is the development of appropriate methodologies for engineering agent-oriented software. This paper presents the Prometheus methodology, which has been developed over several years in collaboration with Agent Oriented Software. The methodology has been taught at industry workshops and university courses. It has proven effective in assisting developers to design, document, and build agent systems. Prometheus is a detailed and complete (start to end) methodology for developing intelligent agents which has evolved out of industrial and pedagogical experience, and which is supported by tools. This paper gives a brief overview of the design process as a whole and then discusses envisaged tool support as well as the implemented tool prototypes we have been using.