Software Agents

The next requirement to facilitate integration between human tasks and machine tasks is for some intelligence to be injected at all levels into the overall system. This intelligence will probably take the form of intelligent software agents. Software agents will be able to process the resource definitions and ontologies being developed. The concept of software agents has been around for a few decades. Some might even consider it a failed experiment. However, as we examine the concepts, it will become clear that it was merely an idea that was ahead of its time, and that the infrastructure that makes it possible and useful is now available. The following is by no means intended to cover the topic. By last count, there are at least several dozen good books on the topic, and hundreds of articles. What we will attempt to do, however, is a quick introduction to the topic in the context of enabling the future of Web services.

We can categorize the concepts of intelligent software agents several ways. To add to the confusion, over the years, several definitions of software agent have evolved amidst the discussions of what constitutes intelligence. The two following definitions illustrate the wide spectrum of definitions:

"Intelligent agents are software entities that carry out some set of operations on behalf of a user or another program with some degree of independence or autonomy, and in so doing, employ some knowledge or representation of the user's goals or desires."
—IBM Intelligent Agent Definition (1996)

"An agent is a computational process that implements the autonomous, communicating functionality of an application."

—FIPA and OMG Architecture (1999)

As you can see, the first definition includes the concepts of a user and the user's goals and considers agents to be extensions of users. The second definition considers agents to be a pure functionality embedded within an application or computer program, with no mention or concept of users.

The software agent community has converged on a set of characteristics of autonomous software agents, some of which are considered to be important (autonomous, reactive, learning, goal-oriented, communicative), and others of which are still being debated (mobile, flexible, character):

Reactive— Responds in a timely fashion to changes in the environment
Autonomous— Exercises control over its own actions
Goal-oriented— Does not simply act in response to the environment
Temporally continuous— Is a continuously running process
Communicative— Communicates with other agents, perhaps including people
Learning— Changes its behavior based on its previous experience
Mobile— Is able to transport itself from one machine to another
Flexible— Actions are not scripted
Character— Has a believable "personality" and emotional state

Relating Software Agents to Web Services

It becomes clear from the previous list of definitions that the concept of an autonomous intelligent software agent is closely aligned with that of a Web service, in that an agent can either be exposed as a Web service, or as the interface to a Web service, or can be part of the functionality of a Web service. Consider a functionality that is continuously running, communicative, goal-oriented, and that learns from its previous interactions, and then describe it in a WSDL document and publish it to UDDI; the result is a Web service, regardless of whether it's an intelligent airline booking service that uses a mainframe based process or a wine recommendation service based on a learning adaptive intelligent software agent.

An essential element of both the agent and Web services concepts is that of identity and integrity. In other words, how can agents prove who they are, and how can they prove the integrity of the information they are delivering? As in Web services, the use of digital signatures is starting to become more accepted in software agent applications, which leads us to another important topic: agent communications. Again, most of the standards that have emerged in agent communications have come out of DARPA funded efforts, in this case, the DARPA Knowledge Sharing Effort.

Notably, two specifications, one for knowledge representation and the other for knowledge exchange and message passing, have been established. The first specification is Knowledge Interchange Format (KIF), used to represent information to be exchanged between agents. KIF is an implementation-agnostic specification that is a prefix version of first order predicate logic supporting the definition of four types of expressions: terms (objects), sentences (facts), rules (inference), and definitions (constants). KIF knowledge bases are a set of sentences, rules, or definitions. The simple example shown here represents the information that SkatesTown is a company that sells skateboards:

(exists ((?x Sells) (?y Company) (?z Item))
        (and (Name ?y SkatesTown) (Name ?z SkateBoards)
             (Agent ?x ?y) (Object ?x ?z)))

The second specification is an Agent Communication Language, called Knowledge Query and Manipulation Language (KQML). Whereas KIF is used to represent knowledge, KQML is a message-format and message-handling protocol used for sharing information between agents at runtime. This is done through an extensible set of constructs called performatives because their intent is to cause an agent to perform a specific action. Expressing KIF and KQML in XML should be a relatively straightforward task, and efforts are underway to accomplish that ability. For example, the KQML message shown here, in which a user agent requests a registration for a SEMC-sponsored conference, illustrates the similarity of a KQML performative to a SOAP message:

(request
   :sender   (:name user_agent@tcp://skatestown.com:2020)
   :receiver (:name register_agent@tcp://semc-consortium.org:7070)
   :ontology semc
   :language SL
   :protocol semc-request
   :content
   ( action register_agent@tcp://semc-consortium.com:5001
      ( register
         (:venue conf#3434)
         (:arrival 10/02/2001)
         (:departure 10/15/2001)
         (:infos  ( ))
)))