Our registration server runs on port 9010 instead of the usual port 80. Perhaps you are behind a firewall that does not allow you to reach ports other than 80. If you click here and send a request, we will register you manually and send you the download details.

Click here to generate an email to jack-support

Your email address is required for us to send you a password to enable you to install JACK and use it for the duration of your evaluation period. We do not use any information provided by you for any other external purpose and any information provided by you is treated with the utmost confidence. Click here to read our Privacy Policy

Yes you need a JAVA Development kit or equivalent installed on your computer. A Java runtime by itself is not enough.

Your evaluation package comes complete with a set of examples. The examples are in the sub-directory aos/jack/examples. Alternatively, look under the Help menu in the JACK Development Environment (JDE). There is also a set of practicals in the sub-directory doc/practicals.

Yes. Look under the Help menu.

Your evaluation package comes with a complete set of JACK documentation. These documents (in PDF and HTML format) are in the doc subdirectory. There should be a link in the automatically installed menu, or shortcuts. If not, point your browser at the file doc/jackdocs.html in the place where you installed JACK. It will guide you to all of the available documentation.

This is a Java installation problem rather than a JACK one specifically. It sounds like your old Java runtime or JDK has become stuck in the registry. Perhaps the previous Java that was installed did not get uninstalled properly and now there are incompatible Java components mentioned in the registry.

Although tedious, we suggest the following:

1. Uninstall all Java or JDK (via Control Panel).
2. Make sure all Java or JDK are actually removed. (E.g. delete the C:\Software\JavaSoft folder if it exists and the JDK folder, wherever you installed it)
3. Search the registry for any key or value containing "java" and remove it!ÊÊ (Use the "Run..." command and type 'regedit', then use the find command within regedit)
4. Install the new JDK again.
5. Make sure you have PATH & CLASSPATH set properly. Check that the "BIN" directory of the JDK is in your PATH since the Java installer does not seem to do this for you.

The JACK compiler needs to be able to locate your java compiler, javac. The message indicates that the java compiler can't be found. You need to have installed a JDK (Java Development Kit) and you need to add the bin directory of wherever your JDK is installed to the PATH environment variable. Unfortunately the Java installer may not do this for you. Under Windows 2000, you can do this from the Control Panel, under System, in the Environment tab. Under Windows 95/98 etc. you would need to edit C:\AUTOEXEC.BAT.

To test this, open a Command Prompt window and type javac and see if the command is found. If found, it should complain about being called without any java file arguments. If it is not found, then there is still a problem. You may need to log out or reboot after setting the PATH variable.

This happens when any plan step of a reasoning method (e.g. body()) takes an unreasonably long time to complete (about half a second). It usually means that something is calling out to Java code and not coming back, normally a bug with your code. Individual plan steps must execute quickly. In any case, the JACK kernel leaves that thread alone since it is taking too long and starts a new one to handle other plans. If the original one ever comes back then all is ok. If not, then the agent mentioned is hung.

Often this is harmless but it might indicate a bug in your code. There are several ways you can include a lengthy computation within a plan step should the need arise. One quite flexible way is to use an Action cursor (aos.jack.util.cursor.Action). See the Jack User Guide for details.

If the process is using a lot of CPU, then you may simply be stuck in an infinite loop. Otherwise, there may be nothing to do because JACK is just waiting around for an event to process. There are tracing options described in the JACK User Guide which may be of use.

JACK applications never exit on their own. The JACK kernel is always waiting for an event to process. If you want the application to exit, you should call System.exit(0) explicitly when required.

Within a single JVM, all JACK agents are (normally) executed by just one thread. JACK includes a time-based scheduler, which ensures that all agents get a slice of execution. On top of that, each JACK agent can have many tasks pending at the same time so that each agent can specify its own task manager. This provides the task execution policy for that agent. The default is for the agent to stay committed to a task as long as possible.

Each JACK plan is transformed by the compiler into steps in a finite state machine that can be executed by an agent's task manager. The executing thread may leave the plan (task) and come back to it later, and then continue progressing the plan (task) later.

Thus, JACK has only one thread, plus an additional one for receiving messages.

In many applications, the code within an agent is "java interface code", which may be invoked by threads other than the JACK scheduling thread. The message receiving thread is an example of such a thread.

I get strange compilation errors but if I clean up first everything is ok. Why is that?

Some versions of the JACK compiler had trouble telling apart Java files that were automatically generated by JACK from user provided Java files. This lead to many name clashes due to duplicate declarations. Newer versions of the compiler should be ok but if in doubt, clean it out!

The Belief-Desire-Intention (BDI) agent model is an event-driven execution model providing both reactive and proactive behavior. The BDI agent model is built on a simplified view of human intelligence. In it, agents have a view of the world (Beliefs), certain goals they wish to achieve (Desires), and they form Plans (Intentions) to act on these using their accumulated experience. Agents that are written using the BDI model are at a level of abstraction closer to normal human experience.

JACK supports code re-use through the Capability concept.

JACK Version 1.3 introduced Capabilities to address the issues of and code re-use in the context of the agent A JACK capability represents a cluster of functional components to be used as building blocks during the development of BDI agents. As a design concept they assist in the structuring of agent functionality into meaningful units. At the code level they reduce the amount of source code required when Capabilities are used across different types of agents. Capabilities also support the building of agent code libraries that can be plugged into new developments.

JACK agents are built as components within an application and allow seamless connection with legacy software. JACK agents are accessible in Java code as normal Java objects, enabling the agent's reasoning to be integrated with the processing of legacy applications.

JACK also includes support for inter-process data transport between Java and C++ processes (using JACOB). JACK may also be used with the Java Native Interface (JNI) to inter-link C++ and Java code within a single process.

JACK has a modular design incorporating a generic inference engine that can be tailored by means of plug-in code modules. The default agent model provided is the BDI agent model, which is aimed at "practical reasoning", i.e. reasoning for action. The BDI inference engine implements the procedural reasoning principle of processing plans to fulfill goals.

JACK 4.0 also provides a Teams reasoning model.

What communication protocols does JACK use?

The JACK package includes a standard communications layer that uses UDP/IP-based messaging with a reliability layer. While JACK is delivered with a communications infrastructure of its own, an application may also use another means of communications (such as CORBA, RMI, etc.).

JACK agent messages are declared in a similar way to Java classes and end up being Java objects to be sent and received. These objects are then streamed using Java serialization, or by using the companion package JACOB, for improved messaging performance and flexibility (the JACOB binary format is up to ten times faster than Java serialization).

At the programming level, JACK agents interact via send and reply primitives. These support multi-casting; that is, the same message may be sent to several recipients and an agent may wait for the replies in a resource-free manner. Higher level communications protocols are implemented as capabilities that are re-usable among agents.

JACK agents communicate via peer to peer messaging. Messages are sent to a named agent at a named portal, and it is unimportant to the sending agent whether the receiver is in the same process or in a different process. JACK agents are therefore easily distributed to multiple processes and even multiple machines.

JACK agents are extremely efficient and light weight. This is demonstrated by having JACK running on a handheld Psion 5mx.

Benchmarks using JACK have shown the following:

1. Agents can be created at a rate of over 1,000 per second. An example program which times the creation of 100,000 agents reported 72,811ms total time running on a typical midrange PC under Linux.
2. Agent destruction delay is insignificant. It is of the order of 10µ-s (ten microseconds) or 100,000 agents destroyed per second. An example program which times the destruction of 100,000 agents reported 329ms total time running on an average PC under Linux.
3. Agents can send messages to another agent within the same process in times of the order of 10µ-s (ten microseconds) or 100,000 messages per second. An example program which times the sending of 200,000 such messages reported 2662ms total time running on an average PC under Linux.