The table provides a survey of currently available agent construction tools. A brief summary is available for each tool as well as a links to the manufacturer's product description.

Commercial Products

AgentBuilder®

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

AgenTalk: Describing Multiagent Coordination Protocols®

AgenTalk is a coordination protocol description language for multiagent systems. In the distributed artificial intelligence area, many coordination protocols such as the contract net protocol have been proposed, and many application-specific protocols will be required as more software agents start to be built. AgenTalk allows coordination protocols to be defined incrementally and to be easily customized to suit application domains by incorporating an inheritance mechanism.

AgenTalk is being co-developed by NTT Communication Science Laboratories and Ishida Laboratory , Department of Information Science, Kyoto University. The software is written in Common Lisp and is only distributed in Japan. 

Agentx

Agentx is a second generation, state of the art, set of lightweight, high performance, and scaleable distributed computing libraries for the Java programming environment. The libraries were designed to provide object request broker facilities that were easier to use, faster, more compact and highly functional, than the RMI libraries bundled with the Sun JDK or generally available Java based CORBA implementations. Unlike the aforementioned tools Agentx does not require the use of an interface definition language nor force the creation of stub or skeleton code. In addition Agentx is fully compatible with both the Sun, IBM, and Microsoft virtual machines as well as the latest versions of both Internet Explorer and Netscape Navigator.

In addition to ORB functionality, Agentx also provides programming support for the creation and release of autonomous mobile agents. Objects can move around on the network, attach themselves to a host, and begin independent execution of their program code. This new technology allows for a complex computer program, or computationally intensive task, to be broken down into smaller discreet parts and distributed across a network of heterogeneous machines for simultaneous but independent execution. The computing devices performing the processing tasks might include desktop PCâs and workstations, as well Java based network computers, or machines running a Java OS. Using this new type of software architecture, Agentx can potentially simulate the functionality of a large mainframe or supercomputer, for only a fraction of the cost.

Agentx, is targeted for sale to information systems groups within military, government, educational and corporate organizations, as well as to independent software companies for integration into their own products. For further information, or to obtain a white paper, visit their website, or contact Marc Schneiderman, Chief Scientist via email at mschneid@iks.com. 

Aglets

An aglet is a Java object that can move from one host on the Internet to another. That is, an aglet that executes on one host can suddenly halt execution, dispatch to a remote host, and resume execution there. When the aglet moves, it takes along its program code as well as its state (data). A built-in security mechanism makes it safe for a computer to host untrusted aglets. 

Concordia

CONCORDIA is a full-featured framework for development and management of network-efficient mobile agent applications for accessing information anytime, anywhere and on any device supporting Java. With Concordia, applications can:

- Process data at the data source.
- Process data even if the user is disconnected from the network.
- Access and deliver information across multiple networks (LANs, Intranets and Internet).
- Use wire-line or wireless communication.
- Support multiple client devices, such as Desktop Computers, PDAs, Notebook Computers, and Smart Phones.

DirectIA SDK

Standing for Direct Intelligent Adaptation, DirectIA(r) is a high-level SDK that gives an agent or a group of agents the ability to learn, anticipate and select their actions. An agent controlled by this engine is able to adapt to dynamic environments, to discover new behaviors and check their efficiency in real time. The biomimetic technology behind DirectIA results from a 10-year experience in biocomputing from MASA researchers and software engineers. As a result, the DirectIA SDK is funded on proprietary artificial life technologies, drastically different from classical AI processing. DirectIA both handles the behavior of agents and the cognitive abilities one expects to find for example in a "smart opponent".

DirectIA application engine is provided as C++ libraries for Windows platforms (both 98 and NT) and comprises a sample application, a demo tutorial, and debugging and tuning tools. In addition to the basic programming support which comes with the license, MASA provides upon request a specific training to optimize the application design, and to ensure the rational and optimal use of DirectIA tools.

DirectIA is targeted for sales to game designers (RPG, wargames...), simulation applications programmers, the military (training applications), avatars and web bots developers, IHM programmers, on-line sites, etc. Prices vary according to the range of the license and the SDK version, and are available upon request at support@animaths.com.

Gossip

Gossip is a mobile agent application that trades information for you on the Internet. You tell the Gossip agent what interests you and the agent travels to a server on the Internet called the Marketplace. At the Marketplace, your Gossip agent looks for other agents with similar interests. When agents with similar interests meet, they start a conversation and exchange information.

Grasshopper

Grasshopper is the first mobile agent environment which is compliant to the Mobile Agent System Interoperability Facility (MASIF) standard. The MASIF standard is built on top of CORBA, thus providing the integration of the traditional client/server paradigm and mobile agent technology. The standardization ensures that agent applications will be open towards other agent environments. Grasshopper allows one to build agent-enabled distributed applications which take advantage of local high-speed communication and local high-speed data access.

iGEN^TM

iGEN^TM is a toolkit and workbench based on a programmable model of human expertise. It includes high-level agent-building tools for the development of intelligent applications.

Intelligent Agent Factory

The Intelligent Agent Factory reduces the time needed to create intelligent agent solutions. The agents are intelligent in the sense that they are controlled with rules written in Jess (CLIPS), a forward-chaining system. Agents and rules are generated from simple specifications of workflows. 

Intelligent Agent Library

The Intelligent Agent Library provides an intelligent agent framework that includes extensive facilities for agent communications and for building larger agent assemblies. There is a KQML-based agent framework and many examples illustrating agents that perform activities for web-enabled applications. The library also supports mobile agents.

Libraries are available from Bits & Pixels, 8601 Del Mesa, Austin, Texas 78759 

JACK Intelligent Agents

JACK Intelligent Agents is a third-generation agent system that provides the architecture and capability for developing and running software agents in distributed applications. Written in Java, it uses JACK Agent Language (an extension to Java) and thus provides all the benefits of the Java language.

JAM Agent

JAM is a Belief-Desire-Intention agent architecture based upon the Procedural Reasoning System (PRS) of Georgeff, Ingrand, Rao, Lansky, and others. Unlike many "agents" available today which are useful in very restricted domains, JAM is applicable to nearly any application domain. It supports both top-down, goal-based reasoning and bottom-up data-driven reasoning. Source code and documentation are available for download at the JAM website.

Jumping Beans

Jumping Beans is a software framework that allows developers to mobilize a Java application such that it can move from one host to another during its lifetime. The mobilized software moves from host to host, along with the executable, data, state, resources and other essential information. This allows it to move to and execute on hosts that did not have the application previously installed. 

LiveAgent - Web Automation Software

AgentSoft's Java-based LiveAgent Pro provides an easy to use, powerful, flexible, and extensible way to automate Web activity. LiveAgent Pro is used to create Internet/Intranet scripts using a recording environment (like a high-level macro recorder or automated testing tool). A developer performs a sequence of Web operations in his/her browser, and those actions are automatically saved by LiveAgent Pro as a script (or "agent"). The completed script can then be run by the user or scheduled for automatic launching. 

MadKit

Madkit (freely downloadable at http://www.madkit.org.) is a publicly available multiagent platform based on organizational concepts. This platform is based on the organization based conceptual model called AGR (Agent/Group/Role) in which an agent is considered as an active entity which communicates by message passing with other agents and plays roles in groups. This organizational model eases the design and development of multiagent systems and allows for the dynamic construction of applications.

Madkit, which is written in Java, works in a distributed way accross machines (with different OS) without needing a central server. Communications and groups can be freely distributed and the distribution is performed transparently at the application level. Agents can be programmed in multiple language. For the moment Java, Scheme (Kawa) and Jess (a rule based language written in Java and based on the Clips system) are the first available programming languages. Other languages will be available in the future.

The madkit architecture is totally modular. The micro-kernel (less than 60k of compiled Java code) is extended by a set of various libraries of messages, probes and agents. System services and debugging tools are themselves provided as agents, making system extensions easy and simple to implement.The reduced size of the micro-kernel, combined with the principle of modular services managed by agents enable a range of multiple, scalable platforms and construction of libraries of specialized agent models.

As an example of its modularity, Madkit comes with tools for building simulations and artificial life applications using a specialized synchronous engine which allows for thousands of agents to work together on a single machine.

MadKit comes with an easy to use graphic box but, as agents are decoupled from their interface, it is easy to embed MadKit agents into a specific application. 

Microsoft Agents

Microsoft Agent is a set of programmable software services that supports the presentation of interactive animated characters within the Microsoft Windows interface. Developers can use characters as interactive assistants to introduce, guide, entertain, or otherwise enhance their Web pages or applications in addition to the conventional use of windows, menus, and controls.

Microsoft Agent enables software developers and Web authors to incorporate a new form of user interaction, known as conversational interfaces, that leverages natural aspects of human social communication. In addition to mouse and keyboard input, Microsoft Agent includes optional support for speech recognition so applications can respond to voice commands. Characters can respond using synthesized speech, recorded audio, or text in a cartoon word balloon.

The conversational interface approach facilitated by the Microsoft Agent services does not replace conventional graphical user interface (GUI) design. Instead, character interaction can be easily blended with the conventional interface components such as windows, menus, and controls to extend and enhance your application's interface.

Microsoft Agent's programming interfaces make it easy to animate a character to respond to user input. Animated characters appear in their own window, providing maximum flexibility for where they can be displayed on the screen. Microsoft Agent includes an ActiveX control that makes its services accessible to programming languages that support ActiveX, including Web scripting languages such as VisualBasic Scripting Edition (VBScript). This means that character interaction can be programmed from HTML pages.

Microsoft Agent requires Microsoft Windows, Internet Explorer and ActiveX. 

NetStepper

NetStepper lets you design, test and run internet agents. By using twelve easy to learn action steps, you can program agents that interact with web pages, ftp sites and even Email servers. NetSteppers' powerful variable parsing and replacement make it easy to write scripts that massage web data and perform actions based on web page content. 

Network Query Language

NQL is a scripting language ideal for building intelligent agents, bots and web applications. Strong communications is an important part of NQL's feature set. Internet access to common protocols such as HTTP, FTP, NNTP, and TELNET are built into the language, as well as support for up-and-coming standards such as LDAP. Custom TCP/IP can be implemented easily using NQL's socket programming facilities. E-mail is easily accessed, as are databases and desktop applications. 

Pathwalker

Pathwalker is a distributed process-oriented and agent-oriented programming library written entirely in Java, which was developed in Fujitsu Laboratories Ltd.

Pathwalker has some features which are useful mainly in distributed programming, such as store-and-forward asynchronous message passing, globally unique identifier of light-weight processes, mobile-code handling utility and agent/action programming introduced from Kafka library which was developed prior to Pathwalker.

Pathwalker runs on both JDK1.1 and Java2 SDK(JDK1.2). We have tested it using JDK1.1.8 and Java2 SDK on Solaris2.5.1/2.6 and Windows95/NT (only reading a JAR file in the mobile-code utility requires Java2). On Solaris, we recommend running Pathwalker applications by native threads, because we have often encountered problems with socket communication hanging on green threads, especially on JDK1.2.1 or earlier versions of reference implementations. 

Swarm

Swarm is a software package for multi-agent simulation of complex systems. Swarm is intended as a tool for researchers in a variety of disciplines, especially artificial life. The basic architecture of Swarm is the simulation of collections of concurrently interacting agents: with this architecture, we can implement a large variety of agent based models. The primary platforms for which Swarm is supported are Solaris running on a Sun Sparc, GNU/Linux running on an Intel 386 and up and Windows NT. However, they currently have users running Swarm on more exotic platforms such as GNU/Linux on a PowerPC, HP/UX, DEC Alpha and SGI. 

Topia Personal Agents

Topia Personal Agents are a class of software that performs tasks on your behalf. The Topia Personal Agent fulfills requests by finding, acquiring, filtering and delivering information, negotiating for services and products, collaborating with other agents to complete tasks and monitoring agent activities. The Topia Personal Agents are goal-centered and autonomous. Once the agent has received a goal, it makes decisions to carry out tasks in the best possible way. The Topia Personal Agent performs these actions freeing you to engage in other activities. 

UMPRS Agent

UMPRS is a Belief-Desire-Intention agent architecture based upon the Procedural Reasoning System (PRS) of Georgeff, Ingrand, Rao, Lansky, and others. Unlike many "agents" available today which are useful in very restricted domains, UMPRS is applicable to nearly any application domain. It supports top-down, goal-based reasoning and selects goals and plans based on maximal priority. Source code and documentation are available for download at the UMPRS website. 

Via

The Via System is written entirely in Java and allows developers to build intelligent agent features into existing applications, Web sites and intranets. Via contains tools for creating agent tasks, logic, and user interfaces. It also includes advanced features for supporting system-wide distribution, persistence, and scalability. 

Voyager

Voyager is a 100% Java agent-enhanced Object Request Broker (ORB). It combines the power of mobile autonomous agents and remote method invocation with complete CORBA support and comes complete with distributed services such as directory, persistence, and publish subscribe multicast. Voyager allows Java programmers to quickly and easily create sophisticated network applications using both traditional and agent-enhanced distributed programming techniques.

Voyager uses regular Java message syntax to construct remote objects, send them messages,and move them between applications. Voyager allows agents (i.e, autonomous objects) to move themselves and continue executing as they move. In this way, agents can act independently on the behalf of a client, even if the client is disconnected or unavailable. This approach is particularly valuable in any type of workflow or resource automation. 

Research Projects

The Agent Building Shell: Programming Cooperative Enterprise Agents

This project is developing an Agent Building Shell that provides several reusable layers of languages and services for building agent systems: coordination and communication languages, description logic-based knowledge management, cooperative information distribution, organization modeling and conflict management. The approach is being used to develop multiagent applications in the area of manufacturing enterprise supply chain integration. 

Agent Factory

Agent Factory is an agent prototyping environment. It features the following:

• Written in Smalltalk-80 (supports Mac, PC, UNIX)
• Distribution through TCP/IP
• Web interface provided
• Agents are reactive, social, pro-active, autonomous and intentional
• Agents may be mobile
• Agent model allows configuration of:
• mental state architecture (the developer is free to construct any mental state architecture; however, the inclusion of beliefs and commitments is expected)
• agent communication language (default is Teanga ACL, but KQML and FIPA ACL supported)
• intentional reasoner (commitment management system)
• Agent designs require initial mental state, perceptors, actuators

D'Agents

A mobile-agent system called D'Agents is under development at Dartmouth College. The ultimate goal of D'Agents is to support applications that require the retrieval, organization and presentation of distributed information in arbitrary networks. Some of the research areas are:

-Security mechanisms
-Support for mobile and partially connected computers Navigation network sensing and resource discovery tools
-Automatic indexing, retrieval and clustering techniques for text and other documents

D'Agents is used in several information-retrieval and workflow applications.

Agent Tcl

Agent Tcl is a tool for developing transportable agent systems. The transportable agents are created using the Tool Command Language (Tcl). Tcl is an embeddable scripting language that is highly portable, highly popular and freely available.

The agents migrate from machine to machine using the jump command. Execution resumes on the destination machine at the statement immediately after the jump is completed. Modifications to the Tcl core allow the capture of the complete internal state of an executing script. Migrating agents are encrypted and authenticated using Pretty Good Privacy (PGP). Access restrictions are imposed on the agent based on its authenticated identity. Safe Tcl enforces the access restrictions.

In addition to migration, Agent Tcl supports message passing. Agents can clone themselves and the system provides rudimentary security features. Each agent on a particular machine has a unique integer ID and a unique symbolic name. Agents specify a recipient agent by specifying the recipient's machine and either the recipient's integer ID or the recipient's symbolic name.

The research project is addressing issues involving debugging, privacy, security, mobile agent management, networking resources and performance. Agent Tcl has two components: a modified Tcl interpreter that execute Tcl agents and a server which runs on every machine that can receive a transportable agent. 

Architecture type-based Development Environment (ADE)

Software agents and agent systems are modelled object-orientedly using the latest findings of software architecture. This approach describes a software architecture as a system of components whose interactions are realised via connectors. With the architecture-based methodology, theoretical fundamentals for the implementation of computer-independent platforms for agent programming have been found.

Existing platforms, such as IBM Aglets or Objectspace Voyager, do not support an architecture-based approach and environment when developing agent application systems. As a result these platforms miss the explicit modeling of agent interactions, or allow only a very limited number of property classes. The advantages of a substantiated methodology of an architecture type-based approach are lost while transforming them onto existing platforms.

To map the mental models and systems onto agent platforms, an architecture type-based agent development environment for the modeling, analysis and construction of agent application systems for various agent platforms called ADE - "Architecture type-based Development Environment" is being developed.

Ascape

Ascape is a software framework for developing and analyzing agent-based models. In Ascape, agent objects exist within scapes; collections of agents such as arrays and lattices. These scapes are themselves agents, so that typical Ascape models are made up of "collections of collections" of agents. Scapes provide a context for agent interaction and sets of rules that govern agent behavior. Ascape manages graphical views and collection of statistics for scapes and provides mechanisms for controlling and altering parameters for scape models. 

Bee-gent

Bee-gent is a new type of software development framework in that it is a 100% pure agent system. As opposed to other systems which make only some use of agents, Bee-gent completely "Agentifies" the communication that takes place between software applications. The applications become agents, and all messages are carried by agents. Thus, Bee-gent allows developers to build flexible open distributed systems that make optimal use of existing applications.

The Bee-gent framework is comprised of two types of agents. "Agent Wrappers" are used to agentify existing applications, while "Mediation Agents" support inter-application coordination by handling all communications. The mediation agents move from the site of an application to another where they interact with the agent wrappers. The agent wrappers themselves manage the states of the applications they are wrapped around, invoking them when necessary. Thus inter-application coordination is handled through the agent wrappers generating and receiving requests, which are transported around by the mediation agents. The mediation agents do more than just transport the messages; they are able to respond to the nature of the request to determine the best course of action. 

Bond Distributed Object System

The Bond distributed object system provides a message oriented middleware environment for developing distributed applications. Bond uses the KQML language for object communication.

The agent framework of the Bond system simplifies the task of developing agents by allowing the programmer to concentrate on the specific strategies of a new agent. Bond agents have the intrinsic capability to be controlled remotely and to cooperate with each other. The task of an application programmer is limited to specify the agenda, the finite state machine of the agent, and the strategies associated with each state. 

Cable - Intelligent Agents

Cable is a generic system architecture developed by Logica as part of the GRACE Consortium. Cable can be used to develop and execute distributed applications that are based on the metaphor of multiple, cooperating intelligent agents.

Cable provides the user with an Agent Definition Language (ADL), for defining agents, and a parser known as the Scribe, for compiling agent definitions written in ADL into agent applications. Agents are developed using ADL and C++. ADL allows developers to use Cable without worrying about underlying detail, providing a language with a level of abstraction close to that of the agents with which an application is designed. Inter-agent communication over a local area network is handled using ORBIX, an implementation of the CORBA 2.0 standard. 

DECAF Agent Framework

DECAF (Distributed Environment Centered Agent Framework) provides a platform for extremely rapid development of agents. This is accomplished by building an operating environment that provides an interface, internal agent scheduling and monitoring in a fashion similar to operating system primitives. The agent developer does not need knowledge of any of this structure and can thus focus on development of the agent itself. The basic DECAF architecture has been built using the Java programming language. The rapid prototyping has been tested by development of approximately 15 agents over a two week period by a recent class. 

dMARS

dMARS^TM is an agent-oriented development and implementation environment for building complex, distributed, time-critical systems. Designed for rapid configuration and ease of integration, it facilitates system design, maintenance and re-engineering. This product is based on the older Procedural Reasoning System (PRS) developed by SRI International (California). dMARS takes advantage of the latest research into multi-agent, real-time reasoning.

dMARS is suited to the development of any application that requires both proactive goal directed behavior and reliable time-critical response to change. It is particularly well suited to applications where a large number of complex but well-defined procedures or tactics exist for accomplishing particular tasks in a variety of situations.

dMARS was designed with the issues of robustness, efficiency and user-extensibility in mind. It provides a sophisticated suite of graphical tools for development and debugging. These tools not only provide an intuitive interface, but address the specific issues involved with large-scale development.

dMARS provides a high-level, graphical plan language for specifying complex, context-dependent processes and tactics. dMARS is written in C and C++ and will execute on a variety of UNIX platforms. dMARS is available from the Australian Artificial Intelligence Institute Ltd., Level 6, 171 La Trobe Street, Melbourne 3000 Australia. 

EXCALIBUR

EXCALIBUR is a generic architecture for autonomous agents used in a complex computer-game environment. These agents must be able to find the right actions to pursue their given goals and adapt their behavior to new environments or opponents. Agents also must be able to communicate and perform coordinated group actions. 

GenA

GenA (Multiplatform Generic Agents)
CRIM's generic agent model "GenA" allows agents to run on and move between different agent platforms by using an interface called "GenAi." Programming these GenA agents is independent of the underlying agent platforms. An implementation of this agent model has been performed and validated by a small application.
GenA (Multiplatform Generic Agents) is based on Java and allows mobile agents to run and move between other platforms such as Voyager, Grasshopper, and Aglets. Programming GenA agents is independent of the underlying agent platforms. An implementation of the agent model has been performed and validated by a small application. At the present time (March 2000), GenA has no external researcher or students working on it. For more information, download GenA Mata '99 vf3.ps. 

Gypsy

The Gypsy Project utilizes Java for the implementation of a flexible environment for experimenting with mobile agent programming. It is intended for application in Internet information retrieval, Internet commerce, mobile computing, and networks network management. 

Hive

Hive is a Java software platform for creating distributed applications. Using Hive, programmers can easily create systems that connect and use data from all over the Internet. At its heart, Hive is an environment for distributed agents to live, communicating and moving to fulfill applications. 

InfoSleuth

InfoSleuth is a consortial Project carried out by MCC on behalf of several participants since January 1, 1995. Current
participants are: Raytheon Company, General Dynamics Information Systems, Inc., SAIC , NCR Corporation, TRW, Inc.,
Schlumberger Limited, and Rafael.

InfoSleuth implements a community of cooperating agents that discovers, integrates and presents information on behalf of a
user or application, for which it provides a simple, consistent interface. The information it accesses are distributed and
heterogeneous, for example the types of information available:
• through an intranet in a large corporation, or
• on the World Wide Web.

The InfoSleuth architecture consists of a set of collaborating agents that work together at the request of the user to:
1. gather information via complex queries from a changing set of databases and semi-structured text repositories
distributed across an internet,
2. perform rudimentary polling and notification facilities for monitoring changes in data,
3. automatically route location-independent requests to update individual data items, and
4. analyze information using statistical data mining techniques and/or logical inferencing.

Users make requests to InfoSleuth from a domain-independent or domain-specific applet. Requests are made against an
ontology specifying his domain of interest. The applet forwards the request to the agent system. Within the agent system,
agents cooperate to satisfy the request on behalf of the user. Each request is processed by the available agents at the time of
the request. Results are presented either within the user's applet or within a specialized result applet. 

Infospiders

By Filippo Menczer and Rik Belew

InfoSpiders (aka ARACHNID: Adaptive Retrieval Agents Choosing Heuristic Neighborhoods for Information Discovery)

This project features an artificial life inspired model using endogenous fitness for information retrieval in large, dynamic, distributed, heterogeneous databases, such as the WWW. A population of agents is evolved under density dependent selection for the task of locating information for the user. The energy necessary for survival is obtained from both environment and user in exchange for relevant information. By competing for energy, the agents robustly adapt to their environment and are allocated to efficiently exploit their shared resources. 

JADE

JADE (Java Agent DEvelopment Framework) is a software framework to develop agent-based applications in compliance with the FIPA specifications for interoperable intelligent multi-agent systems. The goal is to simplify the development while ensuring standard compliance through a comprehensive set of system services and agents. JADE can then be considered an agent middle-ware that implements an Agent Platform and a development framework. It deals with all those aspects that are not peculiar of the agent internals and that are independent of the applications, such as message transport, encoding and parsing, or agent life-cycle.
The JADE 1.2 Agent Platform complies with FIPA97 version 1.2 specifications and includes all those mandatory agents that manage the platform, that is the ACC, the AMS, and the DF. All agent communication is performed through message passing, where FIPA ACL is the language to represent messages.

JAFMAS

JAFMAS provides a framework to guide the development of multiagent systems along with a set of classes for agent deployment in Java. The framework is intended to help beginning and expert developers structure their ideas into concrete agent applications. It directs development from a speech-act perspective and supports multicast and directed communication, KQML or other speech-act performatives and analysis of multiagent system coherency and consistency. The JAFMAS project provides a good comparison of agent tools with a particular emphasis on mobile agent projects.

JATLite

JATLite is a set of Java packages that make it easy to build multi-agent systems using Java. JATLite provides a basic infrastructure in which agents register with an Agent Message Router facilitator using a name and password, connect/disconnect from the Internet, send and receive messages, transfer files, and invoke other programs or actions on the various computers where they are running. JATLite facilitates construction of agents that send and receive messages using the emerging standard communications language, KQML (see http://www.cs.umbc.edu/kqml/ for the current KQML standard). The communications are built on open Internet standards, TCP/IP, SMTP, and FTP. 

JATLiteBean Site

JATLiteBean takes the KQML-speaking functionality of JATLite and wraps it into a JavaBean. JATLiteBean provides an easier-to-use interface to JATLite features including KQML message parsing, receiving and sending. It provides an extensible architecture for message handling and agent "thread of control" management. It also supports automatic advertising of agent capabilities to facilitator agents. Also included is a generic configuration file parser and KQML syntax checker. 

JIAC Site

Java Intelligent Agents Componentware (JIAC) is an open, scalable and universal agent architecture. Implemented in Java, it offers component-based mobile agents, as well as providing support for creating e-commerce applications and distributed telecommunication services. 

Kasbah

Kasbah is an ongoing multi-agent research project to develop an agent-mediated electronic commerce system. A user wanting to buy or sell a product or service will create an agent, give it some strategic direction, and send it off into the agent marketplace. Kasbah agents pro-actively seek out potential buyers or sellers and negotiate with them on their creator's behalf. Each agent's goal is to make the "best deal" possible, subject to a set of user-specified constraints, such as a desired price, a highest (or lowest) acceptable price, and a date to complete the transaction. 

KLAIM - a Kernel Language for Agents Interaction and Mobility

Klaim is a formalism that supports a programming paradigm where processes, like data, can be moved frome one computing environment to another. Klaim naturally supports programming with explicit localities; it consists of a core Linda with multiple tuple spaces and of a set of operators for building processes. 

Knowbot® System Software

Knowbot® is a research infrastructure for mobile agents ("Knowbot programs") intended for use in widely distributed systems such as the Internet. The current version is an experimental prototype. The Knowbot software is written in Python, an interpreted object-oriented programming language. The software executes Knowbot programs also written in Python. However, the design of the Knowbot architecture allows multiple programming languages; support for Knowbot programs written in Java (in addition to Python) is planned for a future release. Knowbot programs written in Python and Java should then be able to interoperate.

Mobiware Middleware Toolkit

Mobiware is a software-intensive adaptive mobile networking environment based on distributed object technology. Built on CORBA and Java distributed object technology, it runs on mobile devices, wireless access points and mobile-capable switch/routers providing a set of open programmable interfaces and algorithms for adaptive mobile networking. 

Mole

This is a research project investigating mobile agents.

The basic concepts for Mobile Agent systems have been developed. Furthermore a prototypical implementation has been developed that shows the feasibility of this approach. This prototype adds mechanisms for migration and communication using the Java programming language. 

Multi-Agent Modeling Language (MAML)

Multi-Agent Modeling Language is a programming language for building agent-based models. The MAML modeling environment is aimed to support scientists, who are not experts in programming, doing research in computer-assisted modeling. Such a modeling environment will enable and encourage experimentation and exploration, providing freedom in all phases of modeling. The supported modeling discipline is agent-based modeling. MAML will be used to develop models, run simulations, search in parameter space, and analyze results. It will have a graphical user interface, support work through the web, and be based on an adequate programming language. 

MultiAgent Systems Tool (MAST)

MultiAgent Systems Tool is a general purpose distributed framework for the cooperation of multiple heterogeneous agents. The MAST architecture consists of two basic entities: the agents and the network through which they interact. 

Open Agent Architecture^TM

Open Agent Architecture^TM (OAA) is a framework for integrating a community of heterogeneous software agents in a distributed environment. In this framework, an agent is defined as a software process that registers its services in an acceptable form, speaks the Interagent Communication Language (ICL), and shares functionality common to all OAA agents (e.g. the ability to install triggers, manage data in certain ways). 

Process Link

The objective of this project is to enable design engineers to track and coordinate their design decisions with each other, even when not co-located or working with the same software.

Approach

The project is developing an agent-based framework consisting of generic agents and a message protocol for integrating multidisciplinary engineering software and managing distributed design projects. This framework allows them to "wrap" legacy software with backend code that will disturb the existing software interface as little as possible while providing useful coordination functions.

They are using a "weak" agent technology in which the wrapped software become agents in that they send messages corresponding to interaction semantics, but they don't necessarily have to be "smart" or conform to any particular theory of agent construction. The only comitment is to send messages conforming to a defined set of interactions. 

RETSINA

RETSINA is a reusable agent. Each RETSINA agent has four reusable modules for communicating, planning, scheduling and monitoring the execution of tasks and requests from other agents. A RETSINA agent is distinguished according to the kind of task it performs (i.e. interface, task, and information agents). 

Social Interaction Framework (SIF)

The Social Interaction Framework (SIF) is a tool for rapid-prototyping of simulations involving multiple agents. It supports the design by providing ready-to-use components and several debugging functions during run-time. With this software you can concentrate on agent-oriented design and the study of the interactions between agents. SIF takes care of issues such as parallel computing and visualization. 

Sodabot

Sodabot is a general-purpose software agent user-environment and construction system. Its primary component is the basic software agent- a computational framework for building agents which is essentially an agent operating system. This project developed a new language for programming the basic software agent whose primitives are designed around human-level descriptions of agent activity. Using this programming language, users can implement a wide-range of typical software agent applications, e.g. personal on-line assistants and meeting scheduling agents. 

SOMA

SOMA is a Java-based Mobile Agent framework capable of answering the requirements of scalability, dynamicity, openness and security that are typical in the Internet scenario. It has been designed to achieve two main objectives: security and interoperability. On the one hand, SOMA is based on a thorough security model and provides a wide range of tools and mechanisms to build and enforce flexible security policies. On the other hand, SOMA can interoperate with different application components designed with different programming styles; it grants interoperability by closely considering compliance with CORBA and MASIF. In addition to its security and interoperability features, SOMA provides the location abstractions needed for achieving scalability in a global scenario, and is dynamically configurable and manageable, also via Web-based interfaces. SOMA also supports all forms of mobility. 

TeamBots

TeamBots is a Java-based collection of application programs and Java packages for multiagent mobile robotics research. The TeamBots distribution is a full source-code release. The simulation environment is written entirely in Java. Execution on mobile robots sometimes requires low-level libraries in C, but Java is used for all higher-level functions. At present, TeamBots will run on the Nomadic Technologies' Nomad 150 robot and on Personal Robotics' Cye robot.

TeamBots supports prototyping, simulation and execution of multirobot control systems. Robot control systems developed in TeamBots can run in simulation using the TBSim simulation application, and on mobile robots using the TBHard robot execution environment. 

TuCSoN

TuCSoN is a model for the coordination of Internet agents. TuCSoN exploits a notion of local tuple-based interaction space, called tuple centre, which is a tuple space enhanced with the notion of behaviour specification. By programming its behaviour in response to communication events, a tuple centre can embody coordination laws.

Zeus

Zeus is a 'collaborative' agent building environment and component library written in Java. Each ZEUS agent consists of a definition layer, an organisational layer and a co-ordination layer. The definition layer represents the agent's reasoning and learning abilities, its goals, resources, skills, beliefs, preferences, etc. The organization layer describes the agent's relationships with other agents. The co-ordination layer describes the co-ordination and negotiation techniques the agent possesses. Communication protocols are built on top of the co-ordination layer and implement inter-agent communication. Beneath the definition layer is the API.

*Thanks to James Odell for his assistance in maintaining these pages.

For questions/comments about this website, please contact webmaster@agentbuilder.com
Last modified: November 1, 2000
AgentBuilder is a registered trademark of Reticular Systems, Inc.
All other product names referenced are trademarks of their respective companies.
Copyright © 1999-2000 Reticular Systems, Inc.
Reticular Privacy Policy