Share E-Book

Developing autonomous agent systems a practical guide to designing, building, implementing and testing agent systems (Michael Winikoff Lin Padgham)(Z-Library)

Author

,

Rating 3.5 AI initial rating

Log in to rate

C
Language English

Build your own intelligent agent system… Intelligent agent technology is a tool of modern computer science that can be used to engineer complex computer programmes that behave rationally in dynamic and changing environments. Applications range from small programmes that intelligently search the Web buying and selling goods via electronic commerce, to autonomous space probes. This powerful technology is not widely used, however, as developing intelligent agent software requires high levels of training and skill. The authors of this book have developed and tested a methodology and tools for developing intelligent agent systems. With this methodology (Prometheus) developers can start agent-oriented designs and implementations easily from scratch saving valuable time and resources. Developing Intelligent Agent Systems not only answers the questions “what are agents?” and “why are they useful?” but also the crucial question: “how do I design and build intelligent agent systems?” The book covers everything a practitioner needs to know to begin to effectively use this technology - including an introduction to the notion of agents, a description of the concepts involved, and a software engineering methodology. Read on for: a practical step-by-step introduction to designing and building intelligent agent systems. a full life-cycle methodology for developing intelligent agent systems covering specification, analysis, design and implementation of agents. PDT: Prometheus Design Tool – software support for the Prometheus design process. the example of an electronic bookstore to illustrate the design process throughout the book. Electronic resources including the Prometheus Design Tool (PDT), can be found at: http://www.cs.rmit.edu.au/agents/prometheus This book is aimed at industrial software developers, software engineers and at advanced undergraduate students. It assumes knowledge of basic software engineering but does not require knowledge of Artificial Intelligence or

Format PDF
Size 1.4 MB
(First 20 pages)

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

Page 1
Developing Intelligent Agent Systems A practical guide Lin Padgham & Michael Winikoff RMIT University, Melbourne, Australia
Page 2
(This page has no text content)
Page 3
Developing Intelligent Agent Systems
Page 4
Wiley Series in Agent Technology Series Editor: Michael Wooldridge, Liverpool University, UK The ‘Wiley Series in Agent Technology’ is a series of comprehensive practical guides and cutting-edge research titles on new developments in agent technologies. The series focuses on all aspects of developing agent-based applications, drawing from the Internet, telecommunications, and Artificial Intelligence communities with a strong applications/ technologies focus. The books will provide timely, accurate and reliable information about the state of the art to researchers and developers in the Telecommunications and Computing sectors. Titles in the series: Padgham/Winikoff: Developing Intelligent Agent Systems 0470861207 (June 2004) Pitt (ed.): Open Agent Societies 047148668X (August 2004)
Page 5
Developing Intelligent Agent Systems A practical guide Lin Padgham & Michael Winikoff RMIT University, Melbourne, Australia
Page 6
Copyright 2004 John Wiley & Sons Ltd, The Atrium, Southern Gate, Chichester, West Sussex PO19 8SQ, England Telephone (+44) 1243 779777 Email (for orders and customer service enquiries): cs-books@wiley.co.uk Visit our Home Page on www.wileyeurope.com or www.wiley.com All Rights Reserved. No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except under the terms of the Copyright, Designs and Patents Act 1988 or under the terms of a licence issued by the Copyright Licensing Agency Ltd, 90 Tottenham Court Road, London W1T 4LP, UK, without the permission in writing of the Publisher. Requests to the Publisher should be addressed to the Permissions Department, John Wiley & Sons Ltd, The Atrium, Southern Gate, Chichester, West Sussex PO19 8SQ, England, or emailed to permreq@wiley.co.uk, or faxed to (+44) 1243 770620. This publication is designed to provide accurate and authoritative information in regard to the subject matter covered. It is sold on the understanding that the Publisher is not engaged in rendering professional services. If professional advice or other expert assistance is required, the services of a competent professional should be sought. Other Wiley Editorial Offices John Wiley & Sons Inc., 111 River Street, Hoboken, NJ 07030, USA Jossey-Bass, 989 Market Street, San Francisco, CA 94103-1741, USA Wiley-VCH Verlag GmbH, Boschstr. 12, D-69469 Weinheim, Germany John Wiley & Sons Australia Ltd, 33 Park Road, Milton, Queensland 4064, Australia John Wiley & Sons (Asia) Pte Ltd, 2 Clementi Loop #02-01, Jin Xing Distripark, Singapore 129809 John Wiley & Sons Canada Ltd, 22 Worcester Road, Etobicoke, Ontario, Canada M9W 1L1 Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be available in electronic books. British Library Cataloguing in Publication Data A catalogue record for this book is available from the British Library ISBN 0-470-86120-7 (HB) Produced from LaTeX files supplied by the author, typeset by Laserwords Private Limited, Chennai, India Printed and bound in Great Britain by Antony Rowe Ltd, Chippenham, Wiltshire This book is printed on acid-free paper responsibly manufactured from sustainable forestry in which at least two trees are planted for each one used for paper production.
Page 7
Contents Foreword from the Series Editor ix Preface xi Acknowledgement xiii 1 Agents and Multi-Agent Systems 1 1.1 What is an Intelligent Agent? . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Why are Agents Useful? . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2 Concepts for Building Agents 7 2.1 Situated Agents: Actions and Percepts . . . . . . . . . . . . . . . . . . . 7 2.2 Proactive and Reactive Agents: Goals and Events . . . . . . . . . . . . 8 2.3 Challenging Agent Environments: Plans and Beliefs . . . . . . . . . . . 10 2.4 Social Agents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.5 Agent Execution Cycle . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 2.5.1 Choice of Plan to Execute . . . . . . . . . . . . . . . . . . . . . 14 2.5.2 Many Ways to Achieve a Goal . . . . . . . . . . . . . . . . . . 16 2.6 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 3 Overview of the Prometheus Methodology 21 3.1 Why a New Methodology? . . . . . . . . . . . . . . . . . . . . . . . . . 22 3.2 Prometheus: A Brief Overview . . . . . . . . . . . . . . . . . . . . . . 23 3.2.1 System Specification . . . . . . . . . . . . . . . . . . . . . . . . 24 3.2.2 Architectural Design . . . . . . . . . . . . . . . . . . . . . . . . 25 3.2.3 Detailed Design . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.3 Guidelines for Using Prometheus . . . . . . . . . . . . . . . . . . . . . 27 3.4 Agent-Oriented Methodologies . . . . . . . . . . . . . . . . . . . . . . . 29 4 System Specification 33 4.1 Goal Specification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.1 Identify Initial Goals . . . . . . . . . . . . . . . . . . . . . . . . 35 4.1.2 Goal Refinement . . . . . . . . . . . . . . . . . . . . . . . . . . 36 4.2 Functionalities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 4.3 Scenario Development . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 4.3.1 Goal Step Details . . . . . . . . . . . . . . . . . . . . . . . . . . 45 4.3.2 Capturing Alternative Scenarios . . . . . . . . . . . . . . . . . . 46
Page 8
vi CONTENTS 4.4 Interface Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.4.1 Percepts and Actions . . . . . . . . . . . . . . . . . . . . . . . . 48 4.4.2 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.5 Checking for Completeness and Consistency . . . . . . . . . . . . . . . 51 5 Architectural Design: Specifying the Agent Types 53 5.1 Deciding on the Agent Types . . . . . . . . . . . . . . . . . . . . . . . 56 5.2 Grouping Functionalities . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5.3 Review Agent Coupling – Acquaintance Diagrams . . . . . . . . . . . . 63 5.4 Develop Agent Descriptors . . . . . . . . . . . . . . . . . . . . . . . . . 65 6 Architectural Design: Specifying the Interactions 67 6.1 Interaction Diagrams from Scenarios . . . . . . . . . . . . . . . . . . . 68 6.2 Interaction Protocols from Interaction Diagrams . . . . . . . . . . . . . 74 6.3 Develop Protocol and Message Descriptors . . . . . . . . . . . . . . . . 77 7 Finalizing the Architectural Design 81 7.1 Overall System Structure . . . . . . . . . . . . . . . . . . . . . . . . . . 82 7.2 Identifying Boundaries of the Agent System . . . . . . . . . . . . . . . 82 7.3 Describing Percepts and Actions . . . . . . . . . . . . . . . . . . . . . . 84 7.4 Defining Shared Data Objects . . . . . . . . . . . . . . . . . . . . . . . 88 7.5 System Overview Diagram . . . . . . . . . . . . . . . . . . . . . . . . . 91 7.6 Checking for Completeness and Consistency . . . . . . . . . . . . . . . 94 7.6.1 Consistency between Agents and Functionalities . . . . . . . . . 95 7.6.2 Consistency between Interaction Diagrams, Scenarios and Protocols . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 7.6.3 Consistency of Communication Specifications . . . . . . . . . . 96 7.6.4 Consistency between Descriptors and the System Overview Diagram . . . . . . . . . . . . . . . . . . . . . . . . . 97 8 Detailed Design: Agents, Capabilities and Processes 99 8.1 Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 8.2 Agent Overview Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . 102 8.3 Process Specifications . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 8.4 Develop Capability and Process Descriptors . . . . . . . . . . . . . . . 106 9 Detailed Design: Capabilities, Plans and Events 109 9.1 Capability Overview Diagrams . . . . . . . . . . . . . . . . . . . . . . . 110 9.2 Sub-tasks and Alternative Plans . . . . . . . . . . . . . . . . . . . . . . 112 9.2.1 Identifying Context Conditions . . . . . . . . . . . . . . . . . . 113 9.2.2 Coverage and Overlap . . . . . . . . . . . . . . . . . . . . . . . 115 9.3 Events and Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 9.4 Action and Percept Detailed Design . . . . . . . . . . . . . . . . . . . . 117 9.5 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 9.6 Develop and Refine Descriptors . . . . . . . . . . . . . . . . . . . . . . 118 9.7 Checking for Completeness and Consistency . . . . . . . . . . . . . . . 119 9.7.1 Agent Completeness . . . . . . . . . . . . . . . . . . . . . . . . 120
Page 9
CONTENTS vii 9.7.2 Missing or Redundant Items . . . . . . . . . . . . . . . . . . . . 120 9.7.3 Consistency between Artifacts . . . . . . . . . . . . . . . . . . . 121 9.7.4 Important Scenarios . . . . . . . . . . . . . . . . . . . . . . . . 123 10 Implementing Agent Systems 125 10.1 Agent Platforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 10.2 JACK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 10.3 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 10.3.1 Agents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 10.3.2 Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 10.3.3 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 10.3.4 Messages/Events . . . . . . . . . . . . . . . . . . . . . . . . . . 134 10.3.5 Plans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 10.4 Automatic Generation of Skeleton Code . . . . . . . . . . . . . . . . . . 138 A Electronic Bookstore 139 B Descriptor Forms 199 C The AUML Notation 205 Bibliography 215 Index 221
Page 10
(This page has no text content)
Page 11
Foreword from the Series Editor As the concepts and technologies associated with intelligent software agents make their transition from the research lab to the desk of the IT practitioner, issues such as reliable analysis and design methodologies come increasingly to the fore. If agent technology is to mature into a successful and widely used approach to software development, then it is of critical importance that methodologies are developed, which are accessible to students and IT professionals alike, enabling them to deploy this new and promising technology to full effect. Although several such methodologies have been tentatively proposed, the PROMETHEUS methodology set out in this book is arguably the most mature. PROMETHEUS is a general purpose methodology for the development of software agent systems, in that it is not tied to any specific model of agency or software platform. The authors do an excellent job of describing the models and methods associated with PROMETHEUS and they show how these can be used to analyse and design multiagent systems by means of a detailed running example. Associated with the methodology, the authors have developed a freely available software design tool (PDT), which represents the state-of-the-art in multiagent systems development tools. All in all, this book repre- sents a valuable contribution, not just for those with an interest in the ongoing debate about development methods for multiagent systems but also for those who simply want an answer to the question: How do I actually do it? Mike Wooldridge, Liverpool, June 2004
Page 12
(This page has no text content)
Page 13
Preface Intelligent software agents1 are a powerful technology that is attracting considerable (and growing!) interest. While there are books that cover research areas on agents or survey the field (including the excellent book by Michael Wooldridge (Wooldridge 2002)), there is no book that is aimed at an industrial software developer that answers not only the questions ‘what are agents?’ and ‘why are they useful?’ but also the crucial question ‘how do I design and build intelligent software agents?’. Our book aims to provide a practical introduction to building intelligent agent sys- tems. It covers everything a practitioner needs to know to build multi-agent systems of intelligent agents. It includes an introduction to the notion of agents, a description of the concepts involved, and a software engineering methodology covering specification, analysis, design and implementation of agent systems. The core of the book is the Prometheus methodology for designing multi-agent sys- tems. The methodology was developed over the past six or seven years in collaboration with Agent Oriented Software2, a company that markets the agent development platform, JACKTM as well as agent solutions. The methodology has been used internally at Agent Oriented Software and has also been taught at industry workshops and within university courses. It has proven effective in assisting students and practitioners to develop and document their design and is now at a sufficient level of maturity that support tools have been developed. Our goal in developing Prometheus was to have a process with associated deliverables that could be taught to industry practitioners and undergraduate students who do not have a background in agents and which they could then use to develop intelligent agent systems. Our evidence that we have achieved this is, at this stage, still anecdotal; however, the indications are that Prometheus is usable by nonexperts and that they find it useful. We do not believe that Prometheus is complete and perfect, nor that it is a perfect fit as-is for all applications and all users. However, we do believe that it is usable and in our experience it is much better than not having a methodology. Like most methodologies, Prometheus is intended to be interpreted as a set of guidelines and you should use your common sense and take what is useful, adapting the methodology as needed to suit your needs. Although we do not believe that Prometheus is perfect, it is general purpose in the sense of not being specific to BDI (Belief-Desire-Intention) agents. Only the later part of 1This is shortened to ‘agents’ in the remainder of this book. 2http://www.agent-software.com
Page 14
xii PREFACE the detailed design phase (Chapter 9) makes assumptions about particular types of agent platforms. The assumptions made are fairly general and correspond to a class of agent platforms that have hierarchical plans with triggers, and a description for each plan that indicates the context in which it is applicable. Electronic Bookstore: Case study We will be using an example of an electronic bookstore to illustrate the design process throughout the book. To enable easy following of the example, we will enclose all of these examples in a framed box (like this one), which may extend over page breaks, in which case the bottom and top of the frame on the adjacent pages will be missing. In addition, the collected details of the example can be found in Appendix A. Electronic resources, including the forms in Appendix B and the Prometheus Design Tool (PDT), can be found at http://www.cs.rmit.edu.au/agents/prometheus Audience This book is aimed at industrial software developers and at undergraduate students. It assumes knowledge of basic software engineering but does not require knowledge of Artificial Intelligence or of mathematics. Familiarity with Java will help in reading the examples in Chapter 10. Tool Support We believe that tool support is, if not essential, incredibly useful in developing large designs and in helping to keep them consistent. Thus, we have developed a prototype tool, the Prometheus Design Tool (PDT). This tool supports the process described in this book, of system specification, architectural design and detailed design. The detailed design produced by PDT can be straightforwardly converted to the JACK Development Environment (JDE), and consequently to JACK code. A similar approach could be used to develop plug-ins that enable PDT to produce skeleton code for a range of agent programming platforms.
Page 15
Acknowledgements This book has evolved out of material originally developed with Agent Oriented Soft- ware (AOS) and refined over the course of a number of years of teaching an Agent Oriented Programming and Design course and supervising students in developing multi- agent systems. We thank our colleagues at AOS, especially Andrew Lucas and Ralph Rönnquist, as well as the many students who took our courses and provided valuable feedback. We acknowledge the support of the Australian Research Council (ARC) under grant CO01069343, and its continuation, grant LP04534864. The Prometheus Design Tool was initially developed by Anna Edberg and Christian Andersson. Further development has been done by Claire Hennekam and Jason Khallouf. We especially thank Ian Mathieson for his careful reading and commenting – this book has benefited considerably from his detailed comments. Lin Padgham & Michael Winikoff June 2004 Melbourne, AUSTRALIA 3Simplifying the Development of Agent-Oriented Systems, ARC SPIRT Grant, 2001-2003. 4Advanced Software Engineering Support for Intelligent Agent Systems, ARC Linkage Grant, 2004-2006.
Page 16
(This page has no text content)
Page 17
1 Agents and Multi-Agent Systems This book is about designing and implementing intelligent agent systems. We there- fore begin by answering the obvious first question, namely, ‘What is an agent?’. We answer this question by discussing the properties that characterize an intelligent agent, and contrast agents with objects. The usual second question is ‘Why should I bother with agents?’. We answer this question by arguing that agents are a natural progression from objects that provide a better abstraction and improved encapsulation, and also, perhaps more convincingly, by looking at applications of agent technology. The remaining chapters of this book are dedicated to answering the third question ‘How do I develop agents and agent systems?’. 1.1 WHAT IS AN INTELLIGENT AGENT? As is to be expected from a fairly young area of research, there is not yet a universal consensus on the definition of an agent. However, the Wooldridge and Jennings definition (see below) is increasingly adopted, and it is probably fair to say that most researchers in the field, when asked to provide their definition, will mention various properties drawn from those we discuss below. ☞ Definition: The following definition is from (Wooldridge 2002), which in turn is adapted from (Wooldridge and Jennings 1995): ‘An agent is a computer system that is situated in some environment, and that is capable of autonomous action in this environment in order to meet its design objec- tives’. Wooldridge distinguishes between an agent and an intelligent agent, which is further required to be reactive, proactive and social (Wooldridge 2002, page 23). Developing Intelligent Agent Systems L. Padgham & M. Winikoff 2004 John Wiley & Sons, Ltd ISBN: 0-470-86120-7 (HB)
Page 18
2 AGENTS AND MULTI-AGENT SYSTEMS Let us first note that we are talking about software agents. Whenever we (or any other researcher in the field) say ‘agent’, we really mean ‘software agent’. The typical dictionary definition of agent as ‘an entity having the authority to act on behalf of another’ (e.g. a real estate agent) is not what we mean1. Two basic properties of software agents are that they are autonomous and that they are situated in an environment. The first property, being autonomous, means that agents are independent and make their own decisions. This is one of the properties that distinguishes agents from objects. When we consider a system consisting of a number of agents, then a consequence of the agents being autonomous is that the system tends to be decentralized (we shall return to this in the next section). The second property (situatedness) does not constrain the notion of an agent very much since virtually all software can be considered to be situated in an environment. However, where agents differ is the type of environments. Agents tend to be used where the environment is challenging; more specifically, typical agent environments2 are dynamic, unpredictable and unreliable. These environments are dynamic in that they change rapidly. By ‘rapidly’, we mean that the agent cannot assume that the environment will remain static while it is trying to achieve a goal. These environments are unpre- dictable in that it is not possible to predict the future states of the environment; often this is because it is not possible for an agent to have perfect and complete information about their environment, and because the environment is being modified in ways beyond the agent’s knowledge and influence. Finally, these environments are unreliable in that the actions that an agent can perform may fail for reasons that are beyond an agent’s control. For example, a robot attempting to lift an item may fail for a wide range of reasons including the item being too heavy. Agents are often situated in dynamic environments that change rapidly. In particular, this means that an agent must respond to significant changes in its environment. For example, an agent controlling a robot playing soccer can make plans on the basis of the current position of the ball and of other players, but it must be prepared to adapt or aban- don its plans should the environment change in a significant way. In other words, agents need to be reactive, responding in a timely manner to changes in their environment. Another key property of agents is that they pursue goals over time, that is, they are proactive. One property of goals is that they are persistent; this is useful in that it makes agents more robust: an agent will continue to attempt to achieve a goal despite failed attempts. Although objects can be reactive, and can be seen as having an implicit goal, they are not proactive in the sense of having multiple goals, and of these goals being explicit and persistent. Thus, proactiveness is another property that distinguishes agents from objects. A key issue in agent architectures is balancing reactiveness and proactiveness. On the one hand, an agent should be reactive, so its plans and actions should be influenced by environmental changes. On the other hand, an agent’s plans and actions should be influ- enced by its goals. The challenge is to balance these two (often conflicting) influences: if the agent is too reactive, then it will be constantly adjusting its plans and not achieve 1Some software agents may act as agents in this sense as well. For example, a software assistant that buys products or services on behalf of its user. 2A more detailed analysis of different properties of environments can be found in (Wooldridge 2002) based on the taxonomy of (Russell and Norvig 1995).
Page 19
WHAT IS AN INTELLIGENT AGENT? 3 its goals. However, if the agent is not sufficiently reactive, then it will waste time trying to follow plans that are no longer relevant or applicable. Since failure of actions (and, more generally, of plans) is a possibility in challenging environments, agents must be able to recover from such failures, that is, they must be robust. A natural approach to achieving robustness is to be flexible. By having a range of ways of achieving a given goal, the agent has alternatives that can be used should a plan fail. These two properties are also distinguishing features of agents as compared to objects. Finally, agents almost always need to interact with other agents, that is, agents are social. This interaction is often at a higher level: instead of just saying that agents exchange messages, agent interaction can be framed in terms of performatives3 such as ‘inform’, ‘request’, ‘agree’, and so on. These have standard semantics that are defined in terms of their effects on an agent’s mental state. Agent interaction is often viewed in terms of human interaction types such as negotiation, coordination, cooperation and teamwork. On the basis of these properties, we use the following definition: ☞ Definition: An Intelligent Agent is a piece of software that is • Situated – exists in an environment • Autonomous – independent, not controlled externally • Reactive – responds (in a timely manner!) to changes in its environment • Proactive – persistently pursues goals • Flexible – has multiple ways of achieving goals • Robust – recovers from failure • Social – interacts with other agents. In addition to these properties, there are a number of other properties that we regard as less central. This does not mean that these are not important, just that they are not important for all agent applications. In pursuing their goals, we want agents to be rational. Part of being rational is that an agent should not do ‘dumb’ things such as simultaneously committing to two courses of action that conflict. For example, planning to spend money on a holiday at the same time as planning to spend that same money on a car. A detailed analysis of what is meant by ‘rational’ can be found in the work of Bratman (Bratman 1987). This analysis forms the basis of the Belief-Desire-Intention model for software agents (Rao and Georgeff 1992). 3This is based on speech act theory, which is beyond the scope of this book, and we refer the reader to Chapter 8 of (Wooldridge 2002) for more details.
Page 20
4 AGENTS AND MULTI-AGENT SYSTEMS One definition of agents (strong agency) takes these various properties, and also requires that agents are viewed as having mental attitudes such as beliefs, goals and inten- tions. This intentional stance (Dennett 1987) has a surprisingly pragmatic justification: as a system becomes more complex, its behaviour can be predicted more reliably by abstracting away from how it achieves its goals and instead reasoning about what are its goals and beliefs. For example, in attempting to ascertain whether a piece of furniture will support a person’s weight, we could model the stress and calculate its load-bearing ability, or we could consider its design and reason that the goal of a chair is to be sat upon and so any chair should be able to support a person’s weight. The former stance is the ‘physical stance’, the latter is the ‘design stance’. The ‘intentional stance’ is an extension of this that is applied to active entities. Although having agents that learn from their experiences can be essential for some applications, it can be disastrous for others. Similarly, there are applications in which modelling human emotions can be useful, such as interface agents or computer games, but equally, there are many applications in which this is not relevant. There is a whole body of work devoted to mobile agents (Harrison et al. 1995; Kotz and Gray 1999). However, there is surprisingly little overlap between the work on intelligent agents and the work on mobile agents. Mobility is more of a system-level issue, with much work devoted to questions such as ‘How can a running program be stopped, moved to another machine and restarted?’ and associated issues in security. 1.2 WHY ARE AGENTS USEFUL? Having described what agents are, we now turn to the question of why agent technology is useful. It is important to realize that, like other software technologies such as objects, agents are not magic. They are simply an approach to structuring and developing software that offers certain benefits, and that is very well suited to certain types of applications (in fact, one viewpoint considers agents to be an evolutionary step forward from objects (Odell 2002)). In order to understand why agents are useful, we need to understand how the distinctive features of agents translate into properties of software systems that are designed and built using agents. The usefulness of these properties (such as being decentralized) depends on the application, and so it is important to also understand how these software-system properties relate to application types and application areas. In addition to looking at application types, we try to provide examples of documented applications. Unfortunately, the field of agents is still quite young, so there are not many well-documented applications. However, some applications have been documented in the literature (e.g. Jennings and Wooldridge (1998b)). Perhaps the single most important advantage of agents is that they reduce coupling. Agents are autonomous, which can be seen as encapsulating invocation (Odell 2002; Parunak 1997). Whereas an object makes available methods that are triggered externally, an agent does not provide any control point to external entities. When a message is sent to an agent, the agent (being autonomous) has control over how it deals with the message. Coupling is reduced not only by the encapsulation provided by autonomy but also by the robustness, reactiveness and proactiveness of agents. An agent can be relied upon
The above is a preview of the first 20 pages. Register to read the complete e-book.

Recommended for You

Loading recommended books...
Failed to load, please try again later

Tip the Site

Scan the WeChat Pay or Alipay code to tip. No login required.

WeChat Pay
Alipay
← Back to List