Beyond Java: Merging Corba-based Mobile Agents and WWW

Authors: Fritz Hohl, Joachim Baumann, Markus Straßer
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.
Contact author:

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:

clients may send agents to web servers

this may be used for web search engines which could work in parallel (at the same time on every server in the system!) and with less communication costs because the search engines don't need to transmit every document from a server but the processed result which may be smaller.

secure CGI scripts using Mobile Agents

executing CGI scripts at the server poses severe security problems because they run under the account and with the access rights of a user. Mobile Agents, on the contrary, are executed in an environment that is able to exercise absolute control over foreign programs.

secure client-side programs

which are, in contrary to applets, addressable from other agents, and which may, as first-class objects in agent terms, address other agents.

active objects whose lifetime is not restricted (e.g. by viewing a page)

this implies that, apart from the possibility of permanent addition of functionality at the client's side, e.g. an agent may have permanent state which helps the user the next time he uses this application.

asynchronous net interaction

as agents are autonomous, they can fullfil their orders without the user having run a client program permanently, but to migrate (e.g. for getting a file) to a target and return when the aim is reached.

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

without separate web servers

as every user who has access to an agent system can offer www documents

with global load balancing

as an active web document may (technically) replicate itself and migrate to areas from where it's loaded repeatedly

with support for Electronic Commerce

as the accounting mechanisms, the peer character of every agent system and the uniformity of the agent services constitute a good framework for these services which may be even commercial if a commonly used electronic money mechanism exists. This provides support for even small electronic services offered by every web user

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.