Developing a Distributed Dynamic Intelligent Agent Framework

Based on the Jini ArchitectureHarry Chen

Department of CSEE

U. Of Maryland Baltimore County

Introduction

Developing a framework for dynamic distributed systems..

Ronin Agent Framework – Introduces a hybrid approach based on the agent-

oriented and service-oriented programming designs– deploys a dynamic distributed system with

“intelligence”. Ronin provides solutions for the problems

raised by the existing agent frameworks.

Overview

Observations– The future computing trends.

Motivations for developing Ronin– The Jini architecture– Agent technology

The Ronin Agent Framework Agents2Go & Ronin

Computers & devices are connected in networks.– Wireless connection is gaining its popularity.

Distributed computing is the trend of the future. – PDAs and cellular phones are now capable of doing

computation. People are spending more time with

computers.– Shopping, work, entertainment etc.

The Future Trends

Observations

Networks are by nature dynamic.– “Things” come and go.– “Things” need to find each other.

“Things” are not homogeneous.– A laptop computer wants to talk to a web server as

well as a cellular phone. “Things” need to be smart!

- People can’t spend all of their learning and telling these “things” what to do everyday!!

Observations

We need tools to develop flexible and robust distributed system with “intelligence”.

The Jini architecture seems to be a good framework for developing dynamic distributed systems. – Why is Jini good?– Is Jini the answer?

The Jini Architecture

A simple Java-based infrastructure for providing services in a network.

Each Jini system is built around Lookup Services (LS). – Service client finds services through the LS.

Each service implements a set of well-known service interfaces.– Service client knows how use a service because of

the client knows how to use the interface!

A Typical Jini Service

The Printing Service– Bob needs to print 1000 copies of color brochures

from his laptop.– Bob connects his computer to the network, specifies

a set of lookup attributes for finding a printer.– The LS returns a matched print service.– The client application invokes one of the print

service method, and the job is done!

A Closer Look at the Jini Architecture

There is a catch with the Printing Service scenario.

Finding a good service match Bob has to know about all of the lookup attributes. – A service might have hundreds of attributes. Bob

might not understand all of the attributes.– Bob might not know his file must be printed on a

PostScript printer.

A Closer Look at the Jini Architecture

How can we help Bob?– Give Bob a “smart” agent that can help Bob to make

decision.– The agent finds an appropriate printer for Bob

based on the properties of the print file and the user profile of the Bob.

No need for Bob to learn about the service detail

Reduce the chance of making human errors.

What Can We Say About Jini

Jini is good.– Jini provides flexible and robust infrastructure for

deploying and finding services. – The service-oriented design provides an uniformed

infrastructure for distributed entities to interact. – Developing a Jini service is easy.

What Else Can We Say About Jini

Jini alone is not the answer for everything. Developing a “smart” Jini service is hard.

– Why is it hard? To be adaptive, it needs to learn from the environment and

the past; it needs to cooperate with other services. To be autonomous, it needs to know how to make plans

and schedules; possibly it needs to know how to represent knowledge and reason.

And more …

Searching for Answers

Software agent model contains the properties that we are looking for:– Agents are autonomous.– Agents can learn from the past.– Agents can cooperate with other agents.– Agents can adapt and react to their environment.

If we can model a Jini service to have the same properties as a software agent, then we are done!

Software Agents

The key idea is that agents can act exactingly in order to accomplish tasks on the behalf of their users.

Software agents offer a new paradigm for very large scale distributed heterogeneous applications.

The paradigm focuses on the interactions of autonomous, cooperating processes which can adapt to humans and other agents.

Software Agents DO Communicate

Software agents communicate with each other using Agent Communication Language, ACL.

ACL is important for agent paradigm, just as the development of human language was the key to the development of human intelligence and societies.

Agent Communication Languages

Knowledge sharing approach– KQML, KIF, Ontologies

FIPA

Shared objects, procedure callsand data structures

Shared facts, rules, constraints, procedures and knowledge

Shared beliefs, plans, goals,and intentions

e.g., CORBA, RPC, RMI

e.g., KQML, FIPA, KIF, Aglets

e.g., ?

KnowledgeSharing

IntentionalSharing

?

ObjectSharing

Building Software Agents

Building smart agents we need sophisticated tools, for example.– Agent Communication Languages (ACL).– Rule-based programming.– Domain knowledge representation and reasoning.– Constraint problem solving.– Planners.– And more depends on the domain problem.

Problems Raised by the Existing Agent Frameworks

Lacking of sophisticated tools in Java. Restricted ACL for agent communications. Restricted network protocol. Difficult to integrate heterogeneous agents

systems.– Message representation are different.– Communication scheme are different.

Task 1: Making sophisticated tools to be available for developing agents.

Task 2: Merge the agent architecture with the Jini architecture, taking advantage of the best parts of each.

Our Tasks

Task 1: Making Tools Available

We can implement all of these sophisticated tools in Java. – Takes long time and it is not so trivial.

We can reuse the existing tools and create Java interface for agents to use. – Easy! Create Jini services for these sophisticated

tools.

Making Prolog Available

Prolog engine is an excellent tool for building inference engine and knowledge base.

We have created a Jini service called Distributed Prolog KB (DPKB), to provide simple knowledge base operations for Jini enabled agents.

Prolog Engine

SICStus Prolog– Jasper Java package

PrologEngine– Wrapper class for

SICStus prolog engine

SimplePrologKB– KB operations to

PrologEngine

Jini Prolog KB Service - DPKB

Features.– Heavy-weighted Prolog Engine runs on the server

side. Clients do not have to install native Prolog code.

– Clients can have multiple KB through 1 DPKB service.

Each KB is identified by KB ID and KB password.

Client only sees this

Runs on the server

The Ronin Agent Framework is designed to aid in the development of dynamic distributed system with “intelligence”.

The Ronin Framework introduces a hybrid approach that is based on the composition of the agent-oriented and service-oriented programming design.

Task 2: Merging agent with Jini

Ronin Design Goal

Promote generic agent attributes. Making knowledge sharing possible. Making basic communication negotiation

possible. Independent ACL and network protocol. Making the integration between heterogeneous

agents possible. Simplicity.

Ronin Design

The Ronin Agent Framework defines an open framework that specifies the infrastructure requirements and interface guide line for the agent interaction and communication.

The standard interface and classes that are central (“core”) to the Ronin Agent Framework is called Core Ronin Agent Framework.

Core Ronin Components

Envelope– A meta container for ACL messages.

Effect.– Provides an uniformed structure for delivering

messages. – No network protocol restriction is imposed.

Core Ronin Components

Common Agent Attributes.– Describes agent features to distinguish one agent

from another in ways that are domain independent.– The attribute types and semantic meanings are

defined by Ronin in the domain independent fashion.

Effect– Allows agents to find each other in a domain

independent way, using the generic agent attributes.

Ronin Components

Domain Agent Attributes.– Describes agent features to distinguish one agent

from another in ways that are domain dependent.– The framework does not define the types and

semantic meanings of the Domain Agent Attributes. Effect

– Allows agents to find each other using the domain knowledge as an alternative to the common agent attributes.

Ronin Agent.– A specialized version of a Jini service with the

agent-oriented abstraction. – Provides services through agent communication.– Can be realized by either hardware or software.– Required to have at one Agent Deputy if it is

intended to be contacted by other agents.– Required to have a set of Agent Attributes and

Agent Domain Attributes.

Core Ronin Components

Core Ronin Components

Ronin Agent Deputy.– A specialized version of a Jini service proxy object. – Responsible for handling the communication and

the interaction between its owner Ronin agent and other agents in the system.

Core Ronin Components (Agent Deputy Cont.)

Effect– Provides a local agent representation. – The mobile front-end of the agent.– Hides the actual agent implementation from other

agents. – Making flexible and robust agent communication

possible. Using store-and-forward mechanism. Mailbox mechanism and more …

Proxy Object

An object diagram of a proxy structure at runtime.

Client Proxy Print Server

Core Ronin Components

Ronin Agent & Agent Deputy– Ronin agent owns one or many Agent Deputies. – Agent Deputy will register with Lookup Service

along with Agent’s attributes.– Agents communicate with other agents through their

Agent Deputies.– Agent Deputy is responsible for choose the right

communication scheme to delivery messages back to the owner agent.

Core Ronin & Ronin Implementations

Core Ronin only defines interfaces and classes that are needed to get things to run.– The idea is similar to net.jini.core

Ronin Implementation ~= com.sun.jini Core Ronin has 3 packages

– edu.umbc.ronin.attributes– edu.umbc.ronin.deputy– edu.umbc.ronin.language

Core Ronin

Agent Group Ronin Implementation

Feature.– Ronin Agent/Jini Service Shell (template).

Jini join & lookup specific information can specified in a Java Properties.

Dynamically initialize Agent Attributes and Domain Attributes based on Properties file.

– Provides sufficient library for implementing agent-oriented Jini services.

– Guarantees that deploying Ronin agents is not harder than deploying traditional Jini services.

Agent Group Ronin Implementation

5 Packages– edu.umbc.agent.ronin.agent

Ronin Agent Shell and Message Dispatching utilities.

– edu.umbc.agent.ronin.deputy AND edu.umbc.agent.ronin.deputy.transport

Out-of-box Agent Deputy implementation.

– edu.umbc.agent.ronin.lookup Customzied Lookup Tools for finding Ronin Agents.

– edu.umbc.agent.ronin.util Ronin Agent Shell Admin tools and misc. tools.

Out-of-box Agent Deputy

Receive Remote Envelope

A Smart Jini System

We have developed a distributed system based on the Ronin framework and DPKB to demonstrate their feasibility.

The system is called Agents2Go.

Agents2Go

Components in the system:– An user with a PDA.– A Broker Agent.

Capable of making recommendations to users on local restaurants information.

– A DPKB service.– A number of restaurant agents.

Provides dynamic information about the restaurant, e.G. Wait time etc.

Agents2Go

PDA finds the Broker Agent through Jini lookup service.

PDA submits recommendation request to the Broker with constraint and personal profile attached.

Broker preprocesses the request, constraints, and profile info, and then converts them into a number of queries in Prolog. It depends on the DPKB service for knowledge representation and reasoning.

Agents2Go

If the Broker KB does not have sufficient knowledge to make a recommendation, then the Broker will try to discover and lookup local restaurant agents through the Jini lookup service.

Broker negotiates with these agents using descriptive agent communication language, KQML. Message content is expressed in Prolog.

Agents2Go

After the Broker has received enough information, it restarts the recommendation inference process.

Broker replies the original request with the recommendation. The reply is expressed in the format that can be understood by the PDA.

Screenshots

Netform is a Palm application.

Netform allows a user to find his/her favorite restaurants.

Screenshots

User can specify various matching attributes.

We are looking for – Japanese cuisine– Has dinning in– Has reservation– Price range between $10

and $20.

Screenshots

Making connection to the network.

Connecting the proxy on the network.

The proxy is responsible for contacting agents in the system.

Screenshots

A matched result is send back from the proxy.

Future Works

Make the specifications and the source code of Ronin framework to be available to the community.

Use BeamML for constructing Agent Deputy dynamically.

Add support for Java Servlet.

Conclusion

Java + Jini provides an excellent platform for developing distributed system.

Java + Jini + Agent provides an excellent platform for developing intelligent distributes system.

Ronin framework provide a flexible and robust development platform for building dynamic distributed system with “intelligence”.

More Information

Harry Chen– University of Maryland Baltimore county– Email: hchen1@acm.org

Related project and URL– Dynamic Negotiating Agents (DNA)

http://www.cs.umbc.edu/dna

– Agent Web http://www.cs.umbc.edu/agents