Share E-Book
Scan to open this page

Scan with your phone to open this page

Author: Michael Winikoff, Lin Padgham

Rating 3.5 AI initial rating

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

AI Reading Assistant

Whole-book reading guide from stratified index samples; jump to passages in the text

AI guide
【One-Line Pitch】 A hands-on software-engineering guide to building multi-agent systems with the Prometheus methodology, walking from requirements through architecture to detailed design and implementation. Best for industrial developers, software engineers, and advanced students who know basic software engineering but not AI. 【Book Arc】 - **Opening (~0%–10%)**: Defines what an intelligent agent is, contrasts agents with objects, and argues why agent abstractions pay off in dynamic, open, failure-prone environments — answering "what" and "why" before "how." - **Early (~10%–30%)**: Introduces core agent concepts — goals, events, percepts, actions, beliefs, plans, and the sense-think-act execution cycle — then motivates a dedicated methodology by showing where object-oriented design falls short for proactive agents. - **Middle (~30%–50%)**: Lays out the Prometheus methodology's overall shape and design criteria, then begins the system specification phase: eliciting goals, writing scenarios, defining functionalities, and describing the system-environment interface, illustrated with an electronic bookstore case study. - **Late (~50%–80%)**: Moves into architectural design — determining agent types, grouping capabilities, and specifying interaction protocols — followed by detailed design that refines each agent's internals into capabilities, plans, events, and data structures. (Excerpts do not cover the exact chapter boundaries here.) - **Ending (~80%–100%)**: Closes with implementation and testing concerns plus tool support (the Prometheus Design Tool, PDT), tying the methodology back to a full development life cycle. (Excerpts do not cover the final chapters in detail.) 【Book Arc】 - **Opening (~0%–10%)**: Establishes the vocabulary and motivation — what agents are, why they matter, and what gap this book fills for practitioners. - **Early (~10%–30%)**: Builds the conceptual toolkit (goals, events, plans, beliefs, execution cycle) and justifies a new methodology over reusing OO analysis and design. - **Middle (~30%–50%)**: Presents the Prometheus overview and the specification phase — goals, scenarios, functionalities, and interface description — using the bookstore example. - **Late (~50%–80%)**: Covers architectural design (agent types, capabilities, interaction protocols) and detailed design (capability refinement, process specifications). - **Ending (~80%–100%)**: Addresses implementation, testing, and tool support, completing the life-cycle picture. (Excerpts are thin on these final stages.) 【Key Takeaways】 - **Agents are a natural step beyond objects** (Opening): The book argues agents offer better abstraction and encapsulation than objects, especially where behavior must be autonomous, proactive, and reactive — the "why bother" answer practitioners need before committing. - **Goals and events are the twin engines of agent behavior** (Early): Proactive agents pursue goals with persistence; reactive agents respond to significant events. Balancing the two — sticking to goals by default while noticing meaningful environmental change — is the central design tension. - **The sense-think-act cycle structures execution** (Early): Events update beliefs and trigger immediate actions, goals are updated and prioritized, then plans are selected from a plan library. Understanding this loop is prerequisite to designing anything. - **Object-oriented methods fit agent systems poorly** (Early): OO design lacks explicit goal modeling, a process for identifying agent types, and treatment of messages as first-class components — the gap Prometheus is built to fill. - **Prometheus is a full life-cycle methodology** (Middle): It spans specification, architectural design, and detailed design, deliberately avoiding a waterfall model and supporting iteration and tool assistance. - **Specification starts from goals, scenarios, and interfaces** (Middle): Goals are refined and grouped into functionalities; scenarios give a process view; percepts, actions, and external stores define the system boundary. These activities interleave rather than proceed strictly in sequence. - **Detailed design refines agents into capabilities, plans, and data** (Late): Each agent is progressively decomposed into nested capabilities until reaching plans, events, and data structures, while interaction protocols become process specifications. - **The methodology is a guideline, not a straitjacket** (Opening): The authors explicitly say Prometheus is not perfect or universal — readers should apply common sense and adapt it to their needs. 【Reading Tips】 - **Deep-read the early conceptual chapters** (goals, events, plans, execution cycle); later design steps assume this vocabulary fluently. - **Follow the electronic bookstore case study closely** — it threads through the specification and design chapters and is the best way to see the methodology applied end to end. - **Skim the methodology-comparison passages** if you are not researching methodologies; they are explicitly brief and incomplete by the authors' own admission. - **Treat the design criteria and process guidelines as a checklist** you can return to during your own project, rather than reading them once linearly. - **Pair the book with the PDT tool** if available, since the authors consider tool support highly desirable for realistically sized systems. 【Coverage Limits】 The excerpts concentrate on the book's motivation, conceptual foundations, and specification/design phases; implementation, testing, and the final chapters are only lightly represented, so this guide's late-stage coverage is thinner than the early material.
Excerpt 1
n be found at: http://www.cs.rmit.edu.au/agents/prometheus This book is aimed at industrial software developers, software engineers and at advanced undergrad...
View in text
Excerpt 2
veloped it in a variety of ways . . . ’ – http://www.gameai.com/blackandwhite.html PROACTIVE AND REACTIVE AGENTS: GOALS AND EVENTS 9 Percepts Events Actions...
View in text
Excerpt 3
an environment, and it is important to define the interface between agents and their environment. Percept processing is often important for agents that are s...
View in text
Excerpt 4
different parent goals, in which case we can coalesce them. We can then give a name to the grouping which describes it. This may be related to one of the ori...
View in text
Excerpt 5
rier companies’ areas/rates, and postal rates respectively. In addition, we identify the following clusters of information, without as yet defining all their...
View in text
Excerpt 6
ure 6.2 showing the end of the scenario where a user buys a book (Order Book scenario), the last three steps involve the Stock Manager logging the outgoing d...
View in text
Excerpt 7
? Most actions involving the real world can fail. Even in a software-only system, failures can occur: an e-mail address may be wrong, a web- site may be down...
View in text
Excerpt 8
s Phases, artifacts and relationships in the design process During architectural design, we developed an overview of which agents are in the system (the syst...
View in text
Tags
AI categories
Artificial IntelligenceSoftwareTechnology
ISBN: 0470861207
Publisher: Wiley
Publish Year: 2004
Language: English
Pages: 256
File Format: PDF
File Size: 1.4 MB
Text Preview (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.

Generating text preview…