Using Software Agents in Computational Grids (Draft) Page 1 of 45
Using Software Agents in Computational Grids
Junwei Cao, Darren J. Kerbyson, and Graham R. Nudd
High Performance Systems Laboratory
Department of Computer Science, University of Warwick, UK
Abstract
Software agents are becoming a mainstream technology used widely in many areas
including intelligent user interface, industry, Internet and WWW, electronic
commerce, business process management, digital library, electronic meeting,
entertainment, network management, virtual reality, artificial society, and so on.
Computational Grids are a new concept emerging in the field of high
performance computing. As it aims to a universal source of computing power,
software agents will be sure to play an important role in the development of this new
infrastructure. On the basis of past and present developments of the most important,
relevant and involved applications of software agents in high performance computing,
future trends and developments of agent technology in Computational Grid will also
be extrapolated and predicted in this work.
In the current grid-oriented software systems agent technology has been used in
different ways, which is, however, not noticed by the agent researchers. Many new
techniques developed in agent research are also far not applied in grid-oriented
software systems. This work is to build a bridge between these two.
The main contributions of this work include: 1). A new taxonomy of software
agents is proposed and a list of related research directions is given on the basis of a
snapshot of latest agent applications. 2). A simplified model of Computational Grids
is illustrated using Unified Modeling Language. 3) A survey of agent applications in
the Grid is described in details and several features are summarized on the
characteristics of these applications. 4). Future challenges are predicted to give a
blueprint of using software agents in the Grid.
1 Introduction
Software agents are becoming a more and more important software development
technology. The key sign of this trend is the emergence of diverse applications and
approaches in many different areas. It has become difficult to get a detail survey of
agent technology in one article. However, some books aim to fulfil this purpose
[Bradshaw1997; Chorafas1998; Jennings1998a; Nwana1996]. These books always
include the history of agent development, the definition of software agents, the
summary of new technologies and approaches, typical agent applications, and so on.
So they are good to understand the basic concepts of software agents. Also there are
many works on agent applications in different areas. These fields include intelligent
Using Software Agents in Computational Grids (Draft) Page 2 of 45
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.
1 Introduction
2 Software Agents
3 Computational Grids
2.1 What is an agent?
3.1 What is the Grid?
2.2 What can agents do?
3.2 What can the Grid do?
2.3 What problems can agents solve?
3.3 What challenges has the Grid met?
4 Using Software Agents
in Computational Grids
4.1 What have been used?
4.2 What can be used in future?
5 Conclusions
Figure 1. The Sections of This Work
Using Software Agents in Computational Grids (Draft) Page 3 of 45
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.
Using Software Agents in Computational Grids (Draft) Page 4 of 45
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.
An agent
Input
Requirement
Control
A general
software entity
Output
Result
Resource
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
intelligence itself
Intelligent Agent (IA)
Social Agent (SA)
Intelligent Social
(ISA)
Social Intelligent
(SIA)
Agent
Agent
simple
relationship
among agents
intelligent relationship
among agents
mobility
Example ways to achieve autonomy
personality,
self-learning,
reasoning,
AI
algorithm,
architecture, emotion, knowledge
communication via ACL
life-like,
control
coordination, negotiation, evolution, selforganizing, market mechanism
migration
Table 1. Four Types of Software Agents
Using Software Agents in Computational Grids (Draft) Page 5 of 45
As shown in Table 1, two extensive types of the agents can be defined from the
basic taxonomy of Intelligent Agent (IA) and Social Agent (SA).
From SA we can get 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 highlevel autonomy such as adaptivity only because they are more complex hybrid agents.
Multi-Agent System (MAS) is a widely accepted conception. When many agents
interact with each other they form a MAS. So a SA or ISA must be in a MAS, while a
IA and SIA may or may not be in a MAS.
Our taxonomy is different from my other works. The reason why we classify
agents from a view of the technologies for agents to achieve autonomy is to create a
convenient way to summarize the current agent technologies from diverse agent
applications. This is described in the below.
2.2 What can agents do?
To understand what agents can do we give an introduction in details of current
applications and research on software agents. First, we give a list of current
applications of four types of software agents. For each kind of key technology for the
agent to achieve its autonomy one or more current typical applications are introduced
with related project background, agent structure, key technology description, and so
on. Then many latest research directions on agent technology are described, including
key technologies to achieve autonomy, agent engineering, agent development tools
and environment, and so on.
2.2.1 Agent Applications
A list of current applications of software agents is given below in Table 2. Almost all
of them emerged in the late 90’s, so they can represent the latest trend of agent
technologies. There are also many typical applications in the early 90’s that are not
included for most of their technologies have been inherited. Because the agent
technology originated from the research on user interface, nowadays a quarter of the
applications is still on the IUI. Only the typical applications on IUI are selected here.
Note that some hybrid agent applications are also mentioned here, but we select its
main part and classify it to only one of four types.
Using Software Agents in Computational Grids (Draft) Page 6 of 45
Ty
pe
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 Webbased 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].
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.
Athlete interacts with its virtual environment
and gradually acquires its reactive behavior
during the process of attaining a global goal.
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
computeraided
education.
The architecture for APA includes
Interface Client, User Model, Route
Server, and Digital Map with information
from GPS and current traffic conditions.
The kinematic structure of Athlete is
composed of eight links, interconnected
with seven revolute joints.
A user model via interaction and an
adaptation routing algorithm.
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.
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.
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.
ARA
[Rogers199
9]
Athlete
[Liu1998]
CoRA
[Strippgen1
999]
EDEM
[Hilbert199
8]
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
Dual-level behavioral self-organization
algorithm that involves the construction
of a high-level behavioral pattern map
and
a
low-level
behavioral
parameterization map.
A hybrid control architecture is
developed to enable CoRA to process
situated action directives on different
levels of complexity.
EDEM is based on a multi-level event
model to allow event monitoring to be
raised to the level of expectations.
Using Software Agents in Computational Grids (Draft) Page 7 of 45
information such as system state and event
history.
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.
Text recognition agent and ScriptAgent, a
programming by example system for the
scripting
language
AppleScript
[Lieberman1998].
Filterbot
[Sarwar199
8]
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.
Grammex
[Lieberman
1999]
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.
Guardian
[Larsson19
98]
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 postcardiac 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.
ibot
[Zettlemoy
er1999]
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.
Content-based rating algorithm.
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.
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.
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.
A
typical
agent
application
on IUI.
Using Software Agents in Computational Grids (Draft) Page 8 of 45
NMRA
[Pell1997]
Open
Sesame!
[Das1998]
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.
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.
PPP
Persona
[Rist1997]
PPP Persona is a lifelike character used to
present multimedia material to the user.
Re:Agent
[Boone199
8]
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.
SAM
[Kaminka1
999]
A novel complementary framework for
social monitoring that utilizes knowledge of
social relationships among agents in
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 constraintbased planning and scheduling, robust
multi-threaded execution, and modelbased diagnosis and reconfiguration.
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 presentation planner; medium-specific
generators, currently for graphics, text and
gestures; the Persona Server; and a
constraint-based layout manager.
A language that provides a simple,
structured vocabulary called Model
Definition
Language
(MDL);
incremental learning; configurable
clustering algorithms.
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.
A knowledge-base containing models of
relationships that should hold among the
monitored agents; the agent modeling
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.
Concept feature approach; action
learning with function approximators.
Plan-recognition algorithm; knowledge
of the social relationships.
An
application
on spacecraft
control.
A
typical
lifelike agent.
Using Software Agents in Computational Grids (Draft) Page 9 of 45
monitoring them.
ShopBot
[Doorenbos
1997]
Shopper’s
Eye
[Fano1998]
ShopBot is a fully-implemented, domainindependent, 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.
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.
SNMP
[Hood1998
]
Simple Network Management Protocol
agents process the collected information and
use it to detect the network anomalies that
typically precede a fault.
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.
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 operates in two phases: in the
learning phase, an offline learner creates a
vendor description for each merchant; in
the comparison-shopping phase, a realtime shopper uses these descriptions to
help a person decide which store offers the
best price for a given product.
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.
Observation processing and combination
of information.
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.
Environmental regularities (including
navigation
regularity,
uniformity
regularity and vertical separation
regularity); offline learning algorithm.
Location-based filtering – exploiting
the user’s location to constrain the task
of an agent.
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.
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
Using Software Agents in Computational Grids (Draft) Page 10 of 45
S
AARIA
[Parunak19
99]
An industrial-strength agent-based factory
scheduling and simulation system being
developed for an Army manufacturing
facility.
AGENTS
[Moreira19
97]
The AGENTS system is a set of programs
designed to generate automatically the masklevel layout of full custom CMOS, BICMOS,
and bipolar leaf cells.
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
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 sixphase life cycle: Inquiring, Committing,
Committed, Available, Active, and
Achieved.
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.
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;
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.
Balanced numerical (in which the
agents pass a fixed quantity of markers
back and forth) communication with
minimal reasoning.
Communication via a subset of KQML.
Synchronous
and
communications.
asynchronous
A
typical
agent
application
on
manufacturin
g.
Using Software Agents in Computational Grids (Draft) Page 11 of 45
InfoSleuth
[Bayardo19
97]
KIMSAC
[Charlton1
999]
PWS
[Ardissono
1999]
RoboTA
[Forbus199
8]
SoCom
[Jain1999]
able to infer trends from the plant
information and can make diagnostic
recommendations.
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.
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.
This is agent architecture of a configurable
Web
store
supporting
personalized
interactions with users.
monitoring
agent;
human-computer
interface (HCI) agent; diagnostic agent;
verification agent.
User Agent; Ontology Agent; Broker
Agent; Resource Agent; Data Analysis
Agent; Task Execution Agent; Monitor
Agent.
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 sphere of commitment (SoCom) is viewed
conceptually as a scope within which a
commitment applies; a SoCom is a multiagent 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.
InfoSleuth is comprised of a network of
cooperating agents communicating by
means of the high-level agent query
language KQML.
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.
Several agents with different functions:
Session Manager, Dialog Manager, User
Modeling Component, Product Extractor,
Personalization Agent, Shopping Cart
Manager, and DB Managers.
Flexible
and
communication.
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.
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.
efficient
agent
Some of the
individual
agents
are
intelligent. So
they
are
hybrid agents
of IA and SA.
Using Software Agents in Computational Grids (Draft) Page 12 of 45
IS
WorkWeb
[Tarumi19
97]
“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.
ADEPT
[Jennings1
998b]
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.
Amalthaea
[Moukas19
98]
Amalthaea is an evolving, multi-agent
ecosystem for personalized filtering,
discovery, and monitoring of information
sites.
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 nonhuman 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 crossworkflow view to other agents.
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.
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
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).
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.
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.
Using Software Agents in Computational Grids (Draft) Page 13 of 45
distinct populations of information
filtering and discovery agents.
CSS
[Lin1994]
DMS
[Sen1997]
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.
This is a software system that uses intelligent
meeting-scheduling agents that can negotiate
with other agents without compromising
their user-specified constraints.
FEA
[Cicalese19
99]
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).
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
Part agent, resource agent, monitoring
agent, and so on communicate through a
communication interface module.
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.
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.
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.
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.
Different
multi-stage
negotiation
protocols; different price adjustment
strategies and methodologies for
selecting resources or selecting parts to
serve.
Heuristic contract-based
strategies.
negotiation
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.
An algorithm called Eat-Grow which
gives general rules that every feature
agent in the system should follow; a
family growth algorithm which
Using Software Agents in Computational Grids (Draft) Page 14 of 45
feature agents.
Fishmarket
[Rodriguez
Aguilar199
8]
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.
HomeBots
[Gustavsso
n1999]
In project ISES (Information, Society,
Energy, and Systems) in Sweden, the loadbalancing task of the demand of energy is
modeled as a multi-agent system and a
computational market with auctions as an
allocation mechanism.
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.
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.
MAGNET
[Collins199
8]
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
provides
a
parallel
processing
environment where more agents can
eat, grow and bear simultaneously, and
outputs a feature tree that stores the
features.
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.
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.
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
A
typical
agent
application
on the power
grid.
Using Software Agents in Computational Grids (Draft) Page 15 of 45
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.
DAIS
[Hofmann1
998]
The Domain Adaptive Information System
(DAIS) is a mobile intelligent agent system
for information discovery and dissemination
in a military intelligence network.
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.
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.
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.
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.
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.
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
Using Software Agents in Computational Grids (Draft) Page 16 of 45
MAGENT
A
[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.
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 endto-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-toend 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.
Table 2 Agent Applications
that its host is overloaded with visiting
agents, it prevents additional agents
from moving in and ensures sustainable
agent load on the machine.
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”.
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.
Using Software Agents in Computational Grids (Draft) Page 17 of 45
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.
Using Software Agents in Computational Grids (Draft) Page 18 of 45
(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
DAI [Chenq1998]
HiMAT
[Cremonini1999]
Jackal [Cost1999]
OAA [Moran1997]
SIM_AGENT
[Sloman1999]
Feature Descriptions
This dynamic agent infrastructure differs from other agent platforms and C/S
infrastructures by its support of dynamic behavior modification of agents.
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 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.
An important consideration in the design of the OAA is to facilitate mix-andmatch: 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.
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].
Using Software Agents in Computational Grids (Draft) Page 19 of 45
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
Using Software Agents in Computational Grids (Draft) Page 20 of 45
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 highlevel 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
Using Software Agents in Computational Grids (Draft) Page 21 of 45
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 highend 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, ondemand 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
Using Software Agents in Computational Grids (Draft) Page 22 of 45
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 usecase 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.
Using Software Agents in Computational Grids (Draft) Page 23 of 45
 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.
Using Software Agents in Computational Grids (Draft) Page 24 of 45
<<uses>>
Manage personal infomation
End user
Run application
<<uses>>
Configure
<<uses>>
<<uses>>
Manage application
Manage tool
Ask for help
Manage resource information
Application
developer
Tool developer
Grid developer
Resource owner
Develop application
Preview
Develop tool
Submit
Develop service
System
administrator
Maintenance
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.
Using Software Agents in Computational Grids (Draft) Page 25 of 45
: User Information
Window
: End user
1: fillBasicInfo( )
: End User Info
: Security
: Information
Management
: Accounting
: Resource
Management
2: registerApp( )
3: registerResource( )
4: submitUserInfo_Clicked( )
5: saveUserInfo( )
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.
: Application
Execution Window
: End user
: Task
: Assurance
1: selectApp( )
2: selectResource( )
3: selectStrategy( )
4: configTask_Clicked( )
5: Task(appinfo, resource, strategy, userinfo)
6: assureAppResc(Task)
7: configTaskReport( )
Sequence Diagram: Configure / Configure application
This is the scenario for end user to pre-configure 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.
Using Software Agents in Computational Grids (Draft) Page 26 of 45
1: previewApp_Clicked( )
: Application Execution
Window
2: previewApp( )
: End user
7: getDynamicInfo( )
8: getStaticInfo( )
: Performance
Visualization
: Performance
Scheduler
6: visuSchedApp( )
4: getResourcePolicy(rescname)
3: getAnalysisResult( )
: Resource
Management
: Performance
Analysis
5: getNowSysInfo( )
: Measurement
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: submitApp_Clicked( )
11: payToRescOwnr(User Information, Resource Info)
: Application Execution
Window
: End user
: Accounting
7: getExeReport( )
2: exeTask( )
8: rescheduleApp( )
: Performance
Visualization
6: visuExeApp( )
: Resource
Allocation
3: monExeApp( )
: Performance
Scheduler
10: exeCheckPointTask( )
: Execution
Monitoring
4: rescAllocCheck( )
9: steerExeApp( )
: Execution
Steering
5: getNowAppInfo(Task)
: Measurement
: Security
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.
Using Software Agents in Computational Grids (Draft) Page 27 of 45
User Package
GUI Package
Tool Package
Application
Package
Service
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.
Using Software Agents in Computational Grids (Draft) Page 28 of 45
Figure 5 Computational Grids Model
Using Software Agents in Computational Grids (Draft) Page 29 of 45
Using Software Agents in Computational Grids (Draft) Page 30 of 45
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 gridenabled 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
Using Software Agents in Computational Grids (Draft) Page 31 of 45
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.
Using Software Agents in Computational Grids (Draft) Page 32 of 45
 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.
Using Software Agents in Computational Grids (Draft) Page 33 of 45
Project Name
(Agent Type)
Project Background
Agent Functions
Agent Structure (only internal
structure for IA and SIA)
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.
Each application will have its
own AppLeS including a single
active
agent
called
the
Coordinator and four subsystems: Resource Selector,
Planner, Performance Estimator,
and Actuator. There are three
general source of information:
Network Weather Service, User
Interface, and Performance
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 everincreasing 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.
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.
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.
Certain Condor programs called the Condor
"daemons" must run all the time to monitor
the status of the individual computers in the
cluster.
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
DPSS
(Hybrid
Agent of SA
and
IA)
[Brooks1997]
These
daemons
include
condor_master, condor_startd,
condor_starter, condor_schedd,
condor_shadow,
condor_collector,
condor_negotiator,
condor_kbdd,
condor_ckpt_server.
Key Technology
to Achieve
Autonomy
Scheduling
policy;
applicationspecific
performance
prediction models.
Communications
via ClassAds,
which contain all
the information
about the state of
the daemons, the
resources
they
represent
or
resource requests
in the pool.
Agents use RMIbased
communication
with other agents,
not with clients.
Reasoning: Facts > ontology ->
Task; Task ->
Operators -> Plan.
Using Software Agents in Computational Grids (Draft) Page 34 of 45
GARA (IA)
[Foster1999]
NetLogger
(SA)
[Tierney1998
]
NetSolve
(SA)
[Casanova199
8]
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 coallocation 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.
NetLogger is a methodology that enables the realtime 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.
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 faulttolerance solves a problem, and returns the
answers to the user.
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 coreservation agent.
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 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.
and act on their environment
using a set of Tasks.
A co-reservation agent and a coallocation agent.
Search
deadlock
strategies.
and
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.
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
Using Software Agents in Computational Grids (Draft) Page 35 of 45
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 AgentBased 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
Using Software Agents in Computational Grids (Draft) Page 36 of 45
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
Using Software Agents in Computational Grids (Draft) Page 37 of 45
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.
Using Software Agents in Computational Grids (Draft) Page 38 of 45
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 NetworkEnabled 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.
Using Software Agents in Computational Grids (Draft) Page 39 of 45
[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 3rd 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. SundaramStukel, 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.
Using Software Agents in Computational Grids (Draft) Page 40 of 45
[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.
Using Software Agents in Computational Grids (Draft) Page 41 of 45
[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 Agentbased 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.
Using Software Agents in Computational Grids (Draft) Page 42 of 45
[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. 521533.
[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.
Using Software Agents in Computational Grids (Draft) Page 43 of 45
[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 14th 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.
Using Software Agents in Computational Grids (Draft) Page 44 of 45
[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.
[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. AddisonWesley 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
Using Software Agents in Computational Grids (Draft) Page 45 of 45
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.