1. JACK® Intelligent Agents
a framework overview

2. 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 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. 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. 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. Agent Models
Agents provide a very effective way of building applications for dynamic and complex environments
Develop agents based on Belief-Desire-Intention agent metaphor, i.e. Develop software components as if they have beliefs and goals, act to achieve these goals, and are able to interact with their environment and other agents.

6. 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. 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. 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. 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.

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

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

12. 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.
Simple Team Model
This adds support for team-based reasoning with language extensions and kernel additions.

13. JACK Components and Tools
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.

14. Inter-Agent communication
For agents to communicate with one another, the followingrequirements must be met:
The agents must know one anothers name.
The source agent needs to be able to send a message event.
This is achieved by including a #sends event declaration in the agents 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 agents agent definition.

15. 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).

16. Summary
JACK is an agent development IDE that extends Java, adding the following constituents:
Capabilities:
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

17. Online resources JACK® Intelligent Agents Official Website
Wikipedia definition
JACK® Intelligent Agents: Agent Manual l_WEB/index.html
JACK® Agents Practicals

18. 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” 

19. Setting Up JACK with Java
Install Java Development kit;
Define Java Classpath and Path environment variables;
Make sure that CLASSPATH is set to include jack.jar and the root path for your application.
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;* 

20. DOWNLOAD & INSTALLATION INSTRUCTIONS
Mac OS X: Download and double-click the file to begin the installation process Microsoft Windows: Download and double-click the file to begin the installation process Linux: Download and execute the file to begin the installation process bit Installer: OR bit Installer:
For product password of JACK installation , please send to or