Last Revision: 19.4.96
Affiliation: The authors are members of the research staff of the IPVR (Institute of Parallel and Distributed High-Performance Systems) of the University of Stuttgart, Germany. They are part of the Mole project, which deals with research in the Mobile Agent area and with the construction of an object-oriented Mobile Agent system with the same name, which uses Java as one agent language.
The W3 is a very popular and still rapidly growing information system, but, strictly limited to client-server interaction, there are areas which are unsuitable to the current web techniques. "Mobile code" approaches like Java or the "interacting distributed objects" model of CORBA try to solve some of the disadvantages of the existing web, but they either lack a more general interaction and communication model (Java) or the possibilities to transfer code and the right distribution granularity (CORBA).
An approach that provides both mobile code and interacting objects (or object clusters) is the object-oriented Mobile Agent model. A Mobile Agent is defined as a special object that has a data state (other non-agent-objects), a code state (the classes of the agent and the other referenced objects) and an execution state (the control threads running in the agent). A Mobile Agent is active because it may follow a program, mobile because it may migrate from host to host, and autonomous because it doesn't need to consult a human or non-human supervisor (it may if it wants of course).
A Mobile Agent is executed in a secure manner (because nobody wants to host legal "worms") by an agent server, and Mobile Agents can't execute without them. Agent servers are mainly runtime environments for the agent languages and consist of infrastructure components like Location and Agent objects, and services like communication and migration. Two important services in an agent system are traders and accounting mechanisms. Traders may return a list with agent addresses according to a service specification given in a request. Accounting mechanisms allow the system to stop agents that have exceeded their resources or to give more resources to agents that provide services deemed useful to the system or other agents.
As applets in java, agents are, as normal programs located (potentially) next to a user, able to communicate directly with humans via a GUI system. Those GUI elements are platform (and maybe language) independant and allow an application to work on every supported platform on one hand and without the restrictions of a limited presentation model like HTML on the other hand.
Object-oriented Agent systems need an infrastructure that supports distributed objects, so CORBA is a very useful platform to build agent mechanisms on: The agent servers communicate with each other via normal CORBA interaction (i.e. RPCs), they may support different object-oriented languages (due to the availability of CORBA IDLs for different languages) and they use some of the CORBA services e.g. externalization, persistence (for fail-safe execution), database access etc., thus putting a layer on top of CORBA that knows how to migrate agents, how to execute programs safely and so on (OMG is currently planning to define this layer, see this Request for Proposals for more information).
A scenario for the use of Mobile Agents for WWW would consist of agent servers at web servers and clients. Some of the immediate benefits of this technology would be:
Apart from the impacts on existing web technology, the mobile agent model
may make the client-server approach redundant, because Mobile Agents
systems implement not only client-server, but also peer-to-peer
interaction, combined with asynchronous execution.
This may result in a system
The Mole project consists of several subprojects, e.g. AIDA that is concentrating on the development of a sound conceptual foundation for an agent system, ASAP (together with the Object Systems Group of the University of Geneva) that develops an infrastructure for an electronic newspaper based on agents, or ATOMAS (together with Tandem Computers, Cupertino), which concentrates on transactional processing, thus enabling electronic commerce. A first version of the Mole System will be released to the public in June 1996. This first version will allow a programmer to construct java agents that are able to travel from location to location, to communicate with other agents in the system, and to communicate with users via java applets and to be executed in a secure way. Later releases will include support for other languages, CORBA integration, trading and application-relevant security mechanisms.