AgentBuilder

The next wave of technological innovation must integrate linked organizations and multiple application platforms. Developers must construct unified information management systems that use the world wide web and advanced software technologies. Software agents, one of the most exciting new developments in computer software technology, can be used to quickly and easily build integrated enterprise systems. The idea of having a software agent that can perform complex tasks on our behalf is intuitively appealing. The natural next step is to use multiple software agents that communicate and cooperate with each other to solve complex problems and implement complex systems. Software agents provide a powerful new method for implementing these next-generation information systems.

AgentBuilder is an integrated tool suite for constructing intelligent software agents. AgentBuilder consists of two major components - the Toolkit and the Run-Time System. The AgentBuilder Toolkit includes tools for managing the agent-based software development process, analyzing the domain of agent operations, designing and developing networks of communicating agents, defining behaviors of individual agents, and debugging and testing agent software. The Run-Time System includes an agent engine that provides an environment for execution of agent software.

Agents constructed using AgentBuilder communicate using the Knowledge Query and Manipulation Language (KQML) and support the performatives defined for KQML. In addition, AgentBuilder allows the developer to define new interagent communications commands that suit his particular needs.

All components of both the AgentBuilder Toolkit and the Run-Time System are implemented in Java. This means that agent development can be accomplished on any machine or operating system that supports Java and has a Java development environment. Likewise, the agents created with the AgentBuilder toolkit are Java programs so they can be executed on any Java virtual machine.

Software developers can create powerful intelligent agents in Java that execute on a wide variety of computer platforms and operating systems. The toolkit and the run-time system are described in the following paragraphs. Figure 1 shows the major components of AgentBuilder and their relation to each other.

The AgentBuilder toolkit is designed to provide the agent software developer with an integrated environment for quickly and easily constructing intelligent agents and agent-based software.

The Project Control Tools are provided to help the agent developer manage the overall agent development process. These tools include the Project Manager, the Project Dictionary Tool, and the Project Repository Manager.

The Ontology Manager assists the developer in analyzing the agent application problem domain and in identifying and defining the concepts relevant to the agent's operation in that domain.

The Agency Manager is designed to help the developer construct an agency. An agency consists of two or more agents that communicate and cooperate with each other to perform some task. The agents may be identical or specialized for performing different functions. The Agency Manger allows the developer to identify and characterize all of the agents and agent types in the system under development.

The Agency Manager provides a run-time window for viewing the operation of a system of agents. Thus, the developer can monitor interagent communications, control the agents, or run the agent debugger to examine the state of any or all agents.

The Agent Manager provides tools for defining an individual agent's initial mental model and behavior. The agent definition tools include graphical editors for defining the various mental constructs that make up the agent: initial beliefs, initial commitments, initial intentions, capabilities and behavioral rules. In addition, the Agent Manager supports tools for adding planning and learning capabilities to an agent.

The AgentBuilder toolkit provides assistance for adding a learning and planning capability to the agents. The planning and learning editors provide the developer with the ability to build domain specific planning and learning modules.

To assess the available agent toolkits on the market, the authors utilized the AgentBuilder web site list as a starting point, as it was posted on July 2001. This list was amended by the authors' own secondary research on the Web to find other agent toolkits available on the market. From this investigation, 40 agent toolkits were downloaded from their vendor's web sites; 20 were successfully installed locally and individually tested. Installing the software was a time intensive process given the strict configuration requirements of some of the toolkits. For example, many toolkits worked only with a certain version of Java Virtual Machine (JVM) that sometimes required uninstalling and installing previous versions of JVM.

Each of the toolkits was assessed in terms of its underlying technology and general functionality. Overall, four major categories of agent toolkits were identified: mobile agent toolkits, multi-agent toolkits, general-purpose toolkits and Internet agent toolkits. Table 1 below provides a summary of the authors' assessment of the more popular agent toolkits in terms of these major categories.

	Features	Technology Examples		Comments
Mobile agent toolkits	Mobility Communication (desirable)	Java (77%) Python(7%) Tcl(7%) C/C++(6%)		Concordia Gossip FarGo	Addresses both mobility and communication.
IBM Aglets			A tool for manipulating mobile agents. Knowledge of Java required.
Multi-agent toolkits	Agent Interaction Communication Coordination Conflict Resolution	Java		MadKit	Allows running sample built-in agents as well as agents created outsize the environment.
Zeus			A convenient tool for developers who lack Java programming. May be used in basic agent courses.
JADE			Offers tools for creating and debugging MAS.
JATLite			Well-addressed communication.
MAST			Knowledge interchange.
General purpose toolkits	No specific area of concentration No unique requirements	Java(68%) Prolog(8%) C/C++(8%) Other(16%)		FIPA-OS	Best choice for development of FIPA compliant agents. Knowledge of Java is required for advanced development.
Ascape			May be used by programmers and non-programmers.
Internet agent toolkits	Have features common to mobile agents Usually interactive and emphasize personalization	Java		Microsoft Agent	No programming skills required.
Voyager			Allows creating mobile internet agents. Knowledge of Java required for development.
NetStepper			Used for creating information retrieval agents. No programming skills required.

Table 1: Overview of agent toolkits on the market

Mobile agent toolkits were defined to be toolkits primarily dedicated to the creation of mobile agents. A mobile agent is an executing program that can migrate, at times of its own choosing, from machine to machine in a heterogeneous network. On each machine, the agent interacts with stationary service agents and other resources to accomplish its tasks (Gray et al., 2000). In other words, it is an object that can move from one computer or host machine to another performing a set of tasks that are specified by a user. A remote super computer that becomes a "place of agent meeting" for information exchange may act as a broker linking together agents performing similar tasks.

Multi-agent toolkits were defined to be toolkits that were primarily concerned with the development of a multi-agent system (MAS). A MAS is usually composed of several interacting agents. This interaction involves the coordination of actions between agents, and the adaptation of agent behavior in response to the environment. MAS is an emerging area of research in the field of distributed artificial intelligence. Often, an agent cannot solve a complex problem alone and needs cooperation with other agents to exchange data and information or delegate tasks. Over the last five years, there has been rapid development and deployment of MAS. Many conferences, workshops and seminars have been organized around this topic. There are also several web sites (e.g., www.multiagent.com ) that are entirely devoted to MAS. DeLoach (2001) identifies numerous challenges confronting successful MAS building. These include: decomposing problems and allocating tasks to individual agents; coordinating agent control and communications; making multiple agents act in a coherent manner; reasoning about other agents and the state of coordination; reconciling conflicting goals between the agents; and engineering practical multi-agent systems.

General purpose agent toolkits were defined to be agent development environments that do not concentrate on one specific area of agent development, like the toolkits discussed above. Instead, they allow users to create different kinds of agents for different purposes. Toolkits in this category are also identified by vendors as being agent development environments, agent development tools, agent frameworks, or agent architectures.

Internet agent toolkits were defined to be toolkits dedicated to the creation of Internet agents. These agents are dedicated to searching and retrieving information off the Internet and/or improving the interface with which users themselves search the Web. Various functions may be performed by Internet agents. They may search the Web while a user is not surfing. They may automate routine and time-consuming tasks (e.g., sorting the results that come back from search engines). They may find products a user needs or make the surfing experience more interesting and pleasant. Internet agents are usually interactive and emphasize personalization of retrieved search results. The following subsections provide more detail on the agent toolkits that were analyzed. Each subsection pertains to one of the four major categories of agent toolkits identified above.

In terms of mobile agent toolkits, the authors found the Mobile Agent List4 by Fritz Holh to provide a very comprehensive list of mobile agent construction tools. The list offers a description of 60 products. Although these products differ in terms of functionality, technology and area of application, all of them share two common features: mobility and communication. Mobility is necessary for all mobile agents since they must move through communication networks. For example, Concordia5 implements mobility through its queue manager for the reliable transport of agents and has a special Java object serialization scheme to accomplish this. Communication is another important feature. Although optional, agents may need to communicate and exchange messages while traveling in cyberspace. Some agent toolkits support the creation of mobile agents which are capable of communicating with one another. For example, IBM supports aglets6, which is a mobile agent construction tool with message passage features: agents create and pass both asynchronous and synchronous message objects to one another to communicate.

Figure 1 illustrates the underlying technology employed in mobile agent toolkits. The diagram shows how Java, due to its unique platform independence, has been the most popular language for development of mobile agent toolkits. The other languages utilized for development are Python (7%), Tcl (7%), C/C++ (6%), Prolog, Perl and Jess (3%). Java (77%) Python (7%) Tcl (7%) C/C++ (6%) Other (3%)

Figure 1: Underlying technology of mobile agent

Other examples of mobile agent toolkits are Gossip, developed by Tryllian7, which allows the user to build an agent that trades information on his or her behalf over the Internet, and FarGo, developed by Technion8, which facilitates the creation of agents with unique relocating control features.

Aglets, as mentioned above, is a mobile-agent development tool. The Aglets Software Development Kit9 is a development environment for mobile Internet agents called aglets. The aglet represents a Java object that may be transported from one host machine to another together with state information. The aglet may work on a certain host computer and then it may stop execution and move further though the Internet keeping the data it has gathered and processed. After arriving at a new point of destination, the aglet resumes working. The aglet development kit utilizes J-AAPI technology -- a standard for interfacing aglets and their environment, which defines the set of behaviors aglets follow, such as: message creation and handling, initialization, dispatching, retraction, activation and deactivation, cloning and disposing (Lange, 2002). J-AAPI, a language created for aglet programmers, can also be used for educational purposes.

The toolkit has a user-friendly development environment, called Tahiti, that provides a graphical user interface with a variety of options, for example, configuration options and building tools. Tahiti includes a number of sample aglets that may be run and analyzed by first-time users, which is another important feature of the package. Note, however, that aglets are Java classes that should be created outside Tahiti. The toolkit does not provide a Java development environment itself. Rather, it allows users to send aglets into cyberspace, and monitor and manage them. Therefore, the user must be able to create his or her own agents using an Integrated Development Environment (IDE) like Symantec's Visual Café, IBM's VisualAge, Borland's JBuilder or Metrowerk's Code Warrior. The authors found IBM's aglets to be a useful tool for manipulating mobile agents, however, it requires the agent developer to be very familiar with Java programming. As such, instructors wishing to utilize aglets in educational courses or research must be strongly acquainted with Java.

With respect to multi-agent toolkits, the authors discovered that several different toolkits are available. For example, out of the 60 agent toolkits presented on the AgentBuilder web site, eight were multi-agent. All these utilize Java for agent development. An example of a multi-agent toolkit is the Java Agent Development Framework (JADE)10, developed by the University of Parma, which simplifies implementation of multi-agent systems and provides a set of tools that support development and debugging. The Java Agent Template Lite (JATLite)11 is another example multi-agent toolkit. Created by Stanford University, JATLite allows users to build agents that communicate robustly over the Internet though the Agent Message Router Facilitator. Developers of the Multi-agent Systems Tool (MAST) 12 at the Technical University of Madrid also emphasize all aspects of knowledge interchange among agents.

A well-known multi-agent toolkit is Zeus13, developed by the British Telecommunications Laboratory. This toolkit offers a library of software components and tools that facilitate fast and friendly design, development, and deployment of multi-agents. Zeus consists of three main functional components: the agent component library, agent building tools, and visualization tools. The agent component library is a collection of software components that implement multi-agent functionality. It offers a number of pre-written, standard agent components and a collection of sample agents for developers to utilized. The agent building tools is an integrated multi-agent development environment for creating agents. The visualization tools is a runtime environment for running, testing and debugging agents. The multi-perspective approach used in the visualization tools area gives developers an opportunity to visualize the processes they select.

According to the documentation available off the Zeus home page, creating Zeus agents involves the following five consecutive steps:

For the first step, users define their agents' ontology -- the declarative knowledge representing concepts, attributes and values. This is done via an ontology editor. The second step is where agent creation occurs. This is accomplished through an agent definition user interface where agent tasks and coordination are described. In the third step, the user creates utility or facilitator agents that collectively provide an working infrastructure to support agent task fulfillment and collaboration. In the fourth step, the designer specifies the hosts on which the agents will run and external programs to which the agents will be linked. The last step involves the generation of agent source code. This is done through a code generator which creates a Java-based agent application as its output as well as a number of utilities and batch files. Once an agent has been compiled, the developer may move it to a host machine for testing and running using a variety of graphical, report and statistical tools. It is the authors' opinion that Zeus is a very convenient educational tool for developers who lack a strong Java programming background. This toolkit may be used by instructors in basic intelligent agent courses.

MadKit14 is another multi-agent toolkit for consideration. Developed by the MadKit Development Group, MadKit is a Java multi-agent platform built upon an organizational model. It provides general necessary agent facilities and allows heterogeneity in agent architectures and communication languages as well as customization. G-Box is the graphical user interface development environment for MadKit. The major components of G-Box are a toolbox that shows a list of available agents, a properties zone that shows an agent's editable properties, and an agent desktop working environment. In addition, there are special components within G-Box which show lists of currently running agents and groups of agents.

G-Box offers a wide range of sample multi-agents for execution, as well as the ability for users to add their own Java-written agent applications. This functionality may be of specific interest to educators. For example, to teach basic functionality of multi-agents, an instructor may ask students to monitor the sample Ping-Pong agent available within MadKit. After launching, this agent creates a "Ping-Pong" and waits for another agent to play with. Later, students can launch a second agent which registers with the "Ping-Pong" group. This is detected by the first agent, and the two agents begin interacting with one another by exchanging messages. "Mosquitoes" is another interesting example of multi-agent simulation of potential interest to students where small agents are created according to a predefined algorithm. To view and test out these agents in action, MadKit offers a Java-enabled browser. Such visualization tools can help promote greater learning and understanding of basic agent operability.

In terms of general purpose agent toolkits, a larger majority of toolkits fall into this category. For example, general purpose agent toolkits constituted over 40% of all applications presented on the AgentBuilder web site. Figure 2 illustrates the underlying technology employed in this category of toolkits.

Figure 2: Underlying technology of general purpose toolkits

Java, again, is the leading programming language. Sixteen percent of the applications have been built in C/C++ and Prolog, and a few toolkits have been created with ActiveX, Jack, COOL, Perl, VisualWorks or Lisp.

FIPA-OS and Ascape are two examples of general purpose agent toolkits. FIPA-OS15, developed by Emorphia Limited, is a toolkit that develops FIPA16 compliant agents. FIPA (the Foundation for Intelligent Physical Agents) is an international organization dedicated towards creating and implementing software standards for heterogeneous and interacting agents and agent-based systems. Standards developed by FIPA aim to promote the interoperation of heterogeneous agents and the service that they can represent. FIPA-OS is a component-based agent toolkit that allows users to develop FIPA compliant agents using three groups of components: 1) mandatory components, which must be included in all FIPA compliant products; 2) components with switchable implementations; and 3) optional components, such as Database Factory, Parser Factory and Choice Constraint Language.

Figure 3: The FIPA-OS Agent Toolkit (kindly reproduced with permission)

FIPA-OS is built utilizing Java technology. Agent developers utilizing this toolkit are required to know the concepts of object-oriented programming and be familiar with Java classes. The toolkit provides a group of classes that are used in agent development, as well as a graphical testing environment. The simple tutorials available on the FIPA-OS web site can be used by course instructors to teach students the basic workings of agent development. For example, using these tutorials, students may easily create the following agents:

Performing these exercises will enhance students' understanding of agents and give them some practical experience in constructing FIPA compliant intelligent agents.

Ascape17, introduced by the Brookings Institution, is a software framework for developing, testing, and analyzing intelligent agent-based models. In this environment, agent objects exist within «scapes». These are agents that represent collections (arrays and lattices) of agents and provide interaction and behavioral rules.

Ascape is written purely in Java and may run on any platform. The toolkit, however, may be used by both programmers and non-programmers alike. The toolkit offers a graphical interface where developers who do not have familiarity with Java may monitor and manage their own agents. For example, users have complete control over model parameters at runtime. Users may also create graphs and customize their own views. In future versions of Ascape, no programming will be required to change basic rules and structures. Ascape supplies itself with ten sample demonstration agents (e.g., Prisoner's Dilemma, Retirement, Class Emergence, Firms, Sugarscape and Norms). Students of agent technology may find these samples helpful. To create robust agents in Ascape requires knowledge of Java. However, development of simple agents requires only basic knowledge of Java and object-oriented programming. This is in part due to Ascape's ability to allow the construction of simple agent models from « off-the-shelf » parts. More advanced developers would likely build their agents utilizing Java classes supplied with the agent.

With respect to Internet agent toolkits, the authors found several toolkits for consideration. The authors would like to point out three in particular: Microsoft Agent, Voyager, and NetStepper.

The Microsoft Agent toolkit supports the creation of a personal interactive animated character that may be hosted on a user's web site. This agent may guide visitors through the user's site, explain menus, navigational tools, offer tips and even talk. A benefit for students of agent technologies is that the Microsoft Agent toolkit requires no knowledge of programming to generate these interface agents.

Voyager18, designed by ObjectSpace Inc, is a toolkit for building Java-based agent brokers used in agent-mediated electronic commerce. The main objective of the toolkit is to ease the design, development and deployment of distributed applications over networks such as the Internet. The idea is to build autonomous agents that act on behalf of the client, are able to move through the network, and which are in constant communication and collaboration with other agents and the user. The Voyager product line includes the following applications:

In terms of classroom use, Voyager facilitates the construction of agents that can be viewed by users within a development console. However, Voyager requires thorough knowledge of Java to develop and deploy agents within the toolkit.

NetStepper19 is another tool for designing, testing and running Internet agents that collect information off the Web. The major advantage point of NetStepper is that it allows all aspects of agent design to be accomplished through its graphical user interface. This feature makes the toolkit very attractive to non-programmers. To create an agent within NetStepper, a user can employ a wizard to help describe the agent's functionality. Working with the toolkit, users can build their own databases of the Internet where all information is represented by links. The application includes a very easy to follow tutorial allowing novices agent developers to create simple agents within a few minutes. After an agent has been created, the user may run it from within the toolkit. The agent's output is represented either as a list of the links pointing to the required information, or as a text file containing these links.

AgentBuilder allows software developers with no background in intelligent systems or intelligent agent technologies to quickly and easily build intelligent agent-based applications. AgentBuilder reduces development time and development cost and simplifies the development of high-performance, robust agent-based systems.

AgentBuilder is currently available in two different versions to meet a wide variety of developer needs: Lite, an entry-level product for agent software developers, and Pro, for serious multi-agent development.