In this work we give the outline for a novel approach to semantic web service based applications. This approach centers around the use of so-called intelligent agents as the basis for the middleware layer. We give a broad outline of our prototype architecture and preliminary correctness results.
The Semantic Web and Semantic Service Oriented Architectures[
This particular idea of composition of services provides an advancement over the traditional notion of service oriented architectures: the services available can be loosely coupled and automatically re-used in a dynamic fashion to achieve ad-hoc tasks. These properties of re-used and ad-hoc automation in turn promise to reduce workload on engineers, allowing the instrumentation of common and simple tasks from a basic de nition of the task itself.
The key to the possibility of the automated task composition is that the services of the semantic web di er from their non-semantic cousins by having documents in a machine readable format that describe functions the service performs. This document allows automatic reasoning, planning and work ow execution systems to inspect and decide if a service can be included in a dynamic fashion.
The majority of these systems in place (such as WSMX and UDDI-based systems) use some form of central repository to handle the publication and subscription of a service, while keeping the integration (grounding) of clients and providers distributed. This approach however has problems with maintaining the scale of the central service registry as the number of available services increases. A further problem we have identi ed with this approach is managing the interactions of consumers and providers: integration happens in a tightly coupled fashion outside of good design patterns. 2
The goal of our research is to build a system that allows dynamic composition of services for ac-hoc tasks to be achieved in a fully distributed fashion, removing the need for a central repository to nd and compose the patterns. Additionally we wish this system to be able to manage and broker interactions between services within a distributed environment. This allows increasingly complex tasks to utilise more physical computing resources of the system in an ad-hoc manner. With these aims in mind we de ne four main goals to this research: { 1) that there is no central system for service registration or lookup { 2) that the planning and execution of a work ow of services can be distributed across the available physical resources of the system { 3) that interaction between services and other resources is loosely coupled. { 4) that the system is able to track and manage tasks being executed across itself.
We anticipate that this will allow semantic service oriented architectures, such as semantic grids, to e ciently carry out ad-hoc tasks while allowing the timely inclusion of new services and data into tasks as they are assigned to the system. 3
We have chosen to investigate the use of multi-agent systems as a form of
middleware to enable the distribution of system capabilities and achieve the four
goals of this research as outlined previously. Multi-Agent Systems have been
used with semantic web applications in the past[
To take SSOA and incorporate agents into it, we propose the construction of a novel architecture using a multi agent system as an intelligent middleware layer that brokers the services based on their semantic descriptions and manages the interactions between them.
In our architecture we have services, which are compiled code in the form of annotated classes held locally or integration with remote services (with semantic descriptions of the service being held by the agent in a local service registry). This means every agent has a registry of its own services and knowledge that it maintains. Should another agent require some capabilities it broadcasts this requirement to the set of available agents. Those agents that have the ability to ful ll the requirement propose solutions to the requesting agent, as shown in
The management of interactions is done by sending a task requirement to an agent along with the data that the task is to be performed on, or a description of the data to be found. The agent then uses this description to automatically plan a work ow incorporating discovery of relevant data and the use of relevant services. By having the services and users communicate intentions and requirements to the agents, the agent can utilise available resources according to a decision making process. In this way the instructions to achieve a task need not be hard coded, which further allows the system to be loosely coupled.
To provide a loose coupling mechanism for the services that the agents broker for we propose an API based on Java annotations that can be used to add First Order Predicate Logic to the methods and data presented in a Java class. Using annotations embeds the semantics within the source code, removing the requirement of an external document for the semantics of the class. These annotations are then transformed (by introspection using re ection at load time for the class) into descriptions stored in a local repository that can be used by the agent's internal reasoner to add to task compositions if they match a required sub-task.
The annotations of the services, as well as facts known about the world, are used by the reasoning system of the agent to establish if a goal can be satis ed. The ontology is a set of documents that express facts about the world, but is
Network
Message Queue Request Generator
Request Interpreter Workflow manager
Reasoning Engine Service Service Service
Service manager
Planning algorithm
Service Description Repository
Ontologies and Facts not a complete representation. Each agent has its own domain that it operates in. If a goal cannot be achieved because an agent lacks complete knowledge, a request to solve that problem is sent to the other agents of the collective. This way, even if an agent does not have complete knowledge, the system does and can use knowledge to reason if any agent has this knowledge. The reasoning engine is responsible for checking that tasks can be understood by an agent and to specify the plan requirement to the planning algorithm. This structure is shown in Figure 2. This ensures that our system has perfect knowledge, which is assured in centralised systems.
Using a multi-agent system to implement the middleware allows us to use
several existing solutions to issues that occur with the planning and execution of
ad-hoc tasks, and especially those that are intrinsic to distributed systems. These
include solutions to planning[
As multi-agent systems can be used to distribute the load of planning algorithms, our approach meets goals 1 and 2: there is no central system, and the agents can collaborate to plan and execute solutions to tasks. Since services are invoked (based on descriptions) by the agent and never directly based on a reference, this is also a loosely coupled system, satisfying goal 3. Lastly, agents can also manage which services are executed, when and how often, according to a set policy, which achieves goal 4.
This architecture scales to match the number of organisations in using the system: as each organisation has an agent, the number of agents available increases proportionally. This does not take into account load on any single agent though. Each agent is not an atomic construction, they are a single logical endpoint for data and single repository for data but are not constructed as a single program on a single machine. In this way our architecture allows single agents to adapt to heavy data usage.
We have given a novel architecture that places the \intelligent" component of a semantic service oriented architecture (the elements that performs the reasoning and planning) into a middleware layer based on multi-agent systems. We anticipate this will achieve the four goals we stated for an SSOA by reducing the problem to a multi-agent system, which are known to be able to achieve the four stated goals.
We have made initial mathematical veri cations of this architecture and have begun the construction of a prototype based on a robust set of open source technologies. This prototype has yet to be tested for performance and consistency in controlled experiments against systems that perform the same job of ad-hoc task composition.
In future we plan to deliver a demonstrable prototype, based on an existing real world domain. This prototype will be used for demonstration, testing and tuning purposes.
We plan to evaluate the agent-service integration component for performance and consistency by testing the performance of the agent as services and requests increase. Additionally we plan to test the agent collaboration by simulating a variable number of organisations solving tasks for a real world domain.
We aim to use our results to show the real world usefulness of this system.