7.1 Software Agents

7.1 Software Agents

7.1.1 Introduction

Software agents are probably the key technology in me-centric computing, and they act as the glue for the whole architecture. Software agents are used for communication between intelligent components of the network, and they represent users on the network. With intelligent agents, it becomes possible for the first time for people who use computers to reduce their workload, because they can offload it to these agents. People can do more without having to work more. Therefore, it is very important to understand what agents are and how they work.

Recent trends have made it clear that software complexity will continue to increase dramatically in the coming decades. The dynamic and distributed nature of both data and applications requires that software not merely respond to requests for information, but intelligently anticipate, adapt, and actively seek ways to support users. Not only must these systems assist in coordinating tasks among humans , they must also help manage cooperation among distributed programs.

In response to these requirements, the efforts of scientists from several different fields have begun to coalesce around a common broad agenda: the development of software agents. In software development, several levels of abstraction have taken place to make programming more efficient and easier. Software developers and system designers use high-level abstractions in building complex software to manage complexity and to make programming more natural. An abstraction focuses on the important and essential properties of a problem and hides the incidental components of that problem.

It started out with methods and functions, and went on to objects and agents. An object is a high-level abstraction that describes methods and attributes of a software component. An agent, however, is an extremely high-level software abstraction that provides a convenient and powerful way to describe a complex software entity. Rather than being defined in terms of methods and attributes, an agent is defined in terms of its behavior. This is important because programming an agent-based system is primarily a matter of specifying agent behavior instead of identifying classes, methods, and attributes. It is much easier and more natural to state desired results (give objectives, propose goals, delegate tasks) than it is to tell one how to accomplish them or what behaviors should be done. This is the necessary and sufficient condition for delegating work: Tell the agent what you want the conditions to be (at the end, along the way, etc.), and leave the agent to figure out how to achieve them. Agents provide a new way of managing complexity because they provide a new way of describing a complex system or process. Using agents, it is easy to define a system in terms of agent-mediated processes.

If you look at Figure 7.1, you can see how the relationship between user and agent works. There you can see a user, an associated agent, and a set of agents that are communicating with the personal agent through the agents network. Work is delegated by the user , accepted by the associated agent and partly delegated to the other agents. These agents execute their tasks and report back to the associated agent, which in turn reports back to the user. The agents interact with legacy systems, such as payment systems and order entry systems. The key difference to today's computing paradigm is that you do not tell the agent how to do the work, but you ask the agent to accomplish something.

Figure 7.1. The User-Agent Relationship

A software agent has a common set of features: It is autonomous, communicative, and perceptive. This means that the agent is capable of operating as a standalone process and performing actions without user intervention. It can communicate with the user, other software agents, or other software processes, and is able to perceive and respond to changes in its environment.

While software agents must be autonomous, communicative, and perceptive, they can have different levels of competence as determined by their programsthat is, their task specifications. If the competence is limited by the task specification, that would be a failure of the user's to ask for the right thing. If the agent were, on the other hand, given a good and effective task specification but seemed incompetent at accomplishing it, that would be a reflection of ignorance, limited problem-solving ability, or some other inherent weakness.

The goal is to make software agents as useful as possible, which in turn requires that we be able to task them in the most natural possible way. Just as we would task an assistant or a craftsman. That in turn requires that they understand the kinds of aspirations we have, the way we communicate those to them, and what they would need to do to ensure correct interpretation of the inferred tasks and effective and efficient accomplishment of those tasks. If we could easily tell them what we wish and they could always get it right and do the right thing, we'd find them almost super-natural, like an extraordinary personal assistant.

The system developer no longer has to design communication protocols and message formats. The agent provides this capability as part of the basic agent mechanism. Agents have the inherent capability to build models of their environment, monitor the state of that environment, and reason and make decisions based on that state. The software developer simply needs to specify what the agents are to do in any given situation.

Consider, for example, the system design issues involved in building a content management application that ties together content editors, content managers, designers, and Webmasters, and automates much of the content approval process. Building this system using current technology is a complex and difficult task, because the system decomposition forces the developer to deal with relatively low-level concepts (e.g., content input form, layout, approvals ) when defining the overall system architecture.

In addition, significant design time must be dedicated to defining the communications protocol and interfaces that will allow the company to exchange data with external contributors for text and images. In an agent-oriented system design, the system solution might include a text collection agent, a workflow agent, an approval agent, etc. The focus is placed on the behavior of each of these agents and communication between agents. The problem is made much easier because the level of abstraction is much higher and the programming problem becomes one of specifying agent behavior. Business people, for example, can easily control the process, as they understand what is happening. They do not have to deal with source code or application interfaces anymore.

Software agents provide an ideal mechanism for integrating legacy systems with new data systems. Agents can be used to perform data translation and implement data systems interfaces that meet a wide variety of requirements (see also Figure 7.2). In many applications, system developers have legacy code that performs some unique function that is needed in their new applications. A software agent can be used to invoke and execute this legacy code, leveraging the value of the existing code base.

Figure 7.2. The Agent Model

Through agents, it is possible to delegate work. To delegate work, it is necessary to be sure that this work is done properly and on time. However, by definition, delegation implies relinquishing control of a task to an entity with different memories, experiences, and possibly agendas . Thus, by not doing something ourselves, we open ourselves up to a certain risk that the agent will do something wrong. This means that we have to balance the risk that the agent will do something wrong with the trust that it will do it right. This decision must be based on both our internal mental model of what the agent will do (hence, how much we trust it) and the domain of interest (hence, how much a mistake will cost us).

A very important feature of agents is the graceful degradation in case of problems. When communicating with an agent, a communications mismatch or domain mismatch can occur. This means that either the two parties do not understand each other very well or the parties are talking about the same task, but in different environments. So if the agent is not sure what to do, it should only fulfill the subtasks it is sure about and request another communication round with the user, before executing the rest of the subtasks . This is generally a better outcome and gives the user more trust in the agent's performance.

The user and the agent are essentially collaborating in constructing a contract. The user is specifying what actions should be performed on his or her behalf , and the agent is specifying what it can do and providing results. This is often best viewed as a two-way conversation, in which each party may ask questions of the other to verify that both sides are in agreement about what is going on. As such, the two parties interact more as peers in agent-oriented systems; in non-agent-oriented systems, the user typically "commands," through some interface, a particular action, and is probably never asked a question about the action unless something goes wrong. In a strictly agentless situation (e.g., a text editor), the feel of the interaction is different than when an agent is present, primarily due to the discourse -oriented nature of the interaction with the agent and the more "stimulus-response" or "non-conversational" feel of the text editor. Once the agent has understood what the user wants it to do, the agent can start the same contracting with other agents, services, devices, or other humans to make sure that the task is executed in the way agreed upon by the original contract between the initiator and his or her agents.

7.1.2 Typical Use of Agents

Software agents can be used in a variety of environments and applications. They reduce the complexity of formerly highly complex systems, but not in all cases. Software agents cannot simplify every type of problem. Agents can be used, for example, in applications that involve distributed computation or communication between components. They can also be used in applications where the software agents need to analyze messages or objects coming from the network and need to respond in an automated manner. Agents are, therefore, well suited for most Internet applications (see Table 7.1). ^[1]

^[1] For more information, see also: Anderson, R. H., and J. J. Gillogly, Rand Intelligent Terminal Agent (RITA): Design Philosophy , Rand Corporation Technical Memorandum R-1809-ARPA, February, 1976.

In applications that can be automated, agents can play an important role, as they maintain a description of their processing state and the state of the world around them. These agents can operate without input or intervention of a user. Today, these agents are already used in applications such as process automation, workflow management, and robotics .

Since agents have the ability to draw inferences, they can easily perform sequences of complex operations based on messages they receive, their own internal beliefs, and their overall goals and objectives.

7.1.3 Software Agencies

Software agents can work on their own, but show their power when working together with other software agents. In this way, it is possible to create a highly competent answer from a set of simple agents. A collection of software agents that communicate and cooperate with each other is called an agency . System designers using agents must consider the capabilities of each individual agent and how multiple agents can work together.

The agent-based approach allows the system designer to implement the system using multiple agents, with each agent specialized for a particular task. For example, an electronic commerce application might have buyer agents, seller agents, stocking agents, database agents, e-mail agents, etc. All of these agents need to communicate with each other and must have the capability of working together to achieve a common set of goals.

Table 7.1. Agent Systems

Agents are ideally suited for a wide variety of applications, but they are particularly well suited for the following types of applications:

• Process and Workflow Automation In companies, these agents can reduce human interaction across the supply chain, for example.

• Electronic Commerce Agents can find the lowest price, the fastest delivery, or the best product on behalf of the buyer.

• Distributed Problem Solving When trying to solve a problem, agents can swarm out to other systems either to find a solution or to use the CPU power of that system to solve the problem.

• Internet Applications Business-to-Business (B2B) applications, for example, which involve complex workflows with partners and suppliers, can be handled through agents.

7.1.4 Competence Levels

Agents can be constructed with a wide range of capabilities. One of the advantages of the agent-based approach is that many times a complex processing function can be broken into several smaller, simpler ones. Since each individual agent can be crafted to be an expert in solving a specific problem or performing a particular task, you can build systems that exhibit complex behaviors by using a collection of relatively simple agents.

Sometimes, however, we do need to build agents that are quite smart. With the agent-based approach, you can implement agents with sophisticated intellectual capabilities such as the ability to reason, learn, or plan. In addition, intelligent software agents can utilize extensive amounts of knowledge about their problem domain. This means that the underlying agent architecture must support sophisticated reasoning, learning, planning, and knowledge representation.

Sophisticated software agents can be very difficult to build if you are building them from scratch. You will need specialized skills and knowledge in a variety of areas including agent architecture, communications technology, reasoning systems, knowledge representation, agent communication languages, and protocols. If you want to add machine learning or machine planning capabilities, you will need skill in these areas as well. If you don't possess these specialized skills and knowledge, you should use an agent construction toolkit. Agent construction toolkits allow software developers without agent expertise to quickly and easily build software agents.

7.1.5 Trust

We expect it will take quite a while for people to trust that their agents will do the right thing (see also Table 7.2). For example, in the United States in June 2002, TiVo recorded a replay of a baseball game rather than the World Cup match that viewers had requested . This seriously affected customers' trust in the system. The reason was that ESPN decided to put the show on its premier channel ESPN, rather than ESPN2 as it had advertised and which was listed in the online schedules. TiVo was, in fact, blameless.

So each agent and all agents will have to earn our trust through demonstrated reliable performance and a sense of responsibility to get the right result, whatever it takes. The day after the World Cup match, users received an e-mail (see excerpt in Figure 7.3) from TiVo that explained what needed to be done in order to record the right game. A really good service would have communicated not back to the user but to the user's delegated agent (on the TiVo box), and made the appropriate change in behavior on time.

Figure 7.3. Excerpt from TiVo E-Mail to Customers

In the United Kingdom, TiVo played even more with the users' trust by recording a show that was paid for by the production company, so every user of TiVo found this show recorded on his or her device, no matter whether this was desired or not.

To increase the trust in agents, the agent technology needs to verify the results of previous activities if required and needs to put updating agreements with service providers in place, in case of changes. If the TiVo agent and the TiVo service had put updating agreements in place, people would have seen the right program. On the other hand, agents should do what the user wants and should not be doing things other people want.

Table 7.2. Agent Trust Building

Agents can do their job well only if the user trusts them. Therefore, the agent needs to build a trustworthy relationship through the following actions:

• Understand User's Intent The agent should paraphrase the intent of the user, so the user gets a feeling that the agent really did understand what was requested.

• Understand User's Context The agent should demonstrate understanding about the user's context and values (e.g., money, time, concern for privacy, concern for relationships, attitudes and manners of speech, value of other people's time, resources, etc.).

• Provide Reports The agent should provide intermediate reports and results to the user to "keep the relationship warm" with the user.

• Possess Reasonable Reaction to Errors The agent should provide a reasonable and caring reaction to errors and exceptions

• Ask for Help In truly novel circumstances, where the agent does not have any experience, it should ask the user for support.