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 break-
`through 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 com-
`paratively 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 funda-
`mentally 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 agent-
`based 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
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 1
`
`

`

`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 object-
`oriented 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 phy-
`sical 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
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 2
`
`

`

`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 sys-
`ems, 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.
`
`1.2 Agent Application Domain Characteristics
`
`Now that we have a better understanding of what the terms ‘agent’ and ‘agent-
`based system’ mean, the obvious question to ask is: what do agents have to offer?
`For any new technology to be considered as useful in the computer marketplace, it
`must offer one of two things:
`•
`
`the ability to solve problems that have hitherto been beyond the scope of
`automation – either because no existing technology could be used to solve the
`problem, or because it was considered too expensive (difficult, time-consuming,
`risky) to develop solutions using existing technology; or
`the ability to solve problems that can already be solved in a significantly better
`(cheaper, more natural, easier, more efficient, or faster) way.
`
`•
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 3
`
`

`

`6 Jennings and Wooldridge
`
`1.2.1 Solving New Types of Problem
`
`Certain types of software system are inherently more difficult to correctly design
`and implement than others. The simplest general class of software systems are
`functional. Such systems work by taking some input, computing a function of it,
`and giving this result as output. Compilers are obvious examples of functional
`systems. In contrast, reactive systems, which maintain an ongoing interaction with
`some environment, are inherently much more difficult to design and correctly
`implement. Process control systems, computer operating systems, and computer
`network management systems are all well-known examples of reactive systems. In
`all of these examples, a computer system is required that can operate independ-
`ently, typically over long periods of time. It has long been recognized that reactive
`systems are among the most complex types of system to design and implement
`(Pnueli, 1986), and a good deal of effort has been devoted to developing software
`tools, programming languages, and methodologies for managing this complexity –
`with some limited success. However, for certain types of reactive system, even
`specialized software engineering techniques and tools fail – new techniques are
`required. We can broadly subdivide these systems into three classes:
`• open systems,
`• complex systems, and
`• ubiquitous computing systems.
`
`1.2.1.1 Open Systems
`
`An open system is one in which the structure of the system itself is capable of
`dynamically changing. The characteristics of such a system are that its components
`are not known in advance, can change over time, and may be highly heterogeneous
`(in that they are implemented by different people, at different times, using different
`software tools and techniques). Computing applications are increasingly demanded
`by users to operate in such domains. Perhaps the best-known example of a highly
`open software environment is the Internet – a loosely coupled computer network of
`ever expanding size and complexity. The design and construction of software tools
`to exploit the enormous potential of the Internet and its related technology is one of
`the most important challenges facing computer scientists in the 1990s, and for this
`reason, it is worth using it as a case study. The Internet can be viewed as a large,
`distributed information resource, with nodes on the network designed and
`implemented by different organizations and individuals with widely varying
`agendas. Any computer system that must operate on the Internet must be capable of
`dealing with these different organizations and agendas, without constant guidance
`from users (but within well-defined bounds). Such functionality is almost certain to
`require techniques based on negotiation or cooperation, which lie very firmly in the
`domain of multi-agent systems (Bond and Gasser, 1988).
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 4
`
`

`

`Applications of Intelligent Agents 7
`
`1.2.1.2 Complex Systems
`
`The most powerful tools for handling complexity in software development are
`modularity and abstraction. Agents represent a powerful tool for making systems
`modular. If a problem domain is particularly complex, large, or unpredictable, then
`it may be that the only way it can reasonably be addressed is to develop a number
`of (nearly) modular components that are specialized (in terms of their repre-
`sentation and problem solving paradigm) at solving a particular aspect of it. In such
`cases, when interdependent problems arise, the agents in the systems must
`cooperate with one another to ensure that interdependencies are properly managed.
`In such domains, an agent-based approach means that the overall problem can be
`partitioned into a number of smaller and simpler components, which are easier to
`develop and maintain, and which are specialized at solving the constituent sub-
`problems. This decomposition allows each agent to employ the most appropriate
`paradigm for solving its particular problem, rather than being forced to adopt a
`common uniform approach that represents a compromise for the entire system, but
`which is not optimal for any of its subparts. The notion of an autonomous agent
`also provides a useful abstraction in just the same way that procedures, abstract
`data types, and, most recently, objects provide abstractions. They allow a software
`developer to conceptualize a complex software system as a society of cooperating
`autonomous problem solvers. For many applications, this high-level view is simply
`more appropriate than the alternatives.
`
`1.2.1.3 Ubiquity
`
`Despite the many innovations in human-computer interface design over the past
`two decades, and the wide availability of powerful window-based user interfaces,
`computer-naïve users still find most software difficult to use. One reason for this is
`that the user of a software product typically has to describe each and every step that
`needs to be performed to solve a problem, down to the smallest level of detail. If
`the power of current software applications is ever to be fully utilized by such users,
`then a fundamental rethink is needed about the nature of the interaction between
`computer and user. It must become an equal partnership – the machine should not
`just act as a dumb receptor of task descriptions, but should cooperate with the user
`to achieve their goal. As Negroponte wrote, ‘the future of computing will be 100%
`driven by delegating to, rather than manipulating computers’ (Negroponte, 1995).
`To deliver such functionality, software applications must be:
`• autonomous: given a vague and imprecise specification, it must determine how
`the problem is best solved and then solve it, without constant guidance from the
`user,
`• proactive: it should not wait to be told what to do next, rather it should make
`suggestions to the user,
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 5
`
`

`

`8 Jennings and Wooldridge
`
`• responsive: it should take account of changing user needs and changes in the
`task environment, and
`• adaptive: it should come to know user’s preferences and tailor interactions to
`reflect these.
`
`In other words, it needs to behave as an intelligent agent. These considerations
`give rise to the idea of an agent acting as an ‘expert assistant’ with respect to some
`application, knowledgeable about both the application itself and the user, and
`capable of acting with the user in order to achieve the user’s goals. We discuss
`some prototypical expert assistants in Section 1.3.
`
`1.2.2 Improving the Efficiency of Software Development
`
`Agent technology gives us the tools with which to build applications that we were
`previously unable to build. But it can also provide a better means of concept-
`ualizing and/or implementing a given application. Here, three important domain
`characteristics are often cited as a rationale for adopting agent technology (cf. Bond
`and Gasser, 1988):
`• data, control, expertise, or resources are inherently distributed,
`•
`the system is naturally regarded as a society of autonomous cooperating com-
`ponents, or
`the system contains legacy components, which must be made to interact with
`other, possibly new software components.
`
`•
`
`1.2.2.1 Distribution of Data, Control, Expertise, or Resources
`
`When the domain involves a number of distinct problem solving entities (or data
`sources) that are physically or logically distributed (in terms of their data, control,
`expertise, or resources), and which need to interact with one another in order to
`solve problems, then agents can often provide an effective solution. For example, in
`a distributed health care setting, general practitioners, hospital specialists, nurses,
`and home care organizations have to work together to provide the appropriate care
`to a sick patient (Huang et al., 1995). In this domain, there is:
`• distribution of data: the general practitioner has data about the patient, which is
`very different from that of the hospital nurse – even though it concerns the same
`person,
`• distribution of control: each individual is responsible for performing a different
`set of tasks,
`• distribution of expertise: the specialist’s knowledge is very different from that
`of either the general practitioner or the nurse, and
`• distribution of resources: a specialist is responsible for the beds required by
`their patients, a general practitioner for paying hospital bills, etc.
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 6
`
`

`

`Applications of Intelligent Agents 9
`
`In cases like this, agents provide a natural way of modeling the problem: real-
`world entities and their interactions can be directly mapped into autonomous
`problem solving agents with their own resources and expertise, and which are able
`to interact with others in order to get tasks done. Also, in the case of distributed
`data sources, (as in sensor networks (Lesser and Corkill, 1983) and seismic
`monitoring (Mason, 1995)), the use of agents means that significant amounts of
`processing can be carried out at the data source, with only high-level information
`exchanged. This alleviates the need to send large amounts of raw data to a distant
`central processor, thus making more efficient use of communications bandwidth.
`
`1.2.2.2 Natural Metaphor
`
`The notion of an autonomous agent is often the most appropriate metaphor for
`presenting a given software functionality. For example:
`• a program that filters email can be presented to its user via the metaphor of a
`personal digital assistant (Maes, 1994), and
`• meeting scheduling software can naturally be presented as an empowered,
`autonomous, social agent that can interact with other similar agents on the
`user’s behalf.
`
`In such applications, the fact that these functions are implemented through a
`series of local agents also means that they can be personalized to reflect the
`preferences of their user. Finally, in computer games (Wavish and Graham, 1995)
`and virtual reality systems (Bates, 1994), characters can naturally be represented as
`agents.
`
`1.2.2.3 Legacy Systems
`
`Large organizations have many software applications (especially information sys-
`tems) that perform critical organizational functions. To keep pace with changing
`business needs, these systems must be periodically updated. However, modifying
`such legacy systems is in general very difficult: the system’s structure and internal
`operation will become corrupted with the passage of time, designs and docu-
`mentation are lost, and individuals with an understanding of the software move on.
`Completely rewriting such software tends to be prohibitively expensive, and is
`often simply impossible. Therefore, in the long term, the only way to keep such
`legacy systems useful is to incorporate them into a wider cooperating community,
`in which they can be exploited by other pieces of software. This can be done, for
`example, by building an ‘agent wrapper’ around the software to enable it to inter-
`operate with other systems (Genesereth and Ketchpel, 1994; Jennings et al., 1993).
`The process of transforming a software application such as a database into an agent
`is sometimes referred to as agentification (Shoham, 1993).
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 7
`
`

`

`10 Jennings and Wooldridge
`
`1.2.3 The Limitations of Agent Solutions
`
`Although agent technology has an important role to play in the development of
`leading-edge computing applications, it should not be oversold. Most applications
`that currently use agents could be built using non-agent techniques. Thus the mere
`fact that a particular problem domain has distributed data sources or involves
`legacy systems does not necessarily imply that an agent-based solution is the most
`appropriate one – or even that it is feasible. As with all system designs, the ultimate
`choice is dictated by many factors. This section has identified the types of situation
`in which an agent-based solution should be considered, as opposed to those in
`which it should be deployed. Moreover, it should be noted that the very nature of
`the agent paradigm leads to a number of problems, common to all agent- based
`applications:
`• No overall system controller. An agent-based solution may not be appropriate
`for domains in which global constraints have to be maintained, in domains
`where a real-time response must be guaranteed, or in domains in which dead-
`locks or livelocks must be avoided.
`• No global perspective. An agent’s actions are, by definition, determined by that
`agent’s local state. However, since in almost any realistic agent system,
`complete global knowledge is not a possibility, this may mean that agents make
`globally sub-optimal decisions. The issue of reconciling decision making based
`on local knowledge with the desire to achieve globally optimal performance is a
`basic issue in multi-agent systems research (Bond and Gasser, 1988).
`• Trust and delegation. For individuals to be comfortable with the idea of
`delegating tasks to agents, they must first trust them. Both individuals and
`organizations will thus need to become more accustomed and confident with the
`notion of autonomous software components, if they are to become widely used.
`Users have to gain confidence in the agents that work on their behalf, and this
`process can take time. During this period, the agent must strike a balance
`between continually seeking guidance (and needlessly distracting the user) and
`never seeking guidance (and exceeding its authority). Put crudely, an agent
`must know its limitations.
`
`1.3 Agent Application Domains
`
`Agents are the next major computing paradigm and will be pervasive in
`every market by the year 2000. (Janca, 1995)
`
`There are several orthogonal dimensions along which agent applications could be
`classified. They can be classified by the type of the agent, by the technology used to
`implement the agent, or by the application domain itself. We choose to use the
`domain type, since this view fits best with the objectives and structure of the rest of
`this chapter (see Nwana (1996) for an alternative typology). Our aim in producing
`this classification scheme is simply to give a feel for the breadth and variety of
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 8
`
`

`

`Applications of Intelligent Agents 11
`
`agent applications. More comprehensive descriptions of specific agent systems can
`be found in (AA97; Chaib-draa, 1995; Nwana, 1996; PAAM 1996; van Parunak,
`1996).
`
`1.3.1 Industrial Applications
`
`Industrial applications of agent technology were among the first to be developed: as
`early as 1987, Parunak reports experience with applying the contract net task
`allocation protocol in a manufacturing environment (see below). Today, agents are
`being applied in a wide range of industrial applications.
`
`1.3.1.1 Process Control
`
`Process control is a natural application for intelligent agents and multi-agent
`systems, since process controllers are themselves autonomous reactive systems. It is
`not surprising, therefore, that a number of agent-based process control appli-cations
`should have been developed. The best known of these is ARCHON, a soft-ware
`platform for building multi-agent systems, and an associated methodology for
`building applications with this platform (Jennings, 1995). ARCHON has been
`applied in several process control applications, including electricity transportation
`management (the application is in use in northern Spain), and particle accelerator
`control. ARCHON also has the distinction of being one of the earliest field-tested
`multi-agent systems in the world. Agents in ARCHON are fairly heavyweight
`computational systems, with four main components: a high-level communication
`module (HLCM), which manages inter-agent communication; a planning and
`coordination module (PCM), which is essentially responsible for deciding what the
`agent will do; an agent information management module (AIM), which is
`responsible for maintaining the agent’s model of the world, and finally, an
`underlying intelligent system (IS), which represents the agent’s domain expertise.
`The HLCM, PCM, and AIM together constitute a kind of ‘agent wrapper’, which
`can be used to encapsulate an existing intelligent system (or indeed any pre-existing
`software application) and turn it into an agent.
`
`1.3.1.2 Manufacturing
`
`Parunak (1987) describes the YAMS (Yet Another Manufacturing System), which
`applies the well-known Contract Net protocol (Smith, 1980) to manufacturing
`control. The basic problem can be described as follows. A manufacturing enterprise
`is modeled as a hierarchy of workcells. There will, for example, be workcells for
`milling, lathing, grinding, painting, and so on. These workcells will be further
`grouped into flexible manufacturing systems (FMS), each of which will provide a
`functionality such as assembly, paint spraying, buffering of products, and so on. A
`collection of such FMSs is grouped into a factory. A single company or
`organization may have many different factories, though these factories may
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 9
`
`

`

`12 Jennings and Wooldridge
`
`duplicate functionality and capabilities. The goal of YAMS is to efficiently manage
`the production process at these plants. This process is defined by some constantly
`changing parameters, such as the products to be manufactured, available resources,
`time constraints, and so on. In order to achieve this enormously complex task,
`YAMS adopts a multi-agent approach, where each factory and factory component
`is represented as an agent. Each agent has a collection of plans, representing its
`capabilities. The contract net protocol allows tasks (i.e., production orders) to be
`delegated to individual factories, and from individual factories down to FMSs, and
`then to individual workcells. The contract net is based on the idea of negotiation,
`and hence YAMS views the problem of deciding how best to process a company’s
`product manufacturing requirements as a negotiation problem. A some-what similar
`approach was developed in (Wooldridge et al., 1996), where the problem of
`determining an optimal production sequence for a factory was analyzed using the
`tools of game and negotiation theory.
`
`1.3.1.3 Air Traffic Control
`
`Kinny et al. (1996) describe a sophisticated agent-realized air traffic control system
`known as OASIS. In this system, which is undergoing field trials at Sydney airport
`in Australia, agents are used to represent both aircraft and the various air traffic
`control systems in operation. The agent metaphor thus provides a useful and natural
`way of modeling real-world autonomous components. As an aircraft enters Sydney
`airspace, an agent is allocated for it, and the agent is instantiated with the
`information and goals corresponding to the real-world aircraft. For example, an
`aircraft might have a goal to land on a certain runway at a certain time. Air traffic
`control agents are responsible for managing the system. OASIS is implemented
`using the AAII’s own dMARS system. This system allows an agent to be
`implemented using the belief-desire-intention model of agency – one of the most
`popular approaches to reasoning about agents in theoretical multi-agent systems.
`
`1.3.2 Commercial Applications
`
`1.3.2.1 Information Management
`
`As the richness and diversity of information available to us in our everyday lives
`has grown, so the need to manage this information has grown. The lack of effective
`information management tools has given rise to what is colloquially known as the
`information overload problem. Put simply, the sheer volume of information
`available to us via the Internet and World Wide Web (WWW) represents a very
`real problem. The potential of this resource is immediately apparent to anyone with
`more than the most superficial experience of using the WWW. But the reality is
`often disappointing. There are many reasons for this. Both human factors (such as
`users getting bored or distracted) and organizational factors (such as poorly
`organized pages with no semantic markup) conspire against users attempting to use
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 10
`
`

`

`Applications of Intelligent Agents 13
`
`the resource in a systematic way. We can characterize the information overload
`problem in two ways:
`•
`
`Information filtering. Every day, we are presented with enormous amounts of
`information (via email and newsnet news, for example), only a tiny proportion
`of which is relevant or important. We need to be able to sort the wheat from the
`chaff, and focus on information we need.
`Information gathering. The volume of information available prevents us from
`actually finding information to answer specific queries. We need to be able to
`obtain information that meets our requirements, even if this information can
`only be collected from a number of different sites.
`
`•
`
`One important contributing factor to information overload is almost certainly
`that an end user is required to constantly direct the management process. But there
`is in principle no reason why such searches should not be carried out by agents,
`acting autonomously to search the Web on behalf of some user. The idea is so
`compelling that many projects are directed at doing exactly this. Three such
`projects are described below:
`• Maxims: (Maes, 1994) describes an electronic mail filtering agent called
`Maxims. The program ‘learns to prioritize, delete, forward, sort, and archive
`mail messages on behalf of a user’ (p. 35). It works by ‘looking over the
`shoulder’ of a user as he or she works with their email reading program, and
`uses every action the user performs as a lesson. Maxims constantly makes
`internal predictions about what a user will do with a message. If these
`predictions turn out to be inaccurate, then Maxims keeps them to itself. But
`when it finds it is having a useful degree of success in its predictions, it starts to
`make suggestions to the user about what to do.
`• Newt: (Maes, 1994) also describes an example of an Internet news filtering
`program called Newt. This program, implemented in C++ on a UNIX plat-form,
`takes as input a stream of usenet news articles, and as output gives a subset of
`these articles that it is recommended the user reads. The Newt agent is
`‘programmed’ by means of training examples: the user gives Newt examples of
`articles that would and would not be read, and this feedback is used to modify
`an internal ‘model’ (we use the term very loosely) of the user’s interests. The
`user can, if desired, explicitly program Newt by giving it precise rules (e.g.,
`“give me all articles containing the word ‘agent’”). Newt retrieves words of
`interest from an article by performing a full-text analysis using the vector space
`model for documents.
`• The Zuno Digital Library: A digital library is an organized, managed collection
`of data, together with services to assist the user in making use of this data. The
`Zuno Digital Library (ZDL) system is a multi-agent system that enables a user
`to obtain a single, coherent view of incoherent, disorganized data sources such
`as the World Wide Web, a user’s own data, collections of articles on publishing
`house sites, and so on (Zuno, 1997). Agents in ZDL play one of three roles:
`
`Petitioner STMICROELECTRONICS, INC.,
`Ex. 1020, IPR2022-00681, Pg. 11
`
`

`

`14 Jennings and Wooldridge
`
`• consumer – representing end users of the system, who can be thought
`of as consuming information;
`• producer – representing ‘content providers’, who own the information
`that customers consume; and
`facilitator – mapping between consumers and producers.
`
`•
`
`Consumer agents in the system are responsible for representing the user’s
`interests. They maintain models of users, and use these models to assist them,
`by proactively providing information they require, and shielding them from
`infor