1 Applications of Intelligent Agents

N. R. Jennings and M. Wooldridge

Queen Mary & Westfield College

University of London

1.1 Introduction

Intelligent agents are a new paradigm for developing software applications. More

than this, agent-based computing has been hailed as ‘the next significant breakthrough

in software development’ (Sargent, 1992), and ‘the new revolution in

software’ (Ovum, 1994). Currently, agents are the focus of intense interest on the

part of many sub-fields of computer science and artificial intelligence. Agents are

being used in an increasingly wide variety of applications, ranging from comparatively

small systems such as email filters to large, open, complex, mission

critical systems such as air traffic control. At first sight, it may appear that such

extremely different types of system can have little in common. And yet this is not

the case: in both, the key abstraction used is that of an agent. Our aim in this article

is to help the reader to understand why agent technology is seen as a fundamentally

important new tool for building such a wide array of systems. More

precisely, our aims are five-fold:

·  to introduce the reader to the concept of an agent and agent-based systems,

·  to help the reader to recognize the domain characteristics that indicate the

appropriateness of an agent-based solution,

·  to introduce the main application areas in which agent technology has been

successfully deployed to date,

·  to identify the main obstacles that lie in the way of the agent system developer,

and finally

·  to provide a guide to the remainder of this book.

We begin, in this section, by introducing some basic concepts (such as, perhaps

most importantly, the notion of an agent). In Section 1.2, we give some general

guidelines on the types of domain for which agent technology is appropriate. In

Section 1.3, we survey the key application domains for intelligent agents. In

Section 1.4, we discuss some issues in agent system development, and finally, in

Section 1.5, we outline the structure of this book.

Before we can discuss the development of agent-based systems in detail, we

have to describe what we mean by such terms as ‘agent’ and ‘agent-based system’.

Unfortunately, we immediately run into difficulties, as some key concepts in agentbased

computing lack universally accepted definitions. In particular, there is no real

agreement even on the core question of exactly what an agent is (see Franklin and

Graesser (1996) for a discussion). However, we believe that most researchers

4 Jennings and Wooldridge

would find themselves in broad agreement with the following definitions

(Wooldridge and Jennings, 1995).

First, an agent is a computer system situated in some environment, and that is

capable of autonomous action in this environment in order to meet its design

objectives. Autonomy is a difficult concept to pin down precisely, but we mean it

simply in the sense that the system should be able to act without the direct

intervention of humans (or other agents), and should have control over its own

actions and internal state. It may be helpful to draw an analogy between the notion

of autonomy with respect to agents and encapsulation with respect to objectoriented

systems. An object encapsulates some state, and has some control over this

state in that it can only be accessed or modified via the methods that the object

provides. Agents encapsulate state in just the same way. However, we also think of

agents as encapsulating behavior, in addition to state. An object does not

encapsulate behavior: it has no control over the execution of methods – if an object

x invokes a method m on an object y, then y has no control over whether m is

executed or not – it just is. In this sense, object y is not autonomous, as it has no

control over its own actions. In contrast, we think of an agent as having exactly this

kind of control over what actions it performs. Because of this distinction, we do not

think of agents as invoking methods (actions) on agents – rather, we tend to think of

them requesting actions to be performed. The decision about whether to act upon

the request lies with the recipient.

Of course, autonomous computer systems are not a new development. There are

many examples of such systems in existence. Examples include:

·  any process control system, which must monitor a real-world environment and

perform actions to modify it as conditions change (typically in real time) – such

systems range from the very simple (for example, thermostats) to the extremely

complex (for example, nuclear reactor control systems),

·  software daemons, which monitor a software environment and perform actions

to modify the environment as conditions change – a simple example is the

UNIX xbiff program, which monitors a user’s incoming email and obtains

their attention by displaying an icon when new, incoming email is detected.

It may seem strange that we choose to call such systems agents. But these are

not intelligent agents. An intelligent agent is a computer system that is capable of

flexible autonomous action in order to meet its design objectives. By flexible, we

mean that the system must be:

·  responsive: agents should perceive their environment (which may be the physical

world, a user, a collection of agents, the Internet, etc.) and respond in a

timely fashion to changes that occur in it,

·  proactive: agents should not simply act in response to their environment, they

should be able to exhibit opportunistic, goal-directed behavior and take the

initiative where appropriate, and

Applications of Intelligent Agents 5

·  social: agents should be able to interact, when they deem appropriate, with

other artificial agents and humans in order to complete their own problem

solving and to help others with their activities.

Hereafter, when we use the term ‘agent’, it should be understood that we are

using it as an abbreviation for ‘intelligent agent’. Other researchers emphasize

different aspects of agency (including, for example, mobility or adaptability).

Naturally, some agents may have additional characteristics, and for certain types of

applications, some attributes will be more important than others. However, we

believe that it is the presence of all four attributes in a single software entity that

provides the power of the agent paradigm and which distinguishes agent systems

from related software paradigms – such as object-oriented systems, distributed sysems,

and expert systems (see Wooldridge (1997) for a more detailed discussion).

By an agent-based system, we mean one in which the key abstraction used is

that of an agent. In principle, an agent-based system might be conceptualized in

terms of agents, but implemented without any software structures corresponding to

agents at all. We can again draw a parallel with object-oriented software, where it is

entirely possible to design a system in terms of objects, but to implement it without

the use of an object-oriented software environment. But this would at best be

unusual, and at worst, counterproductive. A similar situation exists with agent

technology; we therefore expect an agent-based system to be both designed and

implemented in terms of agents. A number of software tools exist that allow a user

to implement software systems as agents, and as societies of cooperating agents.

Note that an agent-based system may contain any non-zero number of agents.

The multi-agent case – where a system is designed and implemented as several

interacting agents, is both more general and significantly more complex than the

single-agent case. However, there are a number of situations where the single-agent

case is appropriate. A good example, as we shall see later in this chapter, is the

class of systems known as expert assistants, wherein an agent acts as an expert

assistant to a user attempting to use a computer to carry out some task.