part of Agent Oriented Programming course@TEK faculty

1. JACK® Intelligent Agents
- a framework overview -
Pedro Valente
AOP course@TEK Faculty
12/12/2011

2. PART I - Introduction
1. Background;
2. Concepts;
3. JACK components;
4. Agent language;
5. Agent Template;
2

3. 1.Background
•JACK™ Intelligent Agents (JACK) is an Agent Oriented
development environment built on top of and integrated
with the Java programming language.
•JACK Intelligent Agents was built by Agent Oriented Software
Pty. Ltd. (AOS), develop initially in 1997. Commercial system.
•Includes all components of the Java development
environment as well as offering specific extensions to
implement agent behavior.
•JACK has been developed to provide agent-oriented
extensions to the Java programming language.
•JACK source code is first compiled into regular Java code
before being executed.
3

4. 1.1 JACK Attributes
• JACK applications are proactive, responsive, social and
Autonomous distributes. They adapt to dynamically changing
environments, without the need for human intervention.
• JACK is built on a lightweight, cross-platform foundation
Compact/Efficient that can run thousands of agents, even on low-spec
hardware such as PDAs.
• JACK applications are resilient to unexpected events, and
Resilient can consider multiple alternatives solutions to a problem
that is unfolding in real time.
• JACK’s development environment allows analysts to
Rapid Specification specify procedures by dragging /dropping graphical
elements onto a canvas.
4

5. 1.2 JACK major design goals
•To provide developers with a robust, stable, light-weight product;
•To satisfy a variety of practical application needs;
•To ease technology transfer from research to industry;
•Enable further applied research
Benefits:
•Agents can coexist in legacy software systems as simple another
object by non-agent software;
•Conversely, Agents can access any other component of a system;
•JACK Agents are not bound to any specific agent communication
language;
5

6. 2 Agent models
Agents: Act in environments
Agents provide a very
effective way of building
applications for dynamic and
complex environments
+ Agents: Act to achieve goals
Develop agents based on
Belief-Desire-Intention
agent metaphor, i.e. develop
software components as if
they have beliefs and goals, Agents: Represent environment
act to achieve these goals,
and are able to interact with
their environment and other
agents.
6

7. 2.1 Agent Oriented Concepts
A Jack agent can exhibit reasoning behavior both
proactively and reactively. It has:
•A set of beliefs(ideas) about the world (its belief set)
•A set of events(happenings) that it may respond to
•A set of goals that it may desire to achieve as a consequence
of an event
•A set of plans that describe how it can handle the goals or
events that may arise.
7

8. 2.2 Agent workflow
•Agent instantiation;
•Waits until its given a goal or event trigger;
•When such a goal or event arises, it determines what course of action it
will take:
• If the agent already believes that the goal or event has been handled (do
nothing);
• Otherwise, it looks through its plans to find those that are relevant to the
request and applicable to the situation.
• If it has any problems executing this plan, it looks for others that might
apply.
•In terms of Plans, agent follow Procedures Manual (set of plans) which
contains a set of steps.
•Models human logic behavior following plans:
• Goal-directed focus
• Real-time context sensitivity
• Real-time validation of approach
• Concurrency
8

9. 3.The Components of JACK
•The JACK Agent Language
• Actual programming language used to describe an agent-
oriented software system;
• Java super-set (extend constructs to represent agent-oriented
features).
•The JACK Agent Compiler
• pre-processes JACK Agent Language source files and
converts them into pure Java;
• Java source code can then be compiled into Java virtual
machine code.
•The JACK Agent Kernel
• runtime engine for programs written in the JACK Agent
Language;
• provides a set of classes that give JACK Agent Language
programs their agent-oriented functionality;
9

10. 4. JACK Agent language
•The JACK Agent Language is built on top of Java;
•Provides a framework to support an entirely new
programming paradigm;
•extends Java to support Agent Oriented programming:
•It defines new base classes, interfaces and methods.
•It provides extensions to the Java syntax to support new agent-oriented classes,
definitions and statements.
•It provides semantic extensions (runtime differences) to support the execution
model required by an agent-oriented software system.
•All the language extensions are implemented as Java plug-ins;
•Each of the JACK Agent Language extensions is strictly typed.

11. 4.1 Java extensions
The JACK Agent Language introduces five main class-level constructs.
These constructs are:
• This includes capabilities an agent has, what type of messages and events it responds to and
Agents (used to define the overall which plans it will use to achieve its goals.
behavior of MAS):
Beliefset (represents an agent’s • The beliefset construct represents agent beliefs using a generic relational model.
beliefs):
View (allows to perform queries on • The data model may be implemented using multiple beliefsets or arbitrary Java data structures.
beliefsets):
Capability: reusable functional • A capability can be made up of plans, events, beliefsets and other capabilities that together
component made up of plans, events, serve to give an agent certain abilities
belief sets and other capabilities
• They are the instructions the agent follows to try to achieve its goals and handle its designated
Plan (instructions the agent follows to try events.
to achieve its goals and handle events):
Event (occurrence to which agent • The event construct describes an occurrence in response to which the agent must take action.
should respond):

12. 4.2 JACK language example
•In bold is unique JACK
syntactic elements;
•Categorize:
•Classes (types)
•Declarations (#-declarations)
•Reasoning Method Statements
(@-statements)
12

13. 5. JACK – Agent Template
agent AgentType extends Agent {
// Knowledge bases used by the agent are declared here.
#private data BeliefType belief_name(arg_list);
// Events handled, posted and sent by the agent are declared here.
#handles event EventType;
#posts event EventType reference; used to create internal events
#sends event EventType reference; used to send messages to other agents
// Plans used by the agent are declared here. Order is important.
#uses plan PlanType;
// Capabilities that the agent has are declared here.
#has capability CapabilityType reference;
// other Data Member and Method definitions
}

14. PART II - Components
1. Components and tools;
2. Inter-agent Communication;
3. JACK extensions;
14

15. 1.JACK Components and Tools
JACK Intelligent Agent is distributed as the following modules:
•JACK Runtime Environment
• The kernel supports the execution of JACK agents, handling multi-threading and
concurrency issues, etc. It also includes a communications layer with a simple agent naming
service.
•JACK Compiler
• This compiles the JACK Agent Language code into pure Java, and calls the Java compiler
to generate executables.
•BDI Agent Model
• This adds support for BDI reasoning, with additions to the language syntax and the runtime
kernel.
•SimpleTeam Model
• This adds support for team-based reasoning with language extensions and kernel additions.
•Agent Development Environment
• The development environment is a GUI for viewing and manipulating JACK applications.
•Agent Debugging Environment
• Consists of an Agent Interaction Display for viewing messaging between agents along with
switches to the kernel for displaying internal execution states.
•JACOB
• JACK Object Modeller is a powerful object modelling toolkit to support object transport and
interaction with existing applications in Java and C++. It will stream objects in a human
readable textual format, a fast binary format and in XML.
15

16. 2.Inter-Agent communication
•JACK Intelligent Agent provides a basic inter-agent
communication layer called dci network for inter-agent
communication (in remote communication).
•Is based on the UDP transport protocol extended with a thin
layer to provide reliable peer to peer communications.
•Agents can address messages (MessageEvents,
and BDIMessageEvents) to one another by specifying the
name of the destination agent and, if applicable, its portal and
host.
16

17. 2.1 Inter-Agent communication
For agents to communicate with one another, the following
requirements must be met:
•The agents must know one another's name.
•The source agent needs to be able to send a message event.
• This is achieved by including a #sends event declaration in the agent's
definition for the required class of message event.
•The source agent must then include code to send the message
event.
• It can do this by calling the send method from code outside a reasoning
method, or the @sendstatement from within a reasoning method.
•The destination agent needs to be able to handle this message
event.
• This is achieved by including a #handles event declaration for this message
event in the destination agent's agent definition.
17

18. JACK Extensions
JACK Teams: An extension to the BDI software model that facilitates agents collaborating in teams toward achieving a goal.
CoJACK: An extension to the JACK platform that adds a cognitive architecture to the agents for eliciting more realistic (human-
like) behaviors in virtual environments.
FIPA JACK: An extension to the JACK platform to support the FIPA Agent Communications Language. AMS –agent
management service, DF – directory facilitator and MTS – message transport system
Prometheus: An agent-centric software engineering methodology for managing the SDLC of a multi-agent based system.
JACK was used as the basis for investigation, comparison, and testing the methodology. The Prometheus involved the
development of the Prometheus Design Tool (PDT) which was a GUI based tool for managing design concerns in the process.
JACK Eclipse Plug-in: A plug-in that facilitates the development of JACK-based systems in the Eclipse IDE. Specifically, the
plug-in adds capabilities to Eclipse to support the JACK file types (such as .plan, .agent, etc.) as well support for JACK plan
language.
JACK WebBot: An extension that embeds the JACK kernel in the Apache Tomcat web server allowing intelligent agents to be
interacted with and formulate responses HTTP requests (via the Java Servlet API).
18

19. Summary
•JACK is an agent development IDE that extends Java,
adding the following constituents:
• Capabilites:
•encapsulate reasoning parts (events, plans, sub-capabilities, etc.) to
provide a certain ability to any agent.
• Plans:
•Instructions
the agent follows to (try) achieve goals and handle
designated events.
• Events:
•trigger plans. Like event handlers in .NET.
• Belief Sets:
•Agent beliefs using a generic relational model
19

20. Online resources
•JACK® Intelligent Agents Official Website
• http://aosgrp.com/index.html
•Wikipedia definition
• http://en.wikipedia.org/wiki/JACK_Intelligent_Agents
•JACK® Intelligent Agents: Agent Manual
• http://www.aosgrp.com/documentation/jack/Agent_Manua
l_WEB/index.html
•FIPA JACK – A plugin for JACK Intelligent Agents
• http://www.cs.rmit.edu.au/agents/protocols/fipajack.pdf
20

21. PART III
JACK agent Development Environment (JDE)
•Setting Up JACK with Java;
•Compiling and Executing a Sample Project;
“Multi-agent systems can be written in Java code and the JACK plan language in a standard IDE, although the platform provides an agent-centric IDE called
the JACK Development Environment or JDE. The JDE provides graphical tools for writing plans, connecting plans to agents, managing inter-agent
communication, as well as compiling and running. The JDE also provides graphical tools for debugging and tracing the execution of plans and inter-agent
message passing”
21

22. Setting Up JACK with Java
Setting Up JACK with Java:
•Install Java Development kit;
•Define Java Classpath and Path
environment variables; Table - JACK File extensions
•Download JACK evaluation copy*;
•Install with a valid JACK key;
•Run IDE;
•In file menu, choose one:
• Create a new project;
• Open an existing project;
* http://www.aosgrp.com/products/jack/registration/regform.html Solution Explorer Panel
22

23. Running a Sample Project
Follow the steps listed below to execute the ATM-Graphical example:
•Help -> Create Project from Example -> atm-graphical
•Choose a folder where you want the project to be loaded.
•Within a few seconds, the project will be loaded.
•Jack has provided a compiler utility:
• Click on Compiler Application;
• Click the COMPILE Button;
• Jack will generate appropriate Java compliant files, and will switch the compiler utility to
Output/Errors Tab;
• In the same tab, if you see this: [JackBuild Done], that means compilation was successful
and that Jack has transformed the source code into pure Java form;
• Now you are ready to go. Click the Run Application Tab;
• Every Java application has one entry point main() which is always in a *.class file;
• In this example, it is Main.class;
• Double click it, and wait.
•A simple GUI of the Graphical ATM Machine will appear;
•Your account number is 10, pin code is 10 and you have 1000USDs initially.
23

24. Play with it.
Enjoy!
24