University of Toronto
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 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.
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 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.
2 Research Place, Suite 202
Rockville, MD 20850
This infrastructure supports a number of services for agent-based applications that most platforms do not provide. These include: (i) Agent creation and deployment over a network of varied platforms, (ii) a message addressing scheme for agent communication which is independent of the location of a sending or receiving agent, (iii) the accumulation of messages intended for a currently busy recipient agent,. (iv) the proper conversion of message data across platforms, (v) multicasting, broadcasting, and peer-to-peer messaging, and (vi) the migration of agents across processors for performance optimization and/or fault tolerance.
Cybele is easy to use and allows application developers to focus on developing agents, and not on implementing agent infrastructures. Cybele's strong points are high performance, scalability, and support for rapid development.
dMARSTM 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.
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.
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.
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 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.
Massachusetts Institute of Technology
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.
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.
LALO is a programming environment which permits the development of multiagent systems. The architecture is extensible and allows creating multiagent systems including reactive agents and deliberate agents. In addition, LALO permits the definition of agents using this new programming paradigm. The inter-agent communication language used is KQML ("Knowledge Query and Manipulation Language"). LALO is an Agent Oriented Programming (AOP) language and a framework for developing intelligent multiagents systems. A program written in LALO is translated into C++ source code, and then compiled with a C++ compiler.
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.
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.
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.
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.
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.
British Telecommunications Labs