Using Software Agents in Computational GRID

Using Software Agents in Computational Grids (Draft) Page 1 of 45

Using Software Agents in Computational Grids

Junwei Cao, Darren J. Kerbyson, and Graham R. Nudd

High Performance Systems Laboratory

Department of Computer Science, University of Warwick, UK

Abstract

Software agents are becoming a mainstream technology used widely in many areas including intelligent user interface, industry, Internet and WWW, electronic commerce, business process management, digital library, electronic meeting, entertainment, network management, virtual reality, artificial society, and so on.

Computational Grids are a new concept emerging in the field of high performance computing. As it aims to a universal source of computing power, software agents will be sure to play an important role in the development of this new infrastructure. On the basis of past and present developments of the most important, relevant and involved applications of software agents in high performance computing, future trends and developments of agent technology in Computational Grid will also be extrapolated and predicted in this work.

In the current grid-oriented software systems agent technology has been used in different ways, which is, however, not noticed by the agent researchers. Many new techniques developed in agent research are also far not applied in grid-oriented software systems. This work is to build a bridge between these two.

The main contributions of this work include: 1). A new taxonomy of software agents is proposed and a list of related research directions is given on the basis of a snapshot of latest agent applications. 2). A simplified model of Computational Grids is illustrated using Unified Modeling Language. 3) A survey of agent applications in the Grid is described in details and several features are summarized on the characteristics of these applications. 4). Future challenges are predicted to give a blueprint of using software agents in the Grid.

1 Introduction

Software agents are becoming a more and more important software development technology. The key sign of this trend is the emergence of diverse applications and approaches in many different areas. It has become difficult to get a detail survey of agent technology in one article. However, some books aim to fulfil this purpose [Bradshaw1997; Chorafas1998; Jennings1998a; Nwana1996]. These books always include the history of agent development, the definition of software agents, the summary of new technologies and approaches, typical agent applications, and so on. So they are good to understand the basic concepts of software agents. Also there are many works on agent applications in different areas. These fields include intelligent user interface [Lieberman1997], manufacturing [Parunak1998], Internet and WWW [Nwana1997], electronic commerce [Nwana1998], business process management [Jennings1999], digital library [Atkins1996], electronic meeting [Chenh1996], entertainment [Maes1995], network management [Davison1998], virtual reality [Peters1998], artificial society [Gilbert1995], and so on.

In this work we discuss the subject of using software agents in Computational Grids. The Grid is an emerging infrastructure that will fundamentally change the way we think about – and use – computing. The Grid will connect multiple regional and national Computational Grids to create a universal source of computing power [Foster1998]. Two key points should be emphasised in the basic idea of Computational Grids. First, the Grid is another kind of infrastructure after railroad, telephones and telegraphs, power and light, banking, and Internet, which have all had a dramatic impact on human capabilities and society. The word “grid” is chosen by analogy with the electric power grid. Second, unlike other books, which are always the summaries of a mature research field, [Foster1998] gives only a new blueprint for the Grid. Though many essential building blocks are now, or soon will be, in place, Computational Grids do not yet exist.

The blocks from which Computational Grids will be constructed include advanced optical networks, fast microprocessors, parallel computer architectures, communication protocols, distributed software structures, security mechanisms, electronic commerce techniques, and so on. As a mainstream software technology, how much can software agents be used in the development of the Grid? What types of problem can software agents solve? What problems have been met in the development of the Grid? Have there been any applications of software agents to overcome the related difficulties? What can be applied in future? This work is to answer these questions. Figure 1 describes the main framework for the following contents.

Figure 1. The Sections of This Work

Though there have been many works discussing on the definitions related to software agents, there is still no agreement even on the question of what an agent is [Franklin1996]. However, in Section 2, we still try to give a definition and taxonomy of software agents in a different way firstly. By this way, we can understand the agent more simple and clear. The most important is that it is more convenient to get a global view of current agent techniques. Then we get a summary on the main features of the agent applications.

The basic idea of Computational Grids has been introduced above. In Section 3, the definition of the Grid will be described in greater details. By imaging the ways different users are to use the Grid, the questions of what the Grid should be like and what technologies should be applied are answered. Some of the contents of this section are referred in [Foster1998] but organized in a more systematic way.

On the basis of Section 2 and 3, Section 4 answers the main question of this work. That is how to use software agents in the Grid. Firstly, agent applications that have been used to build the related blocks of the Grid are summarized and several key features of current applications are given. Then a blueprint of using agents in the Grid is given in the following. In the research of software agents few works pay attention to the applications in high performance computing, while in the research of the Grid agent applications are only looked as a small part of the whole work and seldom been discussed independently.

Conclusions are given in Section 5. It is pointed out that using advanced agent technology will accelerate the development of the software infrastructure in the Grid. At the same time, new applications with new requirements will also stimulate the emergence of the new technology on software agents.

2 Software Agents

The aim of this section is to give a simple outline of software agents and get a clear description way enough for this work. So we won’t, in fact can’t, give much explanation as what have been done in [Bradshaw1997; Chorafas1998; Jennings1998; Nwana1996]. Note that some definitions may be different from the other works but are coherent within this work.

2.1 What is an agent?

There are two ways to get a definition on the agent. One is to get a description on what an agent should be from the research on related theories. According to this, whether a software entity is an agent or whether what is called an agent is a “true” agent can be distinguished. The other is to look through the current agent applications and understanding on the software agents and get a proper abstraction on them so that it can be accepted within a maximum scope. We adopt the later.

There are many terms used to describe the characteristics of software agents, such as autonomy, intelligence, reactivity, proactivity, personality, adaptivity, mobility, continuity, rationality, collaboration, and so on. But actually no agents have all these characteristics at the same time. We find that only one of them – autonomy – is the most essential to differentiate the agent from other simple program, and have been the most widely accepted. So we define the agent as the following:

An agent is a software entity, which functions autonomously.

Unfortunately, as mentioned in [Jennings1998], 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. This can be illustrated in Figure 2.

Figure 2. An Agent is an Autonomous Software Entity

As shown in Figure 2, the difference between an agent and a general software entity is that an agent encapsulates so-called “control” and “resource”, which mean that an agent know how to function by itself. Also the requirement and result for an agent may be different from the input and output for a general software entity in two aspects. One is that the requirement and result can be a high-level input and output according to some protocol, standard or model. The other is an agent can include a sensor and an effector to feel the requirement and produce the related result on its own initiative.

The difficulty to distinguish an input from a control results in the ambiguity in the understanding of the autonomy. That is to say, sometimes you can’t distinguish what to do and how to do strictly. So someone gives up an objective criterion for software agents and turns to a more subjective one, such as “you call it an agent when you want to treat it as a black box”. It is not necessary to say which is better. The most important is that we have got a basic idea of what an agent is and it is precise (though some ambiguities still exist) enough for us to continue the following discussion.

We describe autonomy as a more important characteristic for an agent than the others because we look the others only as the ways for an agent to achieve its autonomy. The basic two of these different ways are intelligence and social ability. Intelligence means that an agent can achieve the autonomy by an intelligent approach within the ability of itself. Social ability means that an agent achieves its autonomy by relationships with the other agents.

Type / The way to achieve autonomy / Example ways to achieve autonomy
Intelligent Agent (IA) / intelligence itself / personality, self-learning, life-like, reasoning, AI algorithm, control architecture, emotion, knowledge
Social Agent (SA) / simple relationship among agents / communication via ACL
Intelligent Social Agent (ISA) / intelligent relationship among agents / coordination, negotiation, evolution, self-organizing, market mechanism
Social Intelligent Agent (SIA) / mobility / migration

Table 1. Four Types of Software Agents

As shown in Table 1, two extensive types of the agents can be defined from the basic taxonomy of Intelligent Agent (IA) and Social Agent (SA).

From SA we can get IntelligentSocial Agent (ISA). There are a number of agent applications that are called agents only because they can communication and exchange their knowledges among each other. We classify these agents to be SAs. When the relationships among these agents are complex enough to have some characteristics of human society or nature world, such as negotiation and evolution, we call these agents ISAs. Note that the difference between the SA and ISA is not strict.

From IA we can get Social Intelligent Agent (SIA), which achieves its autonomy in so special an intelligent way that it looks exactly like society ability. The only example of this kind of agents is the mobile agent currently, which can move autonomously from one computer to another to fulfil its tasks. So we take SIA and mobile agents as exchangeable terms.

Besides these four types of the agents, the notion of the hybrid agent must be considered here. If an agent can self-learn as well as negotiate with the other agents, it is called a hybrid agent of I-type and IS-type. Some agents can achieve some high-level autonomy such as adaptivity only because they are more complex hybrid agents.

Multi-Agent System (MAS) is a widely accepted conception. When many agents interact with each other they form a MAS. So a SA or ISA must be in a MAS, while a IA and SIA may or may not be in a MAS.

Our taxonomy is different from my other works. The reason why we classify agents from a view of the technologies for agents to achieve autonomy is to create a convenient way to summarize the current agent technologies from diverse agent applications. This is described in the below.

2.2 What can agents do?

To understand what agents can do we give an introduction in details of current applications and research on software agents. First, we give a list of current applications of four types of software agents. For each kind of key technology for the agent to achieve its autonomy one or more current typical applications are introduced with related project background, agent structure, key technology description, and so on. Then many latest research directions on agent technology are described, including key technologies to achieve autonomy, agent engineering, agent development tools and environment, and so on.

2.2.1 Agent Applications

A list of current applications of software agents is given below in Table 2. Almost all of them emerged in the late 90’s, so they can represent the latest trend of agent technologies. There are also many typical applications in the early 90’s that are not included for most of their technologies have been inherited. Because the agent technology originated from the research on user interface, nowadays a quarter of the applications is still on the IUI. Only the typical applications on IUI are selected here. Note that some hybrid agent applications are also mentioned here, but we select its main part and classify it to only one of four types.

Using Software Agents in Computational Grids (Draft) Page 1 of 45

Type / Application Name / Project Background / Agent Structure (only internal structure for IA and SIA) / Key Technology to Achieve Autonomy / Statement
I / Adele [Shaw1999] / Adele is a lifelike animated pedagogical agent that is designed to work with Web-based educational simulations. The Adele architecture implements key pedagogical functions: presentation, student monitoring and feedback, probing questions, hints, and explanations. Adele’s design was based heavily upon earlier work on Steve [Rickel1998]. / Adele’s system consists of four main components: the pedagogical agent, the simulation, the client-server, and the server store. The pedagogical agent consists further of two sub-components, the animated persona and the reasoning engine. / Procedural tasks representation using a standard hierarchical plan; user feedback; situation-based reasoning; opportunistic learning; contextual references. / A typical agent application in computer-aided education.
ARA [Rogers1999] / Adaptive Route Advisor behaves more like a human travel agent, using driver preferences, when known, and working with him/her to find a satisfactory route. / The architecture for APA includes Interface Client, User Model, Route Server, and Digital Map with information from GPS and current traffic conditions. / A user model via interaction and an adaptation routing algorithm.
Athlete [Liu1998] / Athlete interacts with its virtual environment and gradually acquires its reactive behavior during the process of attaining a global goal. / The kinematic structure of Athlete is composed of eight links, interconnected with seven revolute joints. / Dual-level behavioral self-organization algorithm that involves the construction of a high-level behavioral pattern map and a low-level behavioral parameterization map.
CoRA [Strippgen1999] / Traditional human-computer dialogues circumvent those phenomena – a computer is not situated in its environment – but if a human and an agent sense and act in a common environment, new methods of language processing are needed. CoRA is able to understand natural languages directives on different levels of complexity. / The hybrid control architecture contains a behavior-oriented base system, which integrates language, perception and action on a lower level and a deliberative system, which models ‘higher’ cognitive competence. / A hybrid control architecture is developed to enable CoRA to process situated action directives on different levels of complexity.
EDEM [Hilbert1998] / Expectation-Driven Event Monitoring (EDEM) provides developers with a platform for creating software agents to collect usage data and increase user involvement in the development of interactive systems. / Expectation agents, or EA’s, continually monitor usage of the application and perform various actions when encapsulated expectations are violated. When a breakdown occurs, EA’s can provide developers with important contextual information such as system state and event history. / EDEM is based on a multi-level event model to allow event monitoring to be raised to the level of expectations.
Filterbot [Sarwar1998] / A model is implemented for integrating content-based ratings into a collaborative filtering system. The filterbot model allows collaborative filtering systems to address sparsity by tapping the strength of content filtering techniques. / The filterbot author writes a filterbot just like an information faltering agent. The set of filterbots can use very simple algorithms, such as spelling correctness and article length. Filterbot is called whenever new documents arrive, and it returns a numeric rating. / Content-based rating algorithm.
Grammex [Lieberman1999] / Grammex is the first direct manipulation interface designed to allow non-expert users to define grammars for text recognition and actions to take upon recognition interactively by concrete examples. / Text recognition agent and ScriptAgent, a programming by example system for the scripting language AppleScript [Lieberman1998]. / A user interface for define rules of recognition procedure; the “marionette strings” approach to integrate conventional applications - the agent is given a set of “strings” corresponding one-to-one with user actions in the interface, and can “tug” on the strings to make the program perform. / A typical agent application on IUI.
Guardian [Larsson1998] / The tasks of monitoring and diagnosing intensive-care patients take knowledge and skill and demand correct action in complex, unexpected, and time-critical situations. Guardian, is a knowledge-based system designed to perform these tasks for post-cardiac surgery patients. / It has a flexible and adaptive software architecture in which several algorithms can cooperate in solving complex problems in real time. Guardian has been designed as a reference architecture for autonomous agents for monitoring, diagnosis, and control in real-time. / Diagnostic algorithms: simulator, Focus, tFPR (temporal fuzzy pattern recognizer), ReAct, PCT (parsimonious covering theory), MFM (multilevel flow models), SPIN (skeletal plan instantiator); knowledge bases; a common language for medical diagnosis.