Intelligent Agents Technologies and JADE Framework

1.1-Introduction

This article introduces the concepts of intelligent agents. In the recent past, the development and deployment of software agents as digital assistants for managing electronic information has steadily increased. While corporate intranets and the world wide web provide the appropriate infrastructure for agent-based applications, automating the search, access, and filtering of information specifically relevant to the individual, from diverse and distributed resources poses a difficult challenge. We discuss the issues and design considerations for personalized information management frameworks in networked environments, and present one implementation solution JADE (Java Agent Development Environment) that ensures privacy, promotes trust, and achieves efficient information sharing among the software agents and the users. We also present selected agent services in the framework to improve agent autonomy, quality of service, and human-computer interface. Implementation of Agents aspect through JADE is explored from beginner to professional levels.

1.2-Components, Middleware and Agents

Ø A software component is defined as a self-contained, customizable and large-grain building block for (possibly distributed) application systems. Some of the common characteristics of components are their ability to communicate by sending and receiving messages, the possibility of having multiple components of the same type in a system, and the description of their state consisting of attributes and other aggregated components .Components encapsulate specific services or sets of services to provide reusable building blocks that can be composed to develop large-scale applications more rapidly and robustly than those built entirely from scratch. Component-based software engineering produces a set of reusable components that can be combined to obtain a high level of modularity and reuse while developing applications .

Ø Middleware is reusable software that resides between the applications and the underlying operating systems, network protocol stacks and hardware. It works as a bridge between application programs and the basic lower-level hardware and software infrastructure that deals with how the parts of these applications are connected and interoperate.

Ø Software agents are essentially software modules with some intelligence that can perform tasks delegated to them at a high level. The agents are sufficiently autonomous to decide how and when they should perform the task, and some agents have the ability to negotiate the task or even reject the task.

1.3-Agent-oriented software development

Components and middleware can be used to develop agent-oriented software. Some
advantages include:

Ø The compliance of components to message-oriented rather than method oriented communication.
Ø The creation of more flexible, adaptable, robust and self-managing components yields the combination of agents and services.
Ø Dynamic registration and discovery of components by name and features, and the loose coupling lead to a greater degree of independent development. For instance, agents can be loaded and activated while the system is running.
Ø The exploitation of technologies such as patterns, micro-frameworks and generators to create multi-agent protocols and behaviors.

The Agent system characteristics include the following:

Ø Autonomy: an agent is able to take the initiative and exercise a nontrivial degree of control over its own actions through the implemented roles.
Ø Cooperation: An agent does not blindly obey commands, but makes suggestions to modify requests or ask clarification questions. It also cooperates with other agents to manage the project. In order to communicate with one another, agents use language, protocol and ontology for exchanging information, knowledge, and sharing common understanding of the structure of information.


The choice of agents as the solution technology is motivated by the following observations:

Ø The domain involves an inherent distribution of data and source of knowledge both physically and logically.
Ø The integrity of the existing organizational structure and the autonomy of its sub-parts must be maintained. 
Ø Interactions are fairly sophisticated, including information sharing, and coordination.

1.4-Intelligent agents 

Agent based technology can be described as an evolution on the distributed object paradigm. Intelligent Agents are software components which schedule and complete tasks on a user’s behalf autonomously or semi-autonomously. As with most systems, the level of autonomous processing will vary depending on the application domain and the user.

The Intelligent Agent system characteristics include the following:

Ø Intelligence: the agent automatically customizes its self to users’ requests based on previous experience. The agent also automatically adapts to changes in its environment.
Ø Autonomy: an agent is able to take the initiative and exercise a nontrivial degree of control over its own actions through the implemented roles.
Ø Cooperation: An agent does not blindly obey commands, but makes suggestions to modify requests or ask clarification questions. It also cooperates with other agents to manage the project. In order to communicate with one another, agents use language, protocol and ontology for exchanging information, knowledge, and sharing common understanding of the structure of information.
Ø Mobility: A single agent can be deployed in different process with different interfaces.

There are two main configurations of agent based systems: single agent systems (one agent carrying out tasks) or multi-agent systems (numerous agents co-operating to complete tasks). 

1.5-Java-based Agent Environments

Ø Java Development (JADE) framework developed at CSELT in Torino, Italy is a FIPA-complient toolkit for creating multi-agent systems applications. JADE provides a set of tools for debugging and deploying distributed agents. JADE supports RMI, CORBA IIOP and event notification transport protocols.

Ø The IBM Agent Building and Learning Environment (ABLE) is a Java-based framework for developing and deploying hybrid intelligent agents and agent applications. ABLE provides a set of reusable JavaBean components, called AbleBeans, along with several flexible interconnection methods for combining those components to create software agents. AbleBeans implement data access, filtering and transformation, learning and reasoning capabilities. Functions are provided also for classification, clustering, prediction and genetic search and for application-specific agents constructed using one or more Ablebeans. AbleAgent editor provides with GUI-based interactive environment. 

Ø AgentBuilder, from Reticular Systems, Inc., is an integrated software development toolkit for constructing agents in Java. Agent architecture in AgentBuilder is BDI and is based on Shoham’s Agent-0 model. The agents use KQML to communicate. 

Ø Aglets are Java-based autonomous and mobile agents developed by IBM. Aglets communicate using a white board that enables agents to collaborate and share information asynchronously

Ø FIPA Open Source (FIPA-OS) is an open-agent platform that supports communication by using the FIPA agent communication standards. 
Ø Gossip is a demonstration application of Tryllian Inc.’s mobile agent software. The Gossip agents use learning technology to create user’s profiles and to perform automated actions on their user’s behalf. 

Ø Java Agent Template Lite (JATLite) is a set of lightweight Java packages that was developed at Stanford University. JATLite provides a layered architecture for building multi-agent systems that provides different communication protocol at each layer. The base layer uses TCP/IP as the communication mechanism and enables the agent implementers to define the message protocol. The KQML layer provides support for agents that use KQML messages. The Router layer adds message routing that enables messages to be queued for agents that are not active when the Router layer receives the message. The focus on JATLite is on communication

Ø Java Expert System Shell (JESS) is a Java application that can be run from the command line. JESS is a Java implementation of the standard CLIPS rule-based environment developed by NASA. JESS was developed at the Sandia National Laboratories. While not an agent environment, JESS provides rule-based interfacing support in Java. 

Ø The Voyger system is an agent-enhanced ORB written in Java developed by ObjectSpace, Inc. Voyger agents are autonomous and mobile, but not intelligent. 

Ø Zeus is a British Telecom agent building toolkit. Zeus is a framework for the development of collaborative agent systems that are constructed suing large, coarse-grained agents that emphasise autonomy and co-operation. 

For more detail about all the above tools and frameworks please 
E-Mail:skphind@yahoo.co.uk

Before year 2000 many of the agent tools focused more on agents mobility and now there seems to be much more emphasis on agent intelligence and reasoning. Also KQML and closely related FIPA ACL are more popular as agent communication protocol . Most often artificial intelligence is utilized through rule-based interfacing and neural learning. 

JADE

JADE is a software framework and middle-ware enabling technology for developing multi-agent systems. As a FIPA-compliant agent platform, JADE provides an implementation for the following components: 

Ø Agent Management System (AMS). This agent is responsible for controlling access to the platform, authentication and registration of participating agents. 
Ø Directory Facilitator (DF). This agent provides a yellow page service to the agents in the platform.
Ø Agent Communication Channel (ACC). This agent provides a white page service. It also supports inter-agent communication and inter-operability within and across different platforms.
JADE also provides an implementation of the full FIPA communication model, i.e., agent interaction protocols (AIPs), FIPA Agent Communication Language (ACL), SL content language, ontology support and, transport protocols.

JADE is written in Java language and is made of various Java packages, giving application programmers both ready-made pieces of functionality and abstract interfaces for custom, application dependent tasks. Java was the programming language of choice because of its many attractive features, particularly geared towards object-oriented programming in distributed heterogeneous environments; some of these features are Object Serialization, Reflection API and Remote Method Invocation (RMI).

JADE is composed of the following main packages:

jade.core implements the kernel of the system. It includes the Agent class that must be
extended by application programmers; besides, a Behaviour class hierarchy is contained in jade.core.behaviours sub-package. Behaviours implement the tasks, or intentions, of an agent. They are logical activity units that can be composed in various ways to achieve complex execution patterns and that can be concurrently executed. Application programmers define agent operations writing behaviours and agent execution paths interconnecting them.

The jade.lang.acl sub-package is provided to process Agent Communication Language according to FIPA standard specifications.

The jade.content package contains a set of classes to support user-defined ontologies and content-languages. A separate tutorial describes how to use the JADE support to message content. In particular jade.content.lang.sl contains the SL codec2, both the parser and the encoder.

The jade.domain package contains all those Java classes that represent the Agent Management entities defined by the FIPA standard, in particular the AMS and DF agents, that provide life-cycle, white and yellow page services. The subpackage jade.domain.FIPAAgentManagement contains the FIPA-Agent-Management Ontology and all the classes representing its concepts. 

The subpackage jade.domain.JADEAgentManagement contains, instead, the JADE extensions for Agent-Management (e.g. for sniffing messages, controlling the life-cycle of agents, …), including the Ontology and all the classes representing its concepts. The subpackage jade.domain.introspection contains the concepts used for the domain of discourse between the JADE tools (e.g. the Sniffer and the Introspector) and the JADE kernel. The subpackage jade.domain.mobility contains all concepts used to communicate about mobility.

The jade.gui package contains a set of generic classes useful to create GUIs to display and edit Agent-Identifiers, Agent Descriptions, ACLMessages, … 

The jade.mtp package contains a Java interface that every Message Transport Protocol should implement in order to be readily integrated with the JADE framework, and the implementation of a set of these protocols.
jade.proto is the package that contains classes to model standard interaction protocols
(i.e. fipa-request, fipa-query, fipa-contract-net, fipa-subscribe and soon others defined by FIPA), as well as classes to help application programmers to create protocols of their own. 

The FIPA package contains the IDL module defined by FIPA for IIOP-based message
transport.

Finally, the jade.wrapper package provides wrappers of the JADE higher-level functionalities that allows the usage of JADE as a library, where external Java applications launch JADE agents and agent containers.

JADE comes bundled with some tools that simplify platform administration and application development. Each tool is contained in a separate sub-package of jade.tools. Currently, the following tools are available:

· ?? Remote Management Agent, RMA for short, acting as a graphical console for platform management and control. A first instance of an RMA can be started with a command line option ("-gui") , but then more than one GUI can be activated. JADE maintains coherence among multiple RMAs by simply multicasting events to all of them. Moreover, the RMA console is able to start other JADE tools.
· ?? The Dummy Agent is a monitoring and debugging tool, made of a graphical user interface and an underlying JADE agent. Using the GUI it is possible to compose ACL messages and send them to other agents; it is also possible to display the list of all the ACL messages sent or received, completed with timestamp information in order to allow agent conversation recording and rehearsal.
· ?? The Sniffer is an agent that can intercept ACL messages while they are in flight, and displays them graphically using a notation similar to UML sequence diagrams. It is useful for debugging your agent societies by observing how they exchange ACL messages.
· ?? The Introspector is an agent that allows to monitor the life cycle of an agent, its exchanged ACL messages and the behaviours in execution.
· ?? The DF GUI is a complete graphical user interface that is used by the default Directory Facilitator (DF) of JADE and that can also be used by every other DF that the user might need. In such a way, the user might create a complex network of domains and sub-domains of yellow pages. This GUI allows in a simple and intuitive way to control the knowledge base of a DF, to federate a DF with other DF's, and to remotely control (register/deregister/modify/search) the knowledge base of the parent DF's and also the children DF's (implementing the network of domains and subdomains).
· ?? The LogManagerAgent is an agent that allows setting at runtime logging information, such as the log level, for both JADE and application specific classes that use Java Logging.
· ?? The SocketProxyAgent is a simple agent, acting as a bidirectional gateway between a JADE platform and an ordinary TCP/IP connection. ACL messages, travelling over JADE proprietary transport service, are converted to simple ASCII strings and sent over a socket connection. Viceversa, ACL messages can be tunnelled via this TCP/IP connection into the JADE platform. This agent is useful, e.g. to handle network firewalls or to provide platform interactions with Java applets within a web browser.

==============The End==============

About the Authors