Moving vs. Inviting Software Agents

Here, we describe two strategies respectively known as servlet and applet that could enhance the operations of software agents. In the servlet strategy, the flow takes place from the client to the server. The applet strategy performs differently: the flow takes place from the server to the client.

The state of the art in designing and developing complex systems revolves around software agent technologies [1]. Agents have been used in several application domains, ranging from application integration to information retrieval across heterogeneous and distributed systems. Agent approaches to systems gain popularity from several of their observed advantages and characteristics but mainly from autonomy, adaptability, sociability, and mobility. In this column, we focus on mobility. Indeed, embedded with appropriate mobility mechanisms an agent would be able to roam networks, therefore visiting sites, using the resources of these sites locally, and finally, either going back with results to its original site or submitting results remotely. This type of processing avoids keeping networks busy as well as dealing with their reliability. Authors in [2] state there are at least seven good reasons to start using mobile agents because they: reduce the network load, overcome network latency, encapsulate protocols, execute asynchronously and autonomously, adapt dynamically, are mutually heterogeneous, and are robust and fault tolerant.

We assume two types of agents exist: user-agent and service-agent. User-agents are mobile while service-agents are static. In addition, we assume that service-agents offer different types of services. User-agents require services to satisfy their users’ needs and also must reward service-agents for their services. Each service has two costs—in-site and out-site:

• In-site cost indicates a service is performed in the original site hosting the service-agent of this service.
• Out-site cost indicates a service is performed in different sites, except in the site hosting the service-agent of this service. To achieve this operation, a copy of the requested service is transmitted to these sites for execution.

When a user-agent requires a service that is not offered by any service-agents of its site, this user-agent moves to the site that contains this service.¹ Then, the user-agent meets with the service-agent of this service. We denote this approach by servlet strategy, as shown in Figure 1; first, a move occurs from the user-agent’s site to the service’s site, that is, from the client to the server. Then, the in-site cost is applied. In Figure 1, Site_A consists of User-Agent_A1 and a set of Service-Agents offering multiple services, ranging from Service₁ to Service_i. In Step 1, User-Agent_A1 requires ?Service_j. This service is not offered by service-agents of User-Agent_A1‘s site. Consequently, User-Agent_A1 must identify the appropriate site of Service_j, for example Site_B. In Step 2, User-Agent_A1 moves to Site_B². As soon as it installed in Site_B, User-Agent_A1 requests Service_j from a service-agent, for example Service-Agent_B2.

However, it may occur that the out-site cost of a service is more advantageous than the in-site cost for a user-agent. Therefore, instead of moving to a site, the user-agent sends a request to the service-agent of this service [3]. In fact, the request is meant to send a copy of the required service to the user-agent. We denote this approach by applet strategy (see Figure 2); first, a move occurs from the service’s site to the user-agent’s site, that is, from the server to the client. Then, the out-site cost is applied. In Figure 2, Site_A consists of User-Agent_A1 and a set of Service-Agents offering multiple services, ranging from Service₁ to Service_i. In Step 1, User-Agent_A1 requires ?Service_j. This service is not offered by service-agents of User-Agent_A1‘s site. Hence, User-Agent_A1 has to identify the appropriate site of the service it wants, namely Site_B. In Step 2, a request regarding the service asked for is sent from User-Agent_A1 to one of Site_B‘s service-agents, for instance Service-Agent_B2. Finally, Service-Agent_B2 sends a copy of Service_j to User-Agent_A1 (for execution needs, an agent could be transferred along with this copy).

We have illustrated here that both servlet and applet strategies could suit software agents. To this end, agents should be embedded with mechanisms that allow them to make the correct decision: either move or invite.

Back to Top

Back to Top

Back to Top

Back to Top

Back to top