JATLite (Java Agent Template, Lite) is a package of programs written in the Java language that allow users to quickly create new software "agents" that communicate robustly over the Internet. JATLite also provides a basic infrastructure, shown in Figure 1, in which agents register with an Agent Message Router (AMR) using a name and password, connect/disconnect from the Internet, send and receive messages, transfer files with FTP, and generally exchange information with other agents on the various computers where they are running.
Figure 1: JATLite Agent Message Router
Among the diverse agent definitions, the JATLite is especially useful for developing an infrastructure for Typed-Message Agents, defined in terms of communities of agents. The community must exchange messages in order to accomplish a task. They must use a shared message protocol, such as KQML, in which the some of the message semantics are typed and independent of the application. And semantics of the message protocol necessitate that the transport protocol not be only client/server but rather a peer-to-peer protocol. An individual software module is not an agent at all if it can communicate with the other candidate agents with only a client/server protocol without degradation of the collective task performance.
Effectively, this definition means that agents can cooperate with each other to solve a problem and can initiate messages to each other without waiting for a client query in order to do so. This roughly corresponds to to the general concept of autonomy more vaguely discussed in various papers. Many other kinds of software are also called agents, including webcrawlers that look for information or do comparison shopping for the user. JATLite may be used to build such software but is not a general shell for such applications.
Some agents are also described as intelligent and/or mobile. See Are JATLite agents intelligent?.
KQML, the Knowledge Query and Manipulation Language, is a language and protocol for exchanging information and knowledge. It resulted from a larger effort, the DARPA Knowledge Sharing Effort which is aimed at developing techniques and methodology for building large-scale knowledge bases which are sharable and reusable. For more detail, see the JATLite Detailed Technical FAQ.
Agent systems are difficult to build and debug from scratch. And new agent systems should be built in Java so that agents can run on heterogeneous platforms and make use of very lightweight applets as temporary agents. JATLite provides a set of Java templates and a ubiquitous Java agent infrastructure that makes it easy to build systems in a common way,
JATLite provides a template for building agents that utilize a common high-level language and protocol. This template provides the user with numerous predefined Java classes that facilitate agent construction. Furthermore, the classes are provided in layers, so that the developer can easily decide what classes are needed for a given system. For instance, if the developer decides not to use KQML, the classes in the KQML layer are simply omitted. However, if that layer is included, parsing and other KQML-specific functions are automatically included.
The most unique feature of the JATLite is the agent infrastructure packaged with it. Traditional agent systems use an Agent NameServer (ANS) for making connections between agents. An agent uses an ANS simply to look up the IP address of another agent and then uses that address to make a TCP socket connection directly to that agent for the purpose of exchanging messages.
With such an ANS, if the IP address of the other agent changes, the first agent finds out when the next attempt to send a message fails. If the second agent "crashes" in any way, it is the responsibility of every other agent with whom it was communicating to properly save the failed messages and resend them later somehow. It is easy to see how any distributed computation could easily fail under such conditions.
With the JATLite infrastructure, all agents make a single connection to the AMR. The AMR forwards all agent messages by name to the last known IP address. Further, just like an email system, the AMR buffers all messages and saves them until the receiving agent acknowledges receipt with a delete message to the AMR.
Thus agents may send both connect and disconnect messages to the AMR, as well as their initial registration message. The distributed computation is always preserved by the AMR.
The JATLite Agent Message Router(AMR) is a specialized
application which receives a message from the registered
agents and routes the message to the correct receiver. The
received messages will be queued to the file system.
Use of the AMR has several advantages
over a more traditional Agent NameServer(ANS):
"Intelligent" wrt software seems generally to mean that the software is easier to use than most programs. There is no "silver bullet" for constructing such functionality.
JATLite alone does not endow agents with specific capabilities beyond those needed for communication and interaction. In particular, JATLite does not, by itself, construct "intelligent agents" that seek information or automate human tasks, as discussed in the Artificial Intelligence community. The developer is left free to use whatever theories and techniques are best suited for the targeted application or research. A good example is JESS. Jess expert systems have been wrapped with JATLite to produce intelligent agents based on Java and rules. JATLite does not facilitate the use of any particular reasoning tools, but it does not prevent one from using them.
However, it does provide a robust substrate for building such intelligent agents. The JATLite packaged infrastructure allows agents to be portable (e.g., on a laptop computer), to move from one machine to another, and to connect and disconnect from the Internet with automatic queuing and buffering of incoming messages. These features, found to be necessary for robust agent behavior in projects where software agents occasionally fail or migrate, is provided by the Agent Message Router (AMR) infrastructure.
The AMR also may be used by mobile agents. While the JATLite infrastructure provides no framework for autonomous agent migration, the AMR is very suitable for message passing among agents that often change location. That is, mobile agents expect a "docking" framework on each computer that allows the agent to decide to go to it and act to do so without the intervention of a user. JATLite does not assume any such framework and does not care whether or not a user acted to move the agent but does allow roving agents to collect their outstanding messages at will.
This unique facility also overcomes Netscape security restrictions on applets, allowing them to be full-fledged but highly migratory lightweight agents. Applet agents can be run from any browser: there is no need for any specialized "docking" software to be installed.
JATLite facilitates especially construction of agents that send and receive messages using the emerging standard communications language KQML (see http://www.cs.umbc.edu/kqml/ for the current KQML standard). The communications are built on open Internet standards, TCP/IP, SMTP, and FTP. However, developers may easily build agent systems using other agent languages, such as the FIPA ACL using the JATLite layers.
JATLite does require the use of the JDK 1.1 from Sun, and browsers executing JATLite applets should use the JDK 1.1 plugin. For more detail, see What are the JATLite assumptions?
As of August 1997, JATLite is being used or evaluated for creating agent interfaces for a variety of applications including commercial CAD software (AutoCad ARX14), decision and dependency tracking programs (Redux), prototypical financial analysis agents (Yamaichi Information Systems Inc.), rapid prototyping services (Cybercut, RPL), and information searching and retrieval agents (Tektronix).
JATLite is tested extensively within the CDR to investigate the composition of engineering software agents for design analysis and optimization, and for the coordination of the design and development process, especially in cooperation with the Toshiba cooperation.
Figure 2: JATLite approach to wrapping legacy software
A primary application of JATLite is to "wrap" existing programs by providing them with a front-end that allows them automatically to communicate with other programs, sending and receiving messages, files, etc. Figure 2 above illustrates the concept.
Even if no new autonomous agents are ever built, agent technology provides a "glue" for composing legacy software. JATLite provides standard software for agent communications. KQML and other agent protocols provide standards for message exchange. Various process analysis systems can then provide guidance for the composition of specific messages among the system agents.
The key idea is to communicate between software modules using the lowest common denominator: ASCII strings, It is not necessary to conform to any object-oriented language. In fact, the use of object platforms such as CORBA is not necessary, though feasible. All any software module need do is to pass and receive ASCII strings that conform to an agreed upon protocol such as KQML and some arbitrary "inner" language. A common inner language is KIF, but ProcessLink, for example, simply uses a syntax of keywords and value pairs.
It is particularly easy to integrate JATLite with other Java software, but JATLite agents have also been integrated with C, C++, and Lisp code. For more detail, see What are the JATLite assumptions?
Background and Status Questions
Why was JATLite built?
The roots of JATLite date to 1993, when CDR began to use the KQML language for agent communications. After developing a number of C, C++ and Lisp agents with KAPI, it was clear that a standard approach was needed for providing the basic communication and interaction functions needed by all agents. In early 1996, a CDR Masters student, H. Robert Frost developed the Java Agent Template, under the guidance of Prof. Mark Cutkosky and a senior PhD student, Gregory Olsen, who had developed some of the earlier agents. The Java Agent Template was made available to researchers who wanted to download it from the CDR web site. The philosophy and guiding ideas behind the Java Agent Template were outlined in a paper by Frost and Cutkosky in September, 1996 . Three increasingly sophisticated versions of the Java Agent Template were developed by Mr. Frost before his departure from CDR. The final version included provisions for automatically loading class libraries, with a mix of procedural and declarative information.
In 1996 Messrs. Frost and Olsen left CDR to join a software startup called Cross Route Systems Inc., in Redwood Shores, CA. (The technology being developed by Cross Route is unrelated to Java agents.) With the departure of Mr. Frost, it was decided by Prof. Cutkosky his students, and CDR Research Associate Dr. Charles Petrie, that the Java Agent Template had become too complex for follow-on support. Further, it incorporated specific research theories of agenthood that were not necessary in a general agent infrastructure. And finally, this original system did not include the Agent Message Router, which we found to be necessary to run applets as agents.
We decided to do something different. In 1996, Mr. Heecheol Jeon had already modified a version of the JAT in March of 1996 to include an early prototype of the AMR so that we could run applets. Stripping out the code that committed the builder to the specific agent architecture was difficult, so we largely started over with the experience we had gained from the first JAT.
The result was JATLite, a new software package that was smaller, faster, and more robust, and focused only on providing the connection and communications infrastructure that all agents need. The principal developer of JATLite has been Mr. Heecheol Jeon, a PhD student at CDR, with assistance from a few other CDR students and under the supervision of Prof. Cutkosky and Dr. Petrie.
What is the current status of JATLite?
The current version of JATLite, version 0.4 Beta, has been made available to researchers who download it from this web site. To obtain the software, users fill out a form giving their name, address, email address, and company affiliation. You should have a good familiarity with the JDK 1.1. Then follow the JATLite Setup Guide.
Our intention is to continue to provide JATLite free of charge for researchers who wish to evaluate it. Thus far more than a 1,000 researchers from around the world have downloaded various versions of JAT and JATLite. We also encourage users to send technical questions and comments to <firstname.lastname@example.org>. We do not formally support the software, but we do our best to answer questions, fix bugs, and make improvements. For more information, see the JATLite Support page.
How do I license JATLite?
Our long term goals are to continue to refine JATLite and to use it as a substrate for agent-based applications in engineering and business. JATLite source code is available free under the GNU Public Licence. You can directly download the source codes from download area.
At this point we at CDR have no particular plans to commercialize the JATLite technology. We would be very happy to cooperate with anyone wishing to do so.
JATLite Technical Questions
What are the JATLite capabilities?
What are the JATLite assumptions?
JATLite can run on any platform that supports the Java development kit JDK1.1 from Sun Microsystems Inc., including Windows95, WindowsNT, Solaris, Mac OS8. Modifications may be needed for other Java environments. Applet agents can be run using a WWW browser such as Netscape or Internet Explorer, or Sunís applet viewer. JATLite agents also utilize standard TCP/IP communications and sockets for interprocess communication. All communications are assumed to take place through Agent Message Routers (AMRs), which are stand-alone Java programs running on hosts connected to the Internet.
In order to be JATLite-compliant, it is only necessary that an agent send ASCII messages conforming to the general KQML syntax and also make connections with the AMR using the JATLite AMR connection protocol. We have provided special patches to facilitate using KAPI agents in particular.The general operating assumptions are:
What are the JATLite layers?
The JATLite architecture is organized as a hierarchy of increasingly specialized layers, so that developers can select the appropriate layer from which to start building their systems. Thus, a developer who wants to utilize TCP/IP communications but does not want to use KQML can use only the Abstract and Base layers as described below.
Figure 2: JATLite is built as a series of increasingly specialized layers
What are the future extensions planned?
In the future we hope to add an email communications layer to complement the TCP/IP and FTP capabilities. The email layer using SMTP will allow JATLite agents to communicate with other agents (software or human) via electronic mail. This capability will be useful for communicating with programs that are inside corporate "firewalls."
We and others continue to work actively on several extensions, one of which is a method of allowing a hierarchy of AMRs to be used in much the same way that the Internet domain names work. This will allow JATLite based-systems to scale in the same way. To get the latest news, be sure to join the jatlite-users list.
Although the AMR is by now well-tested, the architecture is certainly subject to single-point failure. In practice, we note that a) the crash of a single agent can disturb a distributed computation using an ANS, and b) most Internet systems, such as email servers, work on the same principle. In order to make the AMR more robust, we do plan to add a self-checking and self-restarting daemon to the AMR to make possible AMR crashes, perhaps due to a machine crash, less problematic. In any case, the messages are saved to files.
In our own work we will continue to use the KQML language capabilities, but we recognize that many others will take advantage of JATLite's modular construction to swap out the KQML layer and use their own language such as SQL, for database transactions, or the FIPA ACL.
Why not use CORBA and Java RMI?
CORBA and RMI are certainly compatible with JATLite and can be used together in a number of ways. If the language of your agent does not have a Java interface, for example, you may want to use CORBA as a translator.
As a complete replacement for JATLite, there are two disadvantages. One is the requirement that all software modules send CORBA objects. The other is that one has to rewrite the AMR.
Are there some example applications?
As of July 1998, JATLite is being used or evaluated for creating agent interfaces for a variety of applications including commercial CAD software (AutoCad ARX14), design decision and dependency tracking, constraint management, model-based enterprise control, agent development education including an agent version of CLIPS in Java (JESS), rapid prototyping services (Cybercut, RPL), prototypical financial analysis agents, information searching and retrieval agents, and ship design and construction, etc.
For specific technical hints and code examples, see the JATLite Examples and Tips.
 H.R. Frost and M.R. Cutkosky, "Design for Manufacturability via Agent Interaction," Paper No. 96-DETC/DFM-1302, Proceedings of the 1996 ASME Computers in Engineering Conference, Irvine, CA, August 18-22, 1996, pp. 1-8.
 C. Petrie, " Agent-Based Engineering, the Web, and Intelligence," IEEE Expert December 1996.
 H. Jeon, C. Petrie, M. R. Cutkosky, " JATLite: A Java Agent Infrastructure with Message Routing,", IEEE Internet Computing Mar/Apr 2000.