using software agents in computational gridcaoj/pub/doc/jcao_t_survey.doc · web viewservice agents...

Using Software Agents in Computational Grids (Draft) of 43

Using Software Agents in Computational Grids

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

High Performance Systems LaboratoryDepartment 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

4 Using Software Agentsin Computational Grids

3 Computational Grids2 Software Agents

1 Introduction

2.1 What is an agent? 3.1 What is the Grid?

2.2 What can agents do?

4.1 What have been used?

4.2 What can be used in future?

2.3 What problems can agents solve?

3.2 What can the Grid do?

3.3 What challenges has the Grid met?

5 Conclusions


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).

Result

An agent

A general software entity

Input Output

Control

Resource

Requirement


From SA we can get Intelligent Social 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.


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

EDEM is based on a multi-level event model to allow event monitoring to be raised to the level of expectations.


information such as system state and event history.

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.

ibot [Zettlemoyer1999]

This is a specialized software agent that exists in the environment of the user interface. Such an agent interacts with applications through the same medium as a human user. Its sensors process screen contents and mouse/keyboard events to monitor the user’s actions and the responses of the environment, while its effectors can generate such events for its own contributions to the interaction.

Sensor; Effector; The infrastructure is divided into three separate modules: the image processing module (IPM), the event management module (EMM) and the internal state representation module (ISRM). Each gathers information from the other modules or the operating system to complete its specified tasks.

A pixel grouping algorithm; common user interface knowledge represented in the ERM; state information about how the user is interacting with the application; directly accessing the operating systems event queue.


NMRA [Pell1997]

This is the New Millennium Remote Agent architecture for autonomous spacecraft control systems. A prototype autonomous spacecraft agent is implemented within the architecture and demonstrated in the context of a challenging autonomous mission scenario on a simulated spacecraft.

In the architecture autonomous operations are achieved through the cooperation of 5 distinct components: Planning & Scheduling; Executive; Model-based Mode Identification and Recovery; Monitors; and Real-time Control System.

It integrates traditional real-time monitoring and control with constraint-based planning and scheduling, robust multi-threaded execution, and model-based diagnosis and reconfiguration.

An application on spacecraft control.

Open Sesame! [Das1998]

This is a Macintosh desktop agent that learns to automate the routine tasks of a user. It is an example of a software learning agent based on the Learn Sesame architecture. Open Sesame! version 1.0 watches for two kinds of tasks: time-based and event-based.

The Learn Sesame architecture, consisting of a client application and the learning engine, provides a framework for modeling a dynamic environment in which the states of certain entities called objects undergo changes as a result of actions by other domain entities.

A language that provides a simple, structured vocabulary called Model Definition Language (MDL); incremental learning; configurable clustering algorithms.

PPP Persona [Rist1997]

PPP Persona is a lifelike character used to present multimedia material to the user.

A presentation planner; medium-specific generators, currently for graphics, text and gestures; the Persona Server; and a constraint-based layout manager.

The underlying approach is based on multimedia presentation planning. This core approach is complemented by additional concepts, namely the temporal coordination of presentation acts and the consideration of the human-factors dimension of the added visual metaphor.

A typical lifelike agent.

Re:Agent [Boone1998]

This is an intelligent email agent that can learn actions such as filtering, prioritizing, downloading to palmtops, and forwarding email to voicemail using automatic feature extraction.

The overall operation of the agent is based on extracting useful features from documents to create a feature vector on which machine learning algorithms operate. The output of the learning algorithm is an action vector, which directs handlers to manipulate the document.Example handlers include delete, store, forward, auto-reply, or download to pagers or hand-held devices.

Concept feature approach; action learning with function approximators.

SAM [Kaminka1999]

A novel complementary framework for social monitoring that utilizes knowledge of social relationships among agents in

A knowledge-base containing models of relationships that should hold among the monitored agents; the agent modeling

Plan-recognition algorithm; knowledge of the social relationships.


monitoring them. component responsible for collecting and representing knowledge about the monitored agents; the detector that monitors for violations of relationships among monitored agents; and the diagnoser that verifies the failure, and provides an explanation for it.

ShopBot [Doorenbos1997]

ShopBot is a fully-implemented, domain-independent, comparison-shopping agent. Given the home pages of several online stores, ShopBot autonomously learns how to shop at those vendors. After learning, it is able to speedily visit over a dozen software and CD vendors, extract product information, and summarize the results for the user.

ShopBot operates in two phases: in the learning phase, an offline learner creates a vendor description for each merchant; in the comparison-shopping phase, a real-time shopper uses these descriptions to help a person decide which store offers the best price for a given product.

Environmental regularities (including navigation regularity, uniformity regularity and vertical separation regularity); offline learning algorithm.

Shopper’s Eye [Fano1998]

This is a PDA-based, GPS-enabled agent prototype that relies on knowledge of a shopper’s physical location to support the shopping task while shopping at a mall.

Knowledge of both the user’s goals, and the environment in which they act is a powerful combination that enable Shopper’s Eye to bring relevant information to the user throughout the course of their task.

Location-based filtering – exploiting the user’s location to constrain the task of an agent.

SNMP [Hood1998]

Simple Network Management Protocol agents process the collected information and use it to detect the network anomalies that typically precede a fault.

Observation processing and combination of information.

A change-detection method to characterize the behavior of measurement variables; an algorithm that segments data into variable-length pieces, each of which contains a portion of the time series that is statistically similar; feature extraction and learning; a probabilistic framework of a Bayesian network.

WebMate [Chenl1998]

Finding useful information on the Web is a time consuming process. WebMate is an agent that helps users to effectively browse and search the Web.

WebMate is composed of a stand-alone proxy that can monitor a user’s actions to provide information for learning and search refinement, and an applet controller that interacts with a user.

First, it uses multiple TF-IDF vectors to keep track of user interests in different domains. These domains are automatically learned by WebMate. Second, WebMate uses the Trigger Pair


Model to automatically extract keywords for refining document search. Third, during search, the user can provide multiple pages as similarity/relevance guidance for the search. The system extracts and combines relevant keywords from these relevant pages and uses them for keyword refinement.

S AARIA [Parunak1999]

An industrial-strength agent-based factory scheduling and simulation system being developed for an Army manufacturing facility.

Three persistent agents are Parts, Resources, and Unit Process. Interactions among these three persistent agents are modeled as transient agents, such as Engagements, Materials, Products, and Operations. Each transient agent has a six-phase life cycle: Inquiring, Committing, Committed, Available, Active, and Achieved.

Balanced numerical (in which the agents pass a fixed quantity of markers back and forth) communication with minimal reasoning.

A typical agent application on manufacturing.

AGENTS [Moreira1997]

The AGENTS system is a set of programs designed to generate automatically the mask-level layout of full custom CMOS, BICMOS, and bipolar leaf cells.

The AGENTS system uses four agent servers that can run in parallel on different machines: the Placer, Router, Database, and Broker. A broker is one who acts as an agent in negotiating contracts.

Communication via a subset of KQML.

APACS [Wang1997]

Basically, APACS was designed as a generic agent framework to aid future construction of systems that help power plant operators notice and diagnose failures in continuous processes. Specifically, APACS monitors a plant’s feedwater systems, which supply hot, pressurized, and demineralized water to boilers. APACS agents are fully aware of the overall goal of the feedwater system—which is to maintain a steady plant state—and based on that goal carefully monitor real-time plant information. Furthermore, these agents are

APACS architecture consists of three layers: the agent layer, the knowledge broker layer, and the information repository layer. The agent layer is essentially an application layer consisting of all the APACS agents. The knowledge broker layer manages communication between the agents. And the repository layer stores common knowledge used by all the agents and the knowledge broker. Each agent performs a separate function: data acquisition agent; tracking agent;

Synchronous and asynchronous communications.


able to infer trends from the plant information and can make diagnostic recommendations.

monitoring agent; human-computer interface (HCI) agent; diagnostic agent; verification agent.

InfoSleuth [Bayardo1997]

The goal of the InfoSleuth project is to exploit and synthesize new technologies into a unified system that retrieves and processes information in an ever-changing network of information sources.

User Agent; Ontology Agent; Broker Agent; Resource Agent; Data Analysis Agent; Task Execution Agent; Monitor Agent.

InfoSleuth is comprised of a network of cooperating agents communicating by means of the high-level agent query language KQML.

KIMSAC [Charlton1999]

The KIMSAC project (a European acts project - Kiosk-based Integrated Multimedia System Access to Citizens) started in September 95 with the vision of using the Personal Service Assistant Metaphor to provide public services to a variety of users.

Each agent represents an individual component, such as visual and requirements and services.

The architecture used CORBA to support heterogeneity across languages and platforms. The communication language used between agents was based on KQML and KIF.

PWS [Ardissono1999]

This is agent architecture of a configurable Web store supporting personalized interactions with users.

Several agents with different functions: Session Manager, Dialog Manager, User Modeling Component, Product Extractor, Personalization Agent, Shopping Cart Manager, and DB Managers.

Flexible and efficient agent communication.

Some of the individual agents are intelligent. So they are hybrid agents of IA and SA.

RoboTA [Forbus1998]

RoboTA is a colony architecture for software coaches in educational environments. A RoboTA agent colony has some specialized agents, plus agents written for specific courses.

A RoboTA colony has two kinds of agents: A central server process (the PostOffice) and course or application-specific agents (TA agents).

The PostOffice communicates with TA agents via KQML messages over TCP/IP socket connections.

SoCom [Jain1999]

A sphere of commitment (SoCom) is viewed conceptually as a scope within which a commitment applies; a SoCom is a multi-agent system that the agents constitute, and which serves as the context for commitments among those agents. A concrete SoCom is obtained by naming an abstract SoCom, and binding agents to its roles.

A SoCom is typically associated with a set of resources and authorities over them. A SoCom is modeled using a representative agent, which behaves as a group leader. The agents can represent nonterminating computations. Their results, therefore, must be released prematurely.

The agents communicate with other agents in order to create or adjust their commitments. The recipients autonomously process the communications. Consequently, by employing flexible commitments, recovery can be achieved without violating the autonomy of the consumers.


WorkWeb [Tarumi1997]

“WorkWeb System” is an expanded workflow system that is able to manage and control office resources. The “BPT agent” in the system autonomously manages each workflow process instance, trying to acquire the necessary resources to complete it in time.

In the WorkWeb System, there are four types of agents. Personal Agent manages human resources and acts as the user’s secretary. Resource Agent manages non-human resources: budgets, meeting rooms, shared tools or facilities, etc. It is created for each resource. BPT Agent manages each workflow process instance and tries to complete it in time or as early as possible. Data Management Agent does not manage any resources, but collects data from the agent network according to a given theme and gives the data as a cross-workflow view to other agents.

Each agent is given a URL address. By specifying a URL address, any agent can communicate with a destination agent (unless the communication is refused for security reasons).

IS ADEPT [Jennings1998b]

ADEPT is an agent-based approach to show how agent technology can improve efficiency by ensuring that business activities are better scheduled, executed, monitored, and coordinated.

The ADEPT multi-agent architecture is composed of a number of autonomous agencies. The concept of an agency has a recursive definition. An agency contains a single responsible agent, a possibly empty set of subsidiary agencies and a set of tasks that are under the direct management of the responsible agent.

There are three components of the ADEPT negotiation model: the communication protocol, the service level agreements, and the reasoning model.

An application on business process management.

Amalthaea [Moukas1998]

Amalthaea is an evolving, multi-agent ecosystem for personalized filtering, discovery, and monitoring of information sites.

Two general species of agents exist: the information filtering (IF) agents and information discovery (ID) agents. The information filtering agents (augmented weighted keyword vectors) are responsible for the personalization of the system and for keeping track of (and adapting to) the interests of the user. The information discovery agents are responsible for information resources handling, adapting to those information sources, and finding and fetching the actual information that the user is interested in. Each user has its own

The evolution of the agents is controlled by two elements: their individual fitness and the overall fitness of the system. Only a variable number of the top ranked (the best performers) of the whole population is allowed to produce offspring. The rank of an agent is based solely on its fitness. The number of the agents that will be allowed to produce offspring is linearly related to the number of agents that will be purged because of poor performance (low fitness). These numbers are not

A typical evolving multi-agent system.


distinct populations of information filtering and discovery agents.

constant and are related to the overall fitness of the system. If the over-all fitness is diminishing then the evolution rate is increased in search for quicker adaptation to the user's new interests.

CSS [Lin1994]

An agent based control simulation system was designed to model the agent based real time control and scheduling framework. The system contains a control simulation module and a manufacturing environment simulation module. The control simulation module consists of a collection of autonomous agents who negotiate with each other to reach job processing decisions.

Part agent, resource agent, monitoring agent, and so on communicate through a communication interface module.

Different multi-stage negotiation protocols; different price adjustment strategies and methodologies for selecting resources or selecting parts to serve.

DMS [Sen1997]

This is a software system that uses intelligent meeting-scheduling agents that can negotiate with other agents without compromising their user-specified constraints.

Each user is provided with an automated (computational) meeting-scheduling agent. When a user wants to schedule a meeting, she inputs a request to her agent, which becomes the host agent for that meeting; other users’ agents attending the meeting are called invitee agents.

Heuristic contract-based negotiation strategies.

FEA [Cicalese1999]

This is a massive concurrent computational model in which the multi-agent platform adapts its global behavior through a distributed fuzzy evolutionary model. The framework is based on the notion of fuzzy evolutionary actor (FEA).

Each actor has local knowledge of the overall environment, represented as local variables known as acquaintances; actors can perform tasks by using the values in their acquaintances; tasks are also activated by message exchanged among actors. An FEA is a modified version of a classical actor.

The actors themselves become evolutive and, in a way, “intelligent” entities: they are intelligent in the sense that their behavior is no longer fixed, but follows non-classical logical rules, i.e. actor knowledge is fuzzy. Actors are also evolutive, since their features undergo genetic algorithm based optimization.

Feature [Zhou1997]

This is a feature extraction system based on artificial life concepts. The system provides automatic character feature extraction through the local actions of autonomous

A feature agent is a simple artificial creature, who has a face, a body and two mouths, and can eat, move, grow and bear children in its environment.

An algorithm called Eat-Grow which gives general rules that every feature agent in the system should follow; a family growth algorithm which


feature agents. provides a parallel processing environment where more agents can eat, grow and bear simultaneously, and outputs a feature tree that stores the features.

Fishmarket [Rodriguez-Aguilar1998]

A framework is presented for defining trading scenarios based on fish market auctions. In these scenarios, agents of arbitrary complexity can participate in electronic auctions under a collection of standardized market conditions and be evaluated against their actual market performance.

Buyer agents were identified by a unique login and password delivered to their owners after registering. Then, once admitted into the auction room, all buyer agents were endowed with the same credit at the beginning of each auction of the tournament. Skeleton programs for buyer agents were provided in Java, C, Prolog, and Common Lisp.

When auctioning a good, one could choose among a wide range of bidding protocols. Each of these protocols can be characterized by a set of parameters that we refer to as bidding protocol dynamics descriptors, so that different instantiations of such descriptors lead to different behaviors of their corresponding bidding protocols.

HomeBots [Gustavsson1999]

In project ISES (Information, Society, Energy, and Systems) in Sweden, the load-balancing task of the demand of energy is modeled as a multi-agent system and a computational market with auctions as an allocation mechanism.

The allocation of agents follows the topology of the electric grid. Device agents, which are called HomeBots in this case, intermediate Service agents, and the Utility agent are the participants of the auction.

The market approach provides an integrated strategy for many different loads and contracts. It enables a natural decomposition, from both a software design and a computational perspective. All local characteristics are encapsulated by agents, communicating only through prices and demands, while performing local optimization computations. Due to different capabilities of the HomeBots and Utility agents, different auction schemes can be implemented.

A typical agent application on the power grid.

MAGNET [Collins1998]

MAGNET (Multi AGent NEgotiation Testbed) is a testbed for multi-agent negotiation, implemented as a generalized market architecture. MAGNET provides support for a variety of types of transactions, from simple buying and selling of goods and services to complex multi-agent contract negotiations.

The MAGNET architecture is a distributed set of objects. The fundamental elements of this architecture are the exchange, the market, and the market session. An exchange is a network-accessible resource that supports a set of markets and common services. Each market within an exchange is a forum for commerce a particular

Planning by Contracting is an activity in which an agent, in order to formulate its plans and fulfill its goals, must contract with other self-interested agents for all or part of the necessary tasks. The Planning by Contracting protocol is a three step process which begins after the session has been


commodity or business area. A market session (or simply a session) is the vehicle through which market services are delivered dynamically to participating agents. It serves as an encapsulation for a transaction in the market, as well as a persistent repository for the current state of the transaction.

initiated by a customer agent: the customer issues a call-for-bids, suppliers reply with bids, and the customer accepts the bids chooses with bid-accept messages.

SI Agent Tcl [Kotz1997]

Agent Tcl is a mobile-agent system whose agents can be written in Tcl, Java, and Scheme. Agent Tcl has extensive navigation and communication services, security mechanisms, and debugging and tracking tools.

The core system has four levels: transport mechanisms, a server that runs on each machine, an interpreter for each supported agent language, and the agents themselves; Support agents provide navigation, communication, and resource management services to other agents.

When an agent wants to migrate to a new machine, it calls a single function, agent_jump, which automatically captures the complete state of the agent and sends this state information to the server on the destination machine. The destination server starts up an appropriate execution environment (for example, a Tcl interpreter for an agent written in Tcl), loads the state information into this execution environment, and restarts the agent from the exact point at which it left off. Now the agent is on the destination machine and can interact with that machine’s resources without any further network communication.

DAIS [Hofmann1998]

The Domain Adaptive Information System (DAIS) is a mobile intelligent agent system for information discovery and dissemination in a military intelligence network.

The DAIS approach separates mobile task agents from stationary service agents. Task agents travel through the network and execute tasks on behalf of the user. Service agents remain at one location and preprocess information available locally and mediate access to this information. Service agents and the basic agent life cycle services collectively constitute the extended agent dock.

The extended agent dock consists of the dock proper, infrastructure service agents, and information service agents. The dock proper provides agent mobility and life cycle services, accepts and manages incoming mobile agents, and channels incoming messages to their intended receiver. The dock permits or denies mobile agents to move to its host. When the dock detects


that its host is overloaded with visiting agents, it prevents additional agents from moving in and ensures sustainable agent load on the machine.

MAGENTA [Sahai1998]

MAGENTA is a generic mobile agent environment for distributed applications and provides the agents the capabilities of autonomy, reactivity, proactivity and communication.

The architecture of MAGENTA comprises of lieus and agents. A lieu is a place or location where an agent can originate, reside, execute and interact with the system as well as with other agents. An agent is a program, which moves between the lieus and utilizes the lieu to perform its functions.

The agents have globally unique name, have a “purpose” which defines its type and behave autonomously. They “move” between the lieus carrying with them their data and program state. They have a “folder” to carry their results and can “meet” with other agents and exchange “notes”. A meet operation is enabled by the lieu to enable local communication between the agents. They also carry a “history” which stores all the tasks performed by the agent and “knowledge” which stores the information it gathers about the failed sites as it traverses its “itinerary”.

Tunnel [Meer1998]

RSVP is a framework for resource reservation and QoS provisioning mechanisms within the Internet. However, because non-RSVP routers can degrade the perceived QoS in an uncontrolled way, there is no end-to-end guarantee. The agent-based approach deals with tunnels that lead through so-called cloud of non-RSVP-capable network entities. It aims to improve the end-to-end quality by monitoring the tunnel and providing feedback to enhance the reservation scheme.

The primary goal of tunnel agents is to monitor tunnel properties, interacting with the RSVP routers for assuring the end-to-end QoS to the user. Tunnel agents must make decisions on how to achieve network reconfiguration. These decisions are based on information concerning the tunnel structure and state. All tunnel agents monitor the tunnel behavior and eventually interact with the RSVP protocol.

Decision-making; Interacting with tunnels; Interacting with RSVP; Migration after route change.

A typical agent application on network management.

A hybrid agent of SIA and IA.

Table 2 Agent Applications


2.2.2 Agent Technologies

There are many researches on the agent technique itself rather than its application on the other field. We also give a list here to get a more global view of agent technology development. We mean here a list but not a survey for that it is really difficult to get a systemic taxonomy on agent technologies.

First, many works focus on the research of how agents achieve their autonomy. These can be classified by the agent types we mention above.

(IA): Many AI algorithms are used in agents to achieve their intelligence. For example, several heuristic approaches were proposed to the development of pricing algorithms for software agents that incorporate foresight in [Tesauro1998]; [Maulsby1997] focuses on how to teach agents to learn.

(IA): Many autonomous agents have life-like characteristics such as reproduction, aging, metabolic cycle and movement. [Yap1999] describe how each characteristic may be useful to an agent. The study in [Lester1997] revealed the persona effect, which is that the presence of a lifelike character in an interactive learning environment can have a strong positive effect on student’s perception of their learning experience.

(SA): Agent Communication Languages (ACL) have been used in MAS for agents to exchange information and knowledge. The most widely known one is Knowledge Query and Manipulation Language (KQML) [Finin1994]. Yet agents from different vendors — or even different research projects — cannot communicate with each other. Some recent researches focus on rethinking the ACL principles. [Singh1998] concluded that an ACL’s formal semantics should emphasize social agency; A pragmatic principle of ACL usage is sketched out in [Holmback1999].

(ISA): The coordination problem in the MAS is the problem of managing dependencies between the activities of agents, in conditions of incomplete knowledge about the dynamically changing environment and about the actions, reactions and goals of the agents, such that to achieve the individual and shared goals of the participants and a level of coherence in the behavior of the system as a whole. [Malone1994] gave a survey of coordination theory; A reference architecture was given in [Ciancarini1997] to coordinate multi-agent applications on WWW; In [Washington1998] agent behavior was represented by partially observable Markov decision processes, which can capture uncertainty in both agent’s state and its actions; In [Clement1999] a method was described to coordinate the hierarchical plans of multiple agents at abstract levels.

(ISA): Evolution in societies of agents is a challenging phenomenon. [Brazier1999] introduced deliberate evolution of MAS, within which agents can deliberately influence the direction of the evolution.

(ISA): Auctions provide an efficient way of resolving one-to-many negotiations among agents. [Vulkan1998] introduced an efficient mechanism for the supply of services in multi-agent environments; [Preist1999] described a new agent-based market mechanism for commodity trading via the Internet, which combines the best properties of the continuous double auction and the call auction; An adaptive agent bidding strategy based on stochastic modeling has been developed in [Park1999] for a dynamic, evolving multi-agent auction.


(ISA): Negotiation is a kind of high-level communication between agents. The most typical application is the bargain in electronic commerce, in which negotiation protocol is associate with the interest models of buyer and seller. Further research is progressing like [Qiu1999], which is towards flexible negotiation in teamwork.

(SIA): Java is one of the efficient ways to implement mobile agents. In [Kiniry1997] issues, such as ease of installation, feature set, documentation, and cost, of three leading commercial systems — General Magic’s Odyssey, IBM’s Aglets, and ObjectSpace’s Voyager — were discussed; [Wong1999] explained why Java is such an effective implementation language for mobile agents in electronic commerce.

Second, software engineering related problems on agent development are discussed in many works. These include methodology for agent-oriented analysis and design [Wooldridge1999], design issues for mobile agent systems [Karnik1998], design patterns [Aridor1998; Hayden1999; Kendall1998], visualising and debugging MAS [Ndumu1999], testbed [Corchado1997], visual modeling [Falchuk1998], formalism [Métayer1998] and so on.

Third, many agent development tools are emerging towards an agent-based engineering. Table 3 includes the some latest research works. A survey on Java-based agent environments can be found in [Bigus1998].

Name Feature DescriptionsDAI [Chenq1998] This dynamic agent infrastructure differs from other agent platforms and C/S

infrastructures by its support of dynamic behavior modification of agents.HiMAT [Cremonini1999]

HiMAT model provides a unique, coherent framework for the design and development of mobile agent applications, where critical issues such as topology, authentication, authorization and coordination can be effectively addressed in a uniform way.

Jackal [Cost1999] Jackal is a Java-based tool for communicating with the KQML agent communication language. Some features that make it extremely valuable to agent development are its conversation management facilities, flexible, blackboard style interface and ease of integration.

OAA [Moran1997] An important consideration in the design of the OAA is to facilitate mix-and-match: to facilitate the reuse of agents in new and unanticipated applications, and to support rapid prototyping by facilitating the replacement of agents by better versions.

SIM_AGENT [Sloman1999]

The Sim_Agent toolkit allows construction of sets of agents, in which each agent has a multi-component architecture, in which different components operate in parallel, using different kinds of mechanisms.

Table 3 Agent Development Tools

There are also many miscellaneous research. These include sociological studies [Foner1997; Heckman1998; Heckman1999], user studies [Friedman1997; Gustafson1998], execution monitoring and failure diagnosing [Kaminka1998], exception handling service [Klein1999], standardization [Virdhagriswaran1995], and security [Karjoth1997; Pfitzmann1997].

2.2.3 Key Points of Agent-Oriented Development

There are a lot of information that can be retrieved from the summary of agent development described above. We give several key points to organize these information, which can be the answer of what we should consider when developing software agents [Wooldridge1998].

Agent-Oriented Software Engineering is developing rapidly. However there is no standard methodology that can be used to engineer different agent-based system.


But from the diverse applications above we can summary some common factors that must be considered seriously when developing software agents. We give a list below.

Human vs. agent. When an agent-based software system is to be developed, one of the most decisions is what an agent should do. There are two aspects of consideration on this question. One is from technology and the other is from sociological studies. Many earlier agent developers give a lesson: “Don’t let an agent to do what man can do easily.” Many latest works on implementing complex functions show a clear emphasis on human-agent negotiation, such as ARA in Table 2. The same story can be found in the other fields of research on AI and robot. Sociological studies do a lot on human-agent relationship. For example, agents cannot be so autonomous that they are out of the control of man. Also agents should not do what is considered as human right.

Things vs. functions. The question of what becomes an agent has been mentioned in [Parunak1997]. Whether agents should be things or functions is important especially in MAS. Some agents are dispatched to fulfil a special function in software system, such as almost all the IAs, PWS, AGENTS, and Amalthaea. Some are representation of physical things to take part in the cooperation among different components in the system. Such agent must be in the multi-agent system, for example, AARIA, WorkWeb, DMS, and Fishmarket. Some multi-agent systems like InfoSleuth include both thing agents and function agents. Whether agents should be things or functions depend on the situation the developer deals with. Software on complex system with huge number of different kinds of components would be better to adopt thing agents. It will be convenient to get a clear view of the whole system and easy to update when the functions of the system change; Simple system with special purpose can still adopt functional decomposition.

Intelligent vs. social. We classify the ways for agents to achieve autonomy into intelligence and social ability basically. AI approach can make agent fulfil special task, while communications among multi-agents also can implement complex functions especially in distributed systems. Large-scale applications as on manufacturing prefer to social ability. Future applications as on Computational Grids need both of these agent capabilities.

Single vs. multiple. Distributed applications often use MAS. Other applications can also use multiple agents. Each of them can fulfil one function as a part of the goal and work simultaneously. This is the essential decision on agent system structure.

Centered vs. scalable. One of the important differences between MAS structures is whether it is centered or scalable. When the MAS need global information management, centered structure is the simplest way. Sometimes the centered agent is called broker. In simple system it can work well. But in large-scale applications the broker may become the bottleneck of the software system. The robust and security of the system also become worse. Some systems like the Grid should be scaled to millions of hosts, so they can’t use centered structure. But to achieve scalability extra mechanism must be added to give global control.

Small vs. large. The size of the agent should also be considered when developing agent system. Some so-called ant-like agents, with simple function, small size and large number, can communicate to fulfil complex task. The main advantage is that it can improve the fault tolerance of the system because one failure has very


small impact on the system. Most agents are background processes and should not consume too much resource.

Scratch vs. tool. Though many agent development tools and environment are emerging, most of the current software agents are developed from scratch. Whether using tools or not is the final decision before programming. The developer must take trade-off between generalization and efficiency. For example, in DPSS project in Table 4, all of the agents use RMI-based communication, which is a decision made after KQML message passing turned out to be far less efficient.

2.3 What problems can agents solve?

In this section we discuss what problems agent can solve as the basis of the following sections discussing how to use software agents in Computational Grids. This subject has been discussed in [Jennings1998a] and also a good summary has been given.

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 or the ability to solve problems that can already be solved in a significantly better (cheaper, more natural, easier, more efficient, or faster) way. Software agents can be used to develop three classes of systems.

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. The best-known example of a highly open software environment is the Internet. And the Grid will be much more an open system than the Internet. The functionality is almost certain to require techniques based on negotiation or cooperation, which lie very firmly in the domain of MAS.

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. They can provide a useful abstraction in just the same way those procedures, abstract data types, and 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.

Ubiquitous computing systems. Interaction between computer and user 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. 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.

3 Computational Grids

In this section, we introduce the basic concepts of Computational Grids. After the introduction of the definition, the software infrastructure of the grid is described in greater details using Unified Modeling Language. The main challenges of developing a Grid are given briefly too.

3.1 What is the Grid?


We adopt the definition of the Grid in [Foster1998] here.

A Computational Grid is a hardware and software infrastructure that provides dependable, consistent, pervasive, and inexpensive access to high-end computational capabilities.

Figure 3. Computational Grids

Three key points in this concept should be emphasized.

(1). Supercomputers and their interconnection by high-speed network are significant hardware infrastructure for the Grid to provide computational capabilities. However, since what we are discussing here is how to use software agents in the Grid, we emphasis on the software infrastructure in the Grid which can control hardware to implement user’s requirement.

(2). The basic characteristics of dependability, consistency, pervasiveness and low cost are retrieved from the previous infrastructure like electric power grid. By analogy, only by equipped with all of these can the Grid achieve functions as an infrastructure.

(3). Accessing to high-end computational capabilities is the goal for the Grid to achieve. There are different kind of user like end users, application developers, system administrators, and so on. They will user the grid through different kind of applications including distributed supercomputing, high-throughput computing, on-demand computing, data-intensive computing, and collaborative computing. The Grid software infrastructure should also provide many kinds of services, such as performance analysis, visualization and scheduling, resource management and allocation, security, accounting and assurance.

The software infrastructure in the Grid is really a complex software system. Current many grid-oriented software systems are developed independently. Many new ideas in them are important to accelerate the development of the Grid. Unfortunately it will be difficult to integrate them into one global software system to support different kinds of requirement. In the next section a global view of the software infrastructure in the Grid will be given using unified modeling approach and tools.

3.2 What can the Grid do?


The Grid is so complex a system that it is difficult to understand what it can do exactly. It seems the Grid has to do a lot of things to support high performance computing. It must have a friendly user interface through which user can access the services of the Grid; It must manage the information on users, applications, tools, and resources; It must enable the user to preview their application execution; It must assure the security of the services; It must build efficient market mechanism to provide the cheapest service to the user. All these functions can be provided by the software infrastructure of the Grid at different level. To give a global view of how the Grid achieves its goal, we adopt the unified modeling approach and tools.

3.2.1 Unified Modeling Language

The Unified Modeling Language (UML) is a language for specifying, visualizing, constructing, and documenting the artifacts of software systems, as well as for business modeling and other non-software systems. The UML represents a collection of best engineering practices that have proven successful in the modeling of large and complex systems. Object Management Group (OMG) has accepted UML as the standard for modeling language.

UML is built on well-established and proven techniques for modeling systems. In [Martin1998] the foundation of object-oriented method was introduced in details, which is the basis for understanding UML. The global description of UML can be found in Addison-Wesley Object Technology Series including [Booch1999], [Rumbaugh1999] and [Jacobson1999].

The visual modeling tools are developed by Rational Software Corporation. How to use Rational Rose modeling tool shown in Figure 4 is described in details in [Eriksson1998] and [Quatrani1998]. Different parts of UML include:

Views. Views show different aspects of the system that are modeled. The use-case view describes the functionality the system should deliver, as perceived by external actors; The logical view describes how the system functionality is provided; The component view is a description of the implementation modules and their dependencies; The concurrency view deals with the division of the system into processes and processors; The deployment view shows the physical deployment of the system, such as the computers and devices (nodes) and how they connect to each other.

Diagrams. Diagrams are the graphs that describe the contents in a view. UML has nine different diagram types that are used in combination to provide all views of the system, such as use-case diagram, class diagram, object diagram, state diagram, sequence diagram, collaboration diagram, and so on.

Model elements. The concepts used in the diagrams are model elements that represent common object-oriented concepts such as classes, objects, and messages, and the relationships among these concepts including association, dependency, and generalization.

General mechanisms. General mechanisms provide extra comments, information, or semantics about a model element. They also provide extension mechanisms to adapt or extend the UML to a specific method/process, organization, or user.


Figure 4. A Modeling Tool: Rational Rose

3.2.2 Computational Grids Model

The software infrastructure of the Grid will be an extremely complex software system. The aim we use UML to make a model of the Grid is not to really analyze, design, and implement the Grid. Also what is given below is not a precise model for the system. We only want to give a high-level introduction of what functions the Grid must have for the users to access the computing capabilities.

Since the model is very coarse and high-level, we have to use UML in a little different way. In Figure 5, use case view of the system is given with several typical dynamic processes described by sequence diagrams or collaboration diagrams. Also several class diagrams are shown in logical view of the system model in Figure 5. But the class elements are not really classes in the program but the models of high-level modules in the Grid. The operations of the classes are very complex functions that must be implemented by the processes among many subsystems.

Through this simplified model of the Grid, much more details on the Grid functions and their relationships are described. Many modules of the Grid have not been implemented successfully. New software technologies are needed to overcome the challenges in the Grid development.


Use Case Diagram: Use Case View / Grid

There are 6 Actors in the grid.

End user: Most grid users, like most users of computers or networks today, will not write programs. Instead, they will use grid-enabled applications that make use of grid resources and services.

Application developer: This class of users comprises those who construct grid-enabled applications and components.

Tool developer: They are the developers of the tools, compilers, libraries, and so on that implement the programming models and services used by application developers.

Grid developer: A very small group of grid developers are responsible for implementing the basic services required to construct a grid.

Resource owner: They are not the true user of the grid. They provide computing resources like supercomputers and networks to the grid and get paid from the grid.

System administrator: They must manage the infrastructure on which computational grid operate.

Also there are 14 main Use Cases in the system.

Run application is the most important Use Case for end users to access the computing capbilities of the grid. It uses 3 main Use Cases. In the Use Case of Configure, the end user can select a registered application, resources that the user wish to use and scheduling strategy (for example, minimal cost, minimal response time, or maxiumal throughput). Then they construct a Task with these information. In Preview, the user can get the visual performance results which are produced by the cooperation of services like performance scheduler, analysis, measurement, resource management and so on. The user can preview the application execution over again with different configuration and at last submit a satisfactory one. During the running of the application, the user can also get related dynamic information and even steering the execution through dynamic modification of the application configuration. After finishing running the application, the user can get an entire report with information of resource usage, time consuming and finance.

Other Use Cases include that the different user must manage the related information, the system administrator must provide maintenance of the grid, and so on.

Preview

Submit

Maintenance

Manage tool Develop tool

Develop service

Manage resource informationSystem

administrator

Tool developer

Grid developer

Resource owner

Manage application

Ask for help

Manage personal infomation End user

Application developer

Run application<<uses>>

<<uses>>Develop application

<<uses>>

Configure

<<uses>>


: End user : User Information

Window : End User Info : Information

Management : Accounting : Resource

Management : Security

4: submitUserInfo_Clicked( )

5: saveUserInfo( )

1: fi llBasicInfo( )

2: registerApp( )

3: registerResource( )

6: userinfoCheck(User Information)

7: save( )

8: payToAppDevlp(User Information, Application Info)

9: registerUserToResc(User Information, Resource Info)

10: payToRescOwnr(User Information, Resource Info)

11: submitUserInfoReport( )

Sequence Diagram: Manage personal infomation / Manage end user infomation

Each kind of user can register, update or cancel their personal information. This scenario is for an end user to register the grid. Many services in the grid are used, such as Security, Information Management, Accounting, and Resource Management.

: End user : Application

Execution Window : Task : Assurance

1: selectApp( )

2: selectResource( )

3: selectStrategy( )

5: Task(appinfo, resource, strategy, userinfo)

4: configTask_Clicked( )

7: configTaskReport( )

6: assureAppResc(Task)

Sequence Diagram: Conf igure / Conf igure application

This is the scenario for end user to pre-conf igure the application that the user w ant to run on the grid. Beside the application itself , the user must select related resources and execution strategy to construct a Task. After the system assures that the Task can be implemented, it returns the configuration report.


: End user

: Application Execution Window

: Performance Scheduler

: Performance Visualization

: Measurement

: Performance Analysis

: Resource Management

Collaboration Diagram: Preview / Preview execution of application

This is scenario for an end user to preview the execution of the application after configuring it. This can happen many times before the user gets the sacrifatory preview result.

1: previewApp_Clicked( )

2: previewApp( )

8: getStaticInfo( )

4: getResourcePolicy(rescname)

3: getAnalysisResult( )

6: visuSchedApp( )

5: getNowSysInfo( )

7: getDynamicInfo( )

: End user

: Application Execution Window

: Performance Visualization

: Execution Monitoring

: Resource Allocation

: Security

: Accounting

: Performance Scheduler

: Execution Steering

: Measurement

Collaboration Diagram: Submit / Submit execution of application

This scenario is for an end user to submit the application to the grid. It is the most important and complex process in the grid. During the execution, the user can get dynamic performance visual displays and result report including resource usage, time consuming and finance infomation. Also the user can steer the execution of the application by rescheduling and checkpoint technology.

1: submitApp_Clicked( )

2: exeTask( )8: rescheduleApp( )

11: payToRescOwnr(User Information, Resource Info)

7: getExeReport( )

6: visuExeApp( )

5: getNowAppInfo(Task)

3: monExeApp( )

4: rescAllocCheck( )

9: steerExeApp( )10: exeCheckPointTask( )

Application Package

Tool Package

Service Package

GUI PackageUser Package

Resource Package

Class Diagram: Logical View / Grid

This diagram shows a layered structure of the software infrasturcture of the grid.

Usar Package contains the classes related to the user information. There is a meta-class name User Information, from which different kinds of user classes can be inherited. User Information also associates with classes of application information, tool information and resource information from other packages.

GUI Package contains the components of the graphic user interface of the system. User can access the system service only though this GUI.

Application Package contains descriptions of different kinds of computing application. They are used by the end users though the GUI.

In Tool Package, different programming tools of the grid, such as library, compiler, and programming language, are inherited from Tool Info class.

Many necessary services for the grid are contained in the Service Package, including scheduler, visualization, monitoring, steering, security, accounting, and so on.

User Informationuseridusernamepasswordnameaddressemailtelephoneaccount

saveUserInfo()readUserInfo()delUserInfo()

App Developer Infoapplicationtoolresource

Tool Developer Infotoolresource

Resource Owner Inforesource

System Admin. Info

Grid Developer Info

Application Info(from Application Package)

Tool Info(f rom Tool Package)

End User Infoapplicationresource

<<has>>

Resource Info(from Resource Package)

<<has>>

<<has>>

<<has>>

<<has>>

<<has>>

<<has>>

Class Diagram: User Package / Main

This diagram describes the relationships among the user information related classes.


Figure 5 Computational Grids Model

Application Execution Windowtask : Taskuserinfo : User Information

selectApp()selectResource()selectStrategy()configTask_Clicked()configTaskReport()previewApp_Clicked()getDynamicInfo()getStaticInfo()submitApp_Clicked()getExeReport()

Maintenance Window

Grid Main Window

User Information Window

fillBasicInfo()registerApp()registerTool()registerResource()submitUserInfo_Clicked()submitUserInfoReport()

Application Development Window

Tool Development Window

Service Development Window

Class Diagram: GUI Package / Main

This diagram contains the main GUI windows used in the system.

Compiler

Tool Infonamedescriptionplatformdeveloper

getToolInfo()setToolInfo()

Library

Language

Application Info(from Application Package)

Class Diagram: Tool Package / Main

Tools are used to develop grid-enabled applications. Tool information are maintained by the tool developers. Tools integreted basic services in the grid, which can be compiled to the applications. Then when applications run on the grid, services can be called to fulfil given task.

Resource InfonametypeaddressprocessormemorydiskOSpolicy

getRescInfo()setRescInfo()

Class Diagram: Resource Package / Main

Different kinds of resoures are needed in the grid, mainly supercomputers. Each resource has its own use policy. Complex resource management and accounting service are used to manage to pay for the resource owner. This is one of the challengers in developing the grid.

Security

userinfoCheck()rescAllocCheck()

Accounting

payToAppDevlp()payToToolDevlp()payToRescOwnr()

Information Management

save()read()delete()

Performance Schedulertask : Task

previewApp()rescheduleApp()

Resource Allocationschedtask

exeTask()exeCheckPointTask()

Performance Analysisschedtask : Scheduled Task

getAnalysisResult()

Measurement

getNowSysInfo()getNowAppInfo()

Performance Visualizationschedtask : Scheduled Task

visuSchedApp()visuExeApp()

Resource Management

registerUserToResc()getResourcePolicy()

Assurance

assureAppResc()

Execution Monitoring

monExeApp()

Execution Steering

steerExeApp()

Class Diagram: Service Package / Main

These services developed by the grid developer are the kernel of the grid. They are much more complex for the supporting of the parallel and distributed computing.


3.3 What challenges has the Grid met?

In the preceding sections, we outlined what the Grid is expected to look like. However, there are still many challenges to be overcome before the Grid can be used as easily and flexibly as described in Figure 5. In [Foster1998] a good summary of the nature of these challenges was given. Some of them are related to the software infrastructure and included in the list below.

Software Architecture. The software systems that support the Grid applications must satisfy a variety of potentially conflicting requirements. A need for broad deployment implies that these systems must be simple and place minimal demands on local sites. At the same time, the need to achieve a wide variety of complex, performance-sensitive applications implies that these systems must provide a range of potentially sophisticated services. Other complicating factors include the need for scalability and evolution to future systems and services. It seems likely that new approaches to software architecture will be needed to meet these requirements.

Software Engineering. Many current software modules towards the Grid are developing independently. Techniques for the construction and composition of grid-enabled software components will be important. This needs the new achievements in the field of software engineering, for example, component-based software engineering [Brown1998]. Another challenge lies in the research of software engineering for parallel and distributed application [Astley1998]. Mature technique is needed for developing complex grid-enabled application.

Integration. Many current works must be highly integrated to realize the software infrastructure of the Grid. Integration can be achieved in different levels including information integration, function integration, and application integration. The result of the integration can exceed that of the simple sum of individual information, functions or applications. For example, in traditional application development, once the program is compiled to executable application, the rich information in the source code cannot be used any more, which is very important to the performance analysis. Integrating compiler with performance analysis to achieve performance-driven application development would be great helpful. Besides static integration, more complex support of dynamic integration of new applications, tools and services is also required in the Grid.

User Interface. The different users need friendly user interface to access the services provided by the Grid. Nowadays web-based interface has been applied widely but can provide limited data formats. The grid applications need frequent interaction with the users. Different kinds of high-level requirements are sent to the Grid via the user interface. This kind of tasks can be so complex that user can not spell out each action for the computer explicitly. Traditional Direct Manipulation Interface (DMI) has limitations as tasks grow in scale or complexity. Research on Intelligent User Interface (IUI) aims to solve these problems by combining the expression of user intention through direct manipulation with the notion of an indirect management style of interaction. Many of the actions now performed by users could be delegated to the flexibility and intelligence of the user interface and users could be allowed to give general guidelines and forget about the details.

Application Development. We have mentioned that five kinds of high performance computing applications could be enabled by the Grid. What we can’t


imagine are the new ways to use the Grid. Research is required to explore the bounds of what is possible. Can we imagine grid-enabled games in future?

Programming Models and Tools. The Grid environment will require a rethinking of existing programming models. Novel models should be more suitable for the specific characteristics of grid applications and environments. New techniques are required for expressing advanced algorithms, for mapping those algorithms onto complex Grid architectures, for translating user performance requirements into system resource requirements, and for adapting to changes in underlying system structure and state. Another significant challenge is to provide tools that allow programmers to understand and explain program behavior and performance.

Algorithms and Problem-Solving Methods. Grid environments differ substantially from conventional uniprocessor and parallel computing systems in their performance, cost, reliability, and security characteristics. These new characteristics will motivate the development of new classes of problem-solving methods and algorithms, for example, for latency-tolerant, fault-tolerant, resource management and allocation, performance scheduling.

Instrumentation. A lot of information must be collected in gird environment, such as processor workload, network weather, states of executing applications, and user interests. The techniques of measurement and instrumentation are the basis of performance analysis and scheduling, execution monitoring and steering. Some challenges arise from the new characteristics of the Grid environment. For example, a serious problem that must be solved is how to provide the required performance data and still ensure security of the hosts and applications. Another difficult instrumentation question for the Grid is how we can know whether a performance behavior was due to the application or to transients in networks or computational resources. In current parallel system, it is already difficult to measure the performance of an application that is competing with other applications for processor or communication resources.

Performance Analysis. Performance analysis is of critical importance both in application development and application execution. Precise performance analysis needs different data sources including performance model of the application, workload of the processors and dynamic information on network traffic. The challenge in highly dynamic grid environments is that neither available resources nor adaptive application behavior may be reproducible. More efficient and practical method should integrate performance measurement with real-time performance visualization and adaptive control of application behavior and resource policies. Then this approach for performance analysis would allow interactive steering of applications.

Execution Monitoring and Steering. When a long-term application is running on the Grid, the end user may require knowing about the progress the application is making. This kind of information can be provided by the execution monitoring service of the Grid and displayed to the user via performance visualization functions. Further requirement like application steering would be much more complex to meet. To achieve this performance analysis and scheduling service should also be integrated and special process checkpoint and migration technique as described in [Litzkow1997] is needed.


Security. Grid applications frequently involve many entities, impose stringent performance requirements, and involve complex activities such as collective operations, the downloading of code, and group communications. All of these introduce challenging security problems. Different mechanisms are needed to provide guarantees to users that services behave as advertised.

Accounting. Different computing resources in the Grid have different policies. It seems that the user should have an account on each node in the system where his or her application will run. Distributed accounting is one of the future research directions.

4 Using Software Agents in Computational Grids

In the last two sections we give the introduction to both Software Agents and Computational Grids. In this section the subject of using software agents in the Grid is discussed. A survey of agent applications in the Grid is described in details and several features are summarized on the characteristics of these applications. Future challenges are also predicted to give a blueprint of using software agents in the Grid.

4.1 What have been used?

In the current grid-oriented software systems agent technology has been used in different ways. However, these applications in the research on high performance computing are not noticed by the agent researchers. Six main projects are listed in Table 4. Several features can be summarized from the characteristics of these applications.

(1). Agents are used as a part of the project to fulfil given tasks. Agent functions mainly concentrate on system monitoring, resource management, and performance scheduling. These are the most typical problem that can be solved using agent techniques, which can be found in other agent applications, such as on manufacturing and business process management.

(2). Agents are either IAs or SAs. The key techniques for the agents to achieve their autonomy are simpler than those in Table 2. Though using software agents in the Grid is greatly potential with the development of the Grid software infrastructure, it is just a start now.

(3). IAs as in AppLeS, DPSS and GARA use related algorithms or reasoning to achieve their intelligence. Agents in Condor are some background processes called daemons, which can communicate with each other. SAs in DPSS, NetLogger and NetSolve are MAS with centred structure. Though they are important grid-oriented software systems that can perform complex tasks, they are simple applications from the perspective of software agents.

(4). Agents for event logging management in the NetLogger project are developed using Java Agent Toolkit (JATLite) from Stanford and KQML communication language. In DPSS agents are also written in Java and use RMI-based communication with other agents. However, many agent techniques have not been applied in these applications.


Project Name (Agent Type)

Project Background Agent Functions Agent Structure (only internal structure for IA and SIA)

Key Technology to Achieve Autonomy

AppLeS (IA) [Berman1996]

To achieve a performance-efficient implementation on a distributed heterogeneous system, the performance-seeking end-user or application developer must select a potentially efficient configuration of resources based on load and availability, evaluate the potential performance on such configurations based on their own performance criteria, and interact with the relevant resource management systems in order to implement the application.

Application-level scheduling (AppLeS) agents are developed to provide a mechanism for scheduling individual applications at machine speeds on production heterogeneous systems. AppLeS agents utilize a Network Weather Service (NWS) to monitor the varying performance of resources potentially usable by their applications. Each AppLeS uses static and dynamic application and system information to select viable resource configurations and evaluate their potential performance.

Each application will have its own AppLeS including a single active agent called the Coordinator and four sub-systems: Resource Selector, Planner, Performance Estimator, and Actuator. There are three general source of information: Network Weather Service, User Interface, and Performance Models.

Scheduling policy; application-specific performance prediction models.

Condor (SA) [Condor1999]

Condor is a High Throughput Computing environment that can manage very large collections of distributively owned workstations. Its development has been motivated by the ever-increasing need of scientists and engineers to harness the capacity of such collections. The environment is based on a novel layered architecture that enables it to provide a powerful and flexible suite of Resource Management services to sequential and parallel applications.

Certain Condor programs called the Condor "daemons" must run all the time to monitor the status of the individual computers in the cluster.

These daemons include condor_master, condor_startd, condor_starter, condor_schedd, condor_shadow, condor_collector, condor_negotiator, condor_kbdd, condor_ckpt_server.

Communications via ClassAds, which contain all the information about the state of the daemons, theresources they represent or resource requests in the pool.

DPSS (Hybrid Agent of SA and IA) [Brooks1997]

The DPSS is a data block server, which provides high-performance data handling and architecture for building high-performance storage systems from low-cost commodity hardware components. This technology has been quite successful in providing an economical, high-performance, widely distributed, and highly scalable architecture for caching large amounts of data that can potentially be used by many different users.

Agents provide DPSS clients with different views and monitoring granularities of the system's current and past state. Agents can keep track of all components within the system and restart any component that has gone down, including any DPSS server or one of the other agents. Agents can also monitor the load of each DPSS block server.

A broker/agents architecture: agents are processes that monitors the state of the system; broker agent (or broker) is an agent that manages the information, filters information for clients, or perform some action on behalf of a client.Agents model their environment using an extensible set of Facts

Agents use RMI-based communication with other agents, not with clients.Reasoning: Facts -> ontology -> Task; Task -> Operators -> Plan.


and act on their environment using a set of Tasks.

GARA (IA) [Foster1999]

The Globus Architecture for Reservation and Allocation (GARA) builds on techniques and concepts developed in the Globus toolkit for the provision of computational QoS via the co-allocation of computers, generalizing and extending them to support end-to-end discovery, reservation, allocation, and management of heterogeneous ensembles of computers, networks, storage systems, and other resources under independent local control.

A co-reservation agent is responsible for discovering a collection of resources that can satisfy application end-to-end QoS requirements (a resource set); however, rather than allocating those resources, it simply reserves them. The co-allocation agent has the task of allocating a resource set, given a reservation handle generated by a co-reservation agent.

A co-reservation agent and a co-allocation agent.

Search and deadlock strategies.

NetLogger (SA) [Tierney1998]

NetLogger is a methodology that enables the real-time diagnosis of performance problems in complex high-performance distributed systems. NetLogger includes tools for generating precision event logs that can be used to provide detailed end-to-end application and system level monitoring, and tools for visualizing log data to view the state of the distributed system in real time.

An agent is an autonomous, adaptable entity that is capable of monitoring and managing distributed system components. Agents provide the standard interface for monitoring CPU load, interrupt rate, TCP retransmissions, TCP window size, etc. Agents can also independently perform various administrative tasks, such as restarting servers or monitoring processes. Collectively, a distributed system’s agents maintain a continually updated view of the global state of the system.

The broker controls agents on each host, telling them which tasks to perform. The broker also collects event logs from each agent and merges them together, sorted by time, for use by the event log visualization tools.

NetLogger’s agents are written in Java, use the Java Agent Toolkit (JATLite) from Stanford, and use the KQML communication language.

NetSolve (SA) [Casanova1998]

NetSolve is a client-server system enables users to solve complex scientific problem remotely. The system allows users to access both hardware and software computational resources distributed across a network. NetSolve searches for computational resources on a network, chooses the best one available, and using retry for fault-tolerance solves a problem, and returns the answers to the user.

The NetSolve agent operates both as a database and as a resource broker. The agent keeps track of information about all the servers in its resource pool, including their availability, load, network accessibility, and the range of computational tasks that they can perform. The agent then selects a server to perform the task, and server responds to the client’s request.

There can be multiple instances of the NetSolve agent on the network, and different clients can contact different agents depending on their locations.

The agents can exchange information about their different servers and allow access from any client to any server, if desirable.

Table 4 Agent Applications in Computational Grids


4.2 What can be used in future?

The software infrastructure of the Grid is open, complex software system. Agent technology is one of the ways to overcome the challenges in the grid development. Agent can not do everything. It is also dangerous to define something like Agent-Based Computational Grids by analogy. However, agents are sure to play important roles in implementation of the grid software infrastructure. Future research directions are listed below to give a blueprint of using software agents in the Grid.

Agile Infrastructure. The concept of agility arises from the research on manufacturing. Agile manufacturing is important for the factories to give quick response to the quickly changing market requirements. For example, the enterprise must provide one and one of one million products at the same low cost. Flexible Manufacturing Systems (FMS) are basis to achieve this agility. The same situation is met in Computational Grids. The same software infrastructure must support different kinds of applications with different requirements of QoS. Distributed supercomputing applications should achieve high levels of performance across heterogeneous systems. On-demand applications are often driven by cost-performance concerns rather than absolute performance. In high-throughput computing, users measure the power of the system by the amount of work performed by the system in a fixed amount of time. In data-intensive applications, the complete process involves the movement and processing of many gigabytes of data. And collaborative applications are concerned primarily with enabling and enhancing human-to-human interactions, which depends on the availability of a grid infrastructure able to provide robust performance guarantees. As the Grid evolves, the range and sophistication of applications are expected to increase dramatically. The Grid must provide services to these different requirements with the same low cost. Agent technology can be used to achieve agility for software systems.

Agent-Aided Software Engineering. The complexity of software development has been out of the scope that the developer can control. The gaps between the requirements and the actual systems would be enhanced step by step through the analysis, design and implementation. Intelligent agents can be integrated into the software development tools and “watch” the development processing. When trends to away from the requirements are detected, the agents can give the developers warnings autonomously. Also the agents can be integrated into the final system and “watch” the user operations. If agents detect the differences between the user actual requirements and system functions, related information can be transferred back to the developers. Developers can update the software or give the user more advises on using the software according to different situation. Such kind of ideas has been implemented in the software like Netscape. The Grid applications are to meet much more complex user requirements. Agent-aided software engineering can be applied to development efficient grid-enabled applications.

Virtual High Performance Computing Laboratory. The idea of virtual organizations is not new [Goldman1995]. Developments in information technology capabilities, such as WWW and AI, have allowed the development of implementations of virtual organizations that exploit the capabilities of those technologies. In [O’Leary1997], virtual company, virtual laboratory, virtual classroom, virtual office system, and virtual manufacturing organization are mentioned. The use of agents, facilitators, and KQML, together with negotiated ontology, can provide a workable, reliable, and flexible base of systems used in


creating the platforms for virtual organizations. By analogy, developments in accessing computing capabilities, such as Computational Grids, will also allow the development of implementations of virtual organizations that exploit the capabilities of the Grid. Virtual high performance computing laboratory would be one of this kind of organizations. Agents can be used in the user interface to manage the information of all the components in the laboratory, such as applications, peoples, and resources and handle the user actions to operate on the Grid or cooperate with other users.

Agent Multi-function Integration. Many functions in the Grid can be implemented by MAS. For example, in DPSS system, agents are autonomous adaptable monitors, managers, information aggregates and filters. Multiple functions are integrated in one agent. This can decrease the complexity of the system. The more important is that information sharing can be implemented by integration. For example, the monitoring data is the key to diagnosis and performance scheduling. Dynamic function integration for agents are also important. That all functions are integrated in the agents statically will occupy too much system resources. Some functions may be not necessary to the system running all the time. Message-driven approach can be used to change agent functions dynamically for messages are the most active components after the agent has been started up.

Agent-Based Distributed System Management. In the DPSS, agent system can keep track of all components within the system. Also it can restart any component that has crashed, including one of the other agents, to achieve fault tolerance. This is a typical example of agent-based distributed system management. Distributed information management is another important aspect. In the Grid, this includes the information of users, applications, tools, services and resources as well as related dynamic information such as who are online, which applications are running, and how much the resources are being used.

Agent-Based Monitoring and Diagnosis. Monitoring and diagnosis techniques have been developed in many agent applications like EDEM, Guardian, SNMP in Table 2 and Netlogger in Table 4. Event-based monitoring techniques have been widely applied to construct a comprehensive view of the overall operations of all the elements in the system to determine exactly what is happening. The software infrastructure of the Grid will be extremely complex distributed software system. The developer must take trade-off between the efficiency and completeness. The complete monitoring of the whole Grid, especially the execution monitoring of the applications, will consume many system resources and only a small part of the monitoring data is useful to diagnosis and other Grid services. Research on the ways to achieve monitoring efficiency is essential to the implementation of Grid monitoring service. Diagnosis can be achieved on the basis of the monitoring data. It can learn from the normal states of the system and find or predict the problems that are or will be in the running system. The techniques of pattern recognition [Morrill1998] and data mining [Han1996] can be used to do fault detection or prediction. When many applications are running on the multi-processors at the same time, it will be difficult to distinguish where the problem is. Exist works often focus on special context, so new algorithms and tools should be developed to deal with this situation.

Agent-Aided Performance Modeling. Performance analysis, prediction and scheduling are important services in the Grid. To analysis the performance of the application, the related performance model must be provided by the developer, which is a static description of the application performance. For example, in the AppLeS


project, there are three general sources of information: Network Weather Service, User Interface, and Performance Models. One analysis method is supported by one format of performance model. Though there are many performance-modeling tools like POEMS [Deelman1998] and PACE [Nudd1999], development of the performance model would be not easy especially to those application developers who have no knowledge on performance evaluation of parallel and distributed applications. Agents with special purpose of performance modeling can be integrated into programming tools. They can retrieve information from the source code of the application and construct the performance model semi-autonomously.

Virtual Computational Grid. A virtual Computational Grid can assist the development of new grid applications. It can simulate a grid environment and be used on debugging and tuning of the new applications. Agents can be used to model different components in the Grid. Some agent-based simulation systems can be found in the context of manufacturing, such as AARIA and CSS in Table 2. New modeling and simulation approach is needed to construct virtual grid system.

5 Conclusions

This work gives a survey on using software agents in Computational Grid. The agent is a kind of developing software technology. The Grid is a new infrastructure to provide computing capabilities, which doesn’t exist yet. This work gives the summaries on both of the fields and focuses on building a bridge between them.

Using advanced agent technology is sure to 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.

References

[Ardissono1999] L. Ardissono, C. Barbero, A. Goy, G. Petrone. An Agent Architecture for Personalized Web Stores. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 182-189.

[Aridor1998] Y. Aridor, D. B. Lange. Agent Design Patterns: Elements of Agent Application Design. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 108-115.

[Astley1998] M. Astley and G. Agha. Modular Construction and Composition of Distributed Software Architectures. Proceedings of International Symposium on Software Engineering for Parallel and Distributed Systems, Kyoto, Japan, 1998, pp. 1-11.

[Atkins1996] D. E. Atkins, W. P. Birmingham, E. H. Durfee, E. J. Glover, T. Mullen, E. A. Rundensteiner, E. Soloway, J. M. Vidal, R. Wallace, and M. P. Wellman. Toward Inquiry-Based Education Through Interacting Software Agents. IEEE Computer, 29(5), 1996, pp. 69-76.

[Bayardo1997] R. J. Bayardo, W. Bohrer, R. Brice, A. Cichocki, J. Fowler, A. Helal, V. Kashyap, T. Ksiezyk, G. Martin, M. Nodine, M. Rashid, M. Rusinkiewicz, R. Shea, C. Unnikrishnan, A. Unruh, and D. Woelk. InfoSleuth: Agent-based Semantic Integration of Information in Open and Dynamic Environments.


Proceedings of the ACM SIGMOD International Conference on Management of Data, 1997, pp. 195-206.

[Berman1996] F. Berman, R. Wolski, S. Figueira, J. Schopf, and G. Shao. Application-Level Scheduling on Distributed Heterogeneous Networks. Proceedings of Supercomputing ’96, 1996.

[Bigus1998] J. P. Bigus, and J. Bigus. Constructing Intelligent Agents with Java: A Programmer’s Guide to Smarter Applications. Wiley Computer Publishing, 1998.

[Booch1999] G. Booch, I. Jacobson and J. Rumbaugh. The Unified Modeling Language User Guide. Addison-Wesley Object Technology Series, 1999.

[Boone1998] G. Boone. Concept Features in Re:Agent, an Intelligent Email Agent. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 141-148.

[Bradshaw1997] J. M. Bradshaw (ed.). Software Agents. The AAAI Press/The MIT Press, 1997.

[Brazier1999] F. M. T. Brazier, C. M. Jonker, J. Treur, and N. J. E. Wijngaards. Deliberate Evolution in Multi-Agent Systems (extended abstract). Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 356-357.

[Brooks1997] C. Brooks, B. Tierney, and W. Johnston. JAVA Agents for Distributed System Management. LBNL Report, 1997.

[Brown1998] A. W. Brown, and K. C. Wallnau. The Current State of CBSE. IEEE Software, 15(5), 1998, pp. 37-46.

[Casanova1998] H. Casanova, and J. Dongarra. Applying NetSolve’s Network-Enabled Server. IEEE Computational Science & Engineering, 5(3), 1998, pp. 57-67.

[Charlton1999] P. Charlton, Y. Arafa, and E. Mamdani. Development and Deployment of a Multi-agent System for Public Service Access. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 404-405.

[Chenh1996] H. Chen, A. Houston, J. Nunamaker, and J. Yen. Toward Intelligent Meeting Agents. IEEE Computer, 29(8), 1996, pp. 62-70.

[Chenl1998] L. Chen, and K. Sycara. WebMate : A Personal Agent for Browsing and Searching. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 132-139.

[Chenq1998] Q. Chen, P. Chundi, U. Dayal, and M. Hsu. Dynamic Software Agents for Business Intelligence Applications. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 453-454.

[Chorafas1998] D. N. Chorafas. Agent Technology Handbook. McGraw-Hill, 1998.

[Ciancarini1997] P. Ciancarini, R. Tolksdorf, F. Vitali, D. Rossi, and A. Knoche. Coordinating Multiagent Applications on the WWW: A Reference Architecture. IEEE Transactions on Software Engineering, 24(5), 1998, pp. 362-375.

[Cicalese1999] F. Cicalese, A. di Nola, and V. Loia. A Fuzzy Evolutionary Framework for Adaptive Agents. Proceedings of the 1999 ACM Symposium on Applied Computing, 1999, pp. 233-237.


[Clement1999] B. J. Clement, and E. H. Durfee. Top-Down Search for Coordinating the Hierarchical Plans of Multiple Agents. Proceedings of ACM 3 rd Annual Conference on Autonomous Agents, 1999, pp. 252-259.

[Collins1998] J. Collins, B. Youngdahl, S. Jamison, B. Mobasher, and M. Gini. A Market Architecture for Multi-Agent Contracting. Proceedings of ACM 2nd

Annual Conference on Autonomous Agents, 1998, pp. 285-292.

[Condor1999] Condor Team. Condor Version 6.1.7 Manual. University of Wisconsin–Madison, June 16, 1999.

[Corchado1997] J. M. Corchado, B. Lees, and N. Rees. A Multi-agent System “Test Bed” for Evaluating Autonomous Agents. Proceedings of ACM 1st Annual Conference on Autonomous Agents, 1997, pp. 386-393.

[Cost1999] R. S. Cost, T. Finin, Y. Labrou, X. Luan, Y. Peng, I. Soboroff. Agent Development with Jackal. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 358-359.

[Cremonini1999] M. Cremonini, A. Omicini, and F. Zambonelli. Modelling Network Topology and Mobile Agent Interaction: An Integrated Framework. Proceedings of the 1999 ACM Symposium on Applied Computing, 1999, pp. 410-412.

[Das1998] S. Das, A. Caglayan, and P. Gonsalves. Increasing Agent Autonomy in Dynamic Environments. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 309-316.

[Davison1998] R. G. Davison, J. J. Hardwicke, M. D. J. Cox. Applying the Agent Paradigm to Network Management. BT Technology Journal, 16(3), July 1998, pp. 86-93.

[Deelman1998] E. Deelman, A. Dube, A. Hoisie, Y. Luo, R. L. Oliver, D. Sundaram-Stukel, H. Wasserman, V. S. Adve, R. Bagrodia, J. C. Browne, E. Houstis, O. Lubeck, J. Rice, P. J. Teller, and M. K. Vernon. POEMS: End-to-end Performance Design of Large Parallel Adaptive Computational Systems. Proceedings of the ACM 1st International Workshop on Software and Performance, 1998, pp. 18-30.

[Doorenbos1997] R. B. Doorenbos, O. Etzioni, and D. S. Weld. A Scalable Comparison-Shopping Agent for the World-Wide Web. Proceedings of ACM 1st

Annual Conference on Autonomous Agents, 1997, pp. 39-48.

[Eriksson1998] H. Eriksson, and M. Penker. UML Toolkit. Wiley Computer Publishing, 1998.

[Falchuk1998] B. Falchuk, and A. Karmouch. Visual Modeling for Agent-Based Applications. IEEE Computer, 31(12), 1998, pp. 31-38.

[Fano1998] A. E. Fano. Shopper’s Eye: Using Location-based Filtering for a Shopping Agent in the Physical World. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 416-421.

[Finin1994] T. Finin, R. Fritzson, D. McKay, and R. McEntire. KQML as an Agent Communication Language. Proceedings of the 3rd International Conference on Information and Knowledge Management, 1994, pp. 456-463.


[Foner1997] L. N. Foner. Entertaining Agents: A Sociological Case Study. Proceedings of ACM 1st Annual Conference on Autonomous Agents, 1997, pp. 122-129.

[Forbus1998] K. D. Forbus, and S. E. Kuehne. RoboTA (poster): An Agent Colony Architecture for Supporting Education. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 455-456.

[Foster1998] I. Foster, and C. Kesselman. The GRID: Blueprint for a New Computing Infrastructure. Morgan-Kaufmann, July 1998.

[Foster1999] I. Foster, C. Kesselman, C. Lee, R. Lindell, K. Nahrstedt, and A. Roy. A Distributed Resource Management Architecture that Supports Advance Reservations and Co-Allocation. International Workshop on Quality of Service, 1999.

[Franklin1996] S. Franklin, A. Graesser. Is it an agent, or just a program? Proceedings 3rd International Workshop on Agent Theories, Architectures and Languages, Budapest, Hungary, 1996, pp. 193-206.

[Friedman1997] B. Friedman, and H. Nissenbaum. Software Agents and User Autonomy. Proceedings of ACM 1st Annual Conference on Autonomous Agents, 1997, pp. 466-469.

[Gilbert1995] N. Gilbert, and R. Conte (eds). Artificial Societies. UCL Press, London, 1995.

[Goldman1995] S. Goldman, R. Nagel, and K. Preiss. Agile Competitors and Visual Organizations. Van Nostrand Reinhold, New York, 1995.

[Gustafson1998] T. Gustafson, J. B. Schafer, and J. Konstan. Agents in their Midst: Evaluating User Adaptation to Agent-Assisted Interfaces. Proceedings of the 1998 International Conference on Intelligent User Interfaces, 1998, pp. 163-170.

[Gustavsson1999] R. Gustavsson. Agents with Power. Communications of the ACM, 42(3), 1999, pp. 41-47.

[Han1996] J. Han. Data Mining Techniques. Proceedings of the 1996 ACM SIGMOD International Conference on Management of Data, 1996, p545.

[Hayden1999] S. C. Hayden, C. Carrick, and Q. Yang. A Catalog of Agent Coordination Patterns. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 412-413.

[Heckman1998] C. Heckman, and J. O. Wobbrock. Liability for Autonomous Agent Design. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 392-399.

[Heckman1999] C. Heckman, and A. Roetter. Designing Government Agents for Constitutional Compliance. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 299-305.

[Hofmann1998] M. O. Hofmann, A. McGovern and K. R. Whitebread. Mobile Agents on the Digital Battlefield. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 219-225.

[Holmback1999] H. Holmback, M. Greaves, J. Bradshaw. A Pragmatic Principle for Agent Communication. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 368-369.


[Hood1998] C. S. Hood, and C. Ji. Intelligent Agents for Proactive Fault Detection. IEEE Internet Computing, 2(3), 1998, pp.65-72.

[Jacobson1999] I. Jacobson, G. Booch and J. Rumbaugh. The Unified Software Development Process. Addison-Wesley Object Technology Series, 1999.

[Jain1999] A. K. Jain, M. Aparicio IV, and M. P. Singh. Agents for Process Coherence in Virtual Enterprises. Communications of the ACM, 42(3), 1999, pp. 62-69.

[Jennings1998a] N. R. Jennings and M. J. Wooldridge (eds). Agent Technology: Foundations, Applications, and Markets. Springer-Verlag, 1998.

[Jennings1998b] N. R. Jennings, T. J. Norman, and P. Faratin. ADEPT: An Agent-based Approach to Business Process Management. ACM SIGMOD Record, 27(4), 1998, pp. 32-39.

[Jennings1999] N. R. Jennings, P. Faratin, T. J. Norman, P. O'Brien and B. Odgers. Autonomous Agents for Business Process Management. International Journal of Applied Artificial Intelligence (to appear), 1999.

[Kaminka1998] G. Kaminka, and M. Tambe. A Synergy of Agent Components: Social Comparison for Failure Detection. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 459-460.

[Kaminka1999] G. Kaminka and M. Tambe. I’m OK, You’re OK, We’re OK: Experiments in Distributed and Centralized Socially Attentive Monitoring. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 213-220.

[Karjoth1997] G. Karjoth, D. B. Lange, and M. Oshima. A Security Model for Aglets. IEEE Internet Computing, 1(4), 1997, pp. 68-77.

[Karnik1998] N. M. Karnik, and A. R. Tripathi. Design Issues in Mobile Agent Programming Systems. IEEE Concurrency, 6(3), 1998, pp. 52-61.

[Kendall1998] E. A. Kendall, P. V. M. Krishna, C. V. Pathak, C. B. Suresh. Patterns of Intelligent and Mobile Agents. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 92-99.

[Kiniry1997] J. Kiniry, and D. Zimmerman. A Hands-on Look at Java Mobile Agents. IEEE Internet Computing, 1(4), 1997, pp. 21-30.

[Klein1999] M. Klein, and C. Dellarocas. Exception Handling in Agent Systems. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 62-68.

[Kotz1997] D. Kotz, R. Gray, S. Nog, D. Rus, S. Chawla, and G. Cybenko. Agent TCL: Targeting the Needs of Mobile Computers. IEEE Internet Computing, 1(4), 1997, pp. 58-67.

[Larsson1998] J. E. Larsson, and B. Hayes-Roth. Guardian: An Intelligent Autonomous Agent for Medical Monitoring and Diagnosis. IEEE Intelligent Systems & Their Applications, 13(1), 1998, pp.58-64.

[Lester1997] J. C. Lester, S. A. Converse, S. E. Kahler, S. ToddBarlow, B. A. Stone, and R. S. Bhogal. The Persona Effect Affective Impact of Animated Pedagogical Agents. CHI '97 Conference Proceedings on Human Factors in Computing Systems, 1997, pp. 359-366.


[Lieberman1997] H. Lieberman. Autonomous Interface Agents. CHI '97 Conference Proceedings on Human Factors in Computing Systems, 1997, pp. 67-74.

[Lieberman1998] H. Lieberman. Integrating User Interface Agents with Conventional Applications. Proceedings of the 1998 International Conference on Intelligent User Interfaces, 1998, pp. 39-46.

[Lieberman1999] H. Lieberman, B. A. Nardi, and D. Wright. Training Agents to Recognize Text by Example. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 116-122.

[Lin1994] G. Y. Lin, and J. J. Solberg. An Agent-based Flexible Routing Manufacturing Control Simulation System. Proceedings of the1994 Conference on Winter Simulation, 1994, pp. 970-977.

[Litzkow1997] M. Litzkow, T. Tannenbaum, J. Basney, and M. Livny. Checkpoint and Migration of UNIX Processes in the Condor Distributed Processing System. Technical Report #1346, University of Wisconsin-Madison Computer Sciences, April 1997.

[Liu1998] J. Liu, and H. Qin. Behavioral Self-organization in Lifelike Agents. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 254-260.

[Maes1995] P. Maes. Artificial Life Meets Entertainment: Lifelike Autonomous Agents. Communications of the ACM, 38(11), 1995, pp. 108-114.

[Malone1994] T. W. Malone, K. Crowston. The Interdisciplinary Study of Coordination. ACM Computing Survey, 26(1), 1994, pp. 87-119.

[Martin1998] J. Martin, and J. J. Odell. Object-Oriented Method: A Foundation (UML Edition). Prentice Hall, 1998.

[Maulsby1997] D. Maulsby, and I. H. Witten. Teaching Agents to Learn: From User Study to Implementation. IEEE Computer, 30(11), 1997, pp. 36-44.

[Meer1998] H. de Meer, J. Richter, A. Puliafito, and O. Tomarchio. Tunnel Agents for Enhanced Internet QoS. IEEE Concurrency, 6(2), 1998, pp. 30-39.

[Métayer1998] D. L. Métayer. Describing Software Architecture Styles Using Graph Grammars. IEEE Transactions on Software Engineering, 24(7), 1998, pp. 521-533.

[Moran1997] D. B. Moran, A. J. Cheyer, L. E. Julia, D. L. Martin, and S. Park. Proceedings of the 1997 International Conference on Intelligent User Interfaces, 1997, pp. 61-68.

[Moreira1997] D. de A. Moreira, and L. T. Walczowski. AGENTS: A Distributed Client-server System for Leaf Cell Generation. ACM Transactions on Design Automation of Electronic Systems, 2(1), 1997, pp. 42-61.

[Morrill1998] J. P. Morrill. Distributed Recognition of Patterns in Time Series Data. Communications of the ACM, 41(5), 1998, pp. 45 - 51.

[Moukas1998] A. Moukas, and P. Maes. Amalthaea: An Evolving Multi-Agent Information Filtering and Discovery System for the WWW. Journal of Autonomous Agents and Multi-Agent Systems, 1(1), 1998, pp. 59-88.


[Ndumu1999] D. T. Ndumu, H. S. Nwana, L. C. Lee, J. C. Collis. Visualising and Debugging Distributed Multi-agent Systems. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 326-333.

[Nudd1999] G. R. Nudd, D. J. Kerbyson, E. Papaefstathiou, S. C. Perry, J. S. Harper, and D. V. Wilcox. PACE – A Toolset for the Performance Prediction of Parallel and Distributed Systems. High Performance Systems (to appear), Sage Science Press, 1999.

[Nwana1996] H. S. Nwana and N. Azarmi (eds). Software Agents & Soft Computing: Concepts and Applications. Springer-Verlag as Lecture Notes in Artificial Intelligence Volume 1198, 1997.

[Nwana1997] H. S. Nwana. Intelligent Software Agents on the Internet. http://www.hermans.org/agents/index.html.

[Nwana1998] H. S.Nwana, J. Rosenschein, T. Sandholm, C. Sierra, P. Maes, and R. Guttmann. Agent-Mediated Electronic Commerce: Issues, Challenges and Some Viewpoints. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 189-196.

[O’Leary1997] D. E. O’Leary, D. Kuokka, and R. Plant. Artificial Intelligence and Virtual Organizations. Communications of the ACM, 40(1), 1997, pp. 52-59.

[Park1999] S. Park, E. H. Dutfee, W. P. Birmingham. An Adaptive Agent Bidding Strategy Based on Stochastic Modeling. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 147-153.

[Parunak1997] H. V. D. Parunak, J. Sauter, and S. Clark. Toward the Specification and Design of Industrial Synthetic Ecosystems. Proceedings of 14 th International Workshop on Agent Theories, Architectures, and Languages, 1997.

[Parunak1998] H. V. D. Parunak. Practical and Industrial Applications of DAI. In G. Weiss (ed.), Introduction to Distributed Artificial Intelligence, MIT Press (to appear), 1998.

[Parunak1999] H. V. D. Parunak. The AARIA Agent Architecture: From Manufacturing Requirements to Agent-Based System Design. Integrated Computer-Aided Engineering (to appear), 1999.

[Pell1997] B. Pell, D. E. Bernard, S. A. Chien, E. Gat, N. Muscettola, P. P. Nayak, M. D. Wagner, and B. C. Williams. An Autonomous Spacecraft Agent Prototype. Proceedings of ACM 1st Annual Conference on Autonomous Agents, 1997, pp. 253-261.

[Peters1998] R. Peters, A. Graeff, and C. Paul. Integrating Agents into Virtual Worlds. Proceedings of the Workshop on New Paradigms in Information Visualization and Manipulation, 1998, pp. 69-74.

[Pfitzmann1997] A. Pfitzmann, B. Pfitzmann, M. Schunter and M. Waidner. Trusting Mobile User Devices and Security Modules. IEEE Computer, 30(2), 1997, pp. 61-68.

[Preist1999] C. Preist. Commodity Trading Using an Agent-Based Iterated Double Auction. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 131-138.

http://www.hermans.org/agents/index.html


[Qiu1999] Z. Qiu, M. Tamble, and H. Jung. Towards Flexible Negotiation in Teamwork. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 400-401.

[Quatrani1998] T. Quatrani. Visual Modeling with Rational Rose and UML. Addison-Wesley Object Technology Series, 1998.

[Rickel1998] J. Rickel and W. L. Johnson. STEVE: A Pedagogical Agent for Virtual Reality. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 332-333.

[Rist1997] T. Rist, E. André, and J. Müller. Adding Animated Presentation Agents to the Interface. Proceedings of the 1997 International Conference on Intelligent User Interfaces, 1997, pp. 79-86.

[Rodriguez-Aguilar1998] J. A. Rodriguez-Aguilar, F. J. Martin, P. Noriega, P. Garcia, and C. Sierra. Competitive Scenarios for Heterogeneous Trading Agents. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 293-300.

[Rogers1999] S. Rogers, C. N. Fiechter, P. Langley. An Adaptive Interactive Agent for Route Advice. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 198-205.

[Rumbaugh1999] J. Rumbaugh, I. Jacobson, and G. Booch. The Unified Modeling Language Reference Manual. Addison-Wesley Object Technology Series, 1999.

[Sahai1998] A. Sahai, and C. Morin. Mobile Agents for Enabling Mobile User Aware Applications. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 205-211.

[Sarwar1998] B. M. Sarwar, J. A. Konstan, A. Borchers, J. Herlocker, B. Miller, and J. Riedl. Using Filtering Agents to Improve Prediction Quality in the GroupLens Research Collaborative Filtering System. Proceedings of the ACM 1998 Conference on Computer Supported Cooperative Work, 1998, pp. 345-354.

[Sen1997] S. Sen. Developing an Automated Distributed Meeting Scheduler. IEEE Expert/Intelligent Systems & Their Applications, 12(4), 1997, pp. 41-45.

[Shaw1999] E. Shaw, W. L. Johnson, and R. Ganeshan. Pedagogical Agents on the Web. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 283-290.

[Singh1998] M. P. Singh. Agent Communication Languages: Rethinking the Principles. IEEE Computer, 31(12), 1998, pp. 40-47.

[Sloman1999] A. Sloman, and B. Logan. Building Cognitively Rich Agents Using the SIM_Agent Toolkit. Communications of the ACM, 42(3), 1999, pp. 71-77.

[Strippgen1999] S. Strippgen, and K. Peters. 'The other way round!': Collaborative Communication with Agents. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 108-115.

[Tarumi1997] H. Tarumi, K. Kida, Y. Ishiguro, K. Yoshifu, and T. Asakura. WorkWeb System — Multi-Workflow Management with a Multi-Agent System. Proceedings of the International ACM SIGGROUP Conference on Supporting Group Work: the Integration Challenge, 1997, pp. 299-308.


[Tesauro1998] G. J. Tesauro, and J. O. Kephart. Foresight-Based Pricing Algorithms in an Economy of Software Agents. Proceedings of 1st International Conference on Information and Computation Economies, 1998, pp. 37-44.

[Tierney1998] B. Tierney, W. Johnston, B. Crowley, G. Hoo, C. Brooks, and D. Gunter. The NetLogger Methodology for High Performance Distributed Systems Performance Analysis. Proceeding of IEEE High Performance Distributed Computing Conference, July 1998.

[Virdhagriswaran1995] S. Virdhagriswaran, D. Osisek, and P. O’Connor. Standardizing Agent Technology. StandardView, 3(3), 1995, pp. 96-101.

[Vulkan1998] N. Vulkan, and N. R. Jennings. Efficient Mechanisms for the Supply of Services in Multi-Agent Environments. Proceedings of 1st International Conference on Information and Computation Economies, 1998, pp.1-10.

[Wang1997] H. Wang, and C. Wang. Intelligent Agents in the Nuclear Industry. IEEE Computer, 30(11), 1997, pp. 28-34.

[Washington1998] R. Washington. Markov Tracking for Agent Coordination. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 70-77.

[Wong1999] D. Wong, N. Paciorek, and D. More. Java-based Mobile Agents. Communications of the ACM, 42(3), 1999, pp. 92-102.

[Wooldridge1998] M. Wooldridge, and N. R. Jennings. Pitfalls of Agent-Oriented Development. Proceedings of ACM 2nd Annual Conference on Autonomous Agents, 1998, pp. 385-391.

[Wooldridge1999] M. Wooldridge, N. R. Jennings, and D. Kinnyt. A Methodology for Agent-Oriented Analysis and Design. Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 69-76.

[Yap1999] M. Yap, and N. W. Keong. Are Life-Like Characteristics Useful for Autonomous Agents? Proceedings of ACM 3rd Annual Conference on Autonomous Agents, 1999, pp. 336-337.

[Zettlemoyer1999] L. S. Zettlemoyer, R. St. Amant, M. S. Dulberg. IBOTS: Agent Control Through the User Interface. Proceedings of the 1999 International Conference on Intelligent User Interfaces, 1999, pp. 31-37.

[Zhou1997] L. Zhou, and S. Franklin. Modeling an Environment: Agents in Character Feature Extraction. Proceedings of ACM 1st Annual Conference on Autonomous Agents, 1997, pp. 178-184.

using software agents in computational gridcaoj/pub/doc/jcao_t_survey.doc · web viewservice agents...

Documents