JAM Agents
in a Nutshell
Version 0.65+0.76i1
(November 2001)
Marcus J. Huber, Ph.D.
marcush@marcush.net
Intelligent Reasoning Systems
Oceanside, California
http://www.marcush.net
Draft of November 1, 2001
Table of Contents 2
1.INTRODUCTION & BACKGROUND 4
1.1.Overview 5
1.2.Unpacking the JAM Agent distribution 7
1.3.Running and building JAM 7
2.BELIEFS 10
3.GOALS 12
3.1.Top-level Goals 12
3.2.Subgoals 13
4.PLANS 15
4.1.Expressions 15
4.2.Plan Body 17
4.2.1.Plan Variables 19
4.2.2.Plan Actions 19
4.2.3.Plan Comments 31
4.3.Plan Name 31
4.4.Plan Documentation 31
4.5.Plan Execution Behavior 31
4.5.1.Plan Goal 31
4.5.2.Plan Conclude 32
4.6.Plan Context 32
4.6.1. Predicates 34
4.7.Plan Precondition 35
4.8.Plan Utility 35
4.9.Plan Attributes 35
4.10.Plan Effects 35
4.11.Plan Failure 36
5.CYCLIC FUNCTIONALITY 39
6.INTENTION STRUCTURE 40
7.SOURCE-CODE API 41
8.PRIMITIVE FUNCTION INTERFACING 44
8.1.PrimitiveAction Interface 44
8.2.UserFunctions.java 47
8.3.Invoking Legacy Code 48
8.4.Predefined Functions 48
9.THE INTERPRETER 59
10.CHECKPOINTING and MOBILITY 63
10.1.Checkpointing 63
10.2.Mobility 63
11.KNOWN BUGS AND LIMITATIONS 65
12.EXAMPLE PLANS 66
agent-go.jam 66
blocks-world.jam 66
basic.jam 66
checkpoint-agent.jam 66
memberaccess.jam 66
load.jam 66
retrieveall.jam 66
variablescope.jam 67
unpost.jam 67
threads3.jam 67
javanew.jam 67
hanoi.jam 67
methodinvoke.jam 67
introspec.jam 67
relations.jam 67
subgoals.jam 67
threads1.jam 67
debugging.jam 68
trycatch.jam 68
doallany1.jam 68
observerfail.jam 68
nativejava.jam 68
precond.jam 68
lisplist.jam 68
succeedfail.jam 68
goalsemantics.jam 68
maintain.jam 69
post.jam 69
doallany2.jam 69
threads2.jam 69
wait.jam 69
conclude.jam 69
metalevel.jam 69
parse-string.jam 69
sockets-client.jam 70
sockets-client2.jam 70
sockets-server.jam 70
sockets-server2.jam 70
13.JAM BNF Grammar 71
14.Comparison to UMPRS 74
Similarities 74
Differences 74
15.REFERENCES 75
16.ACKNOWLEDGEMENTS 77
INTRODUCTION & BACKGROUND
JAM is an intelligent agent architecture that grew out of academic research and extended during the last five years of use, development, and application. JAM combines the best aspects of several leading-edge agent theories and intelligent agent frameworks. Influences upon JAM include:
-
The Belief-Desire-Intention (BDI) theories [Bratman88:Plans, Georgeff, etc.]
-
The intelligent agent architectures of the Procedural Reasoning System (PRS) of Georgeff, Lansky, Rao, and others (see [Georgeff86:Procedural, Georgeff87:Reactive, Ingrand90:Managing, Ingrand92:Architecture])
-
The University of Michigan’s implementation of PRS called UMPRS [Lee94:UMPRS, Huber93:UMPRS]
-
SRI International's PRS-CL [Myers97:User]
-
SRI International’s ACT plan interlingua [Wilkins95:Common, Myers97a:Act, Myers97b:Act]
-
The Structured Circuit Semantics (SCS) representation of Lee and Durfee [Lee94:Structured, Lee97:Explicit]
-
Mobility aspects from Agent Tcl [Gray97:Agent], Agents for Remote Action (ARA) [Peine97:ARA], Aglets [Lange98:Programming] and others.
J AM’s family tree is illustrated below in Figure 1, where the small arrows indicate derivation and the large arrows indicate approximate development period.
Overview
Each JAM agent is composed of five primary components: a world model, a plan library, an interpreter, an intention structure, and an observer. This is illustrated in Figure 2. The world model is a database that represents the beliefs of the agent. The plan library is a collection of plans that the agent can use to achieve its goals. The interpreter is the agent’s “brains” that reason about what the agent should do and when it should do it. The intention structure is an internal model of the goals and activities the agent currently has and keeps track of progress the agent has made toward accomplishing those goals. The observer is a lightweight plan that the agent executes between plan steps in order to perform functionality outside of the scope of its normal goal/plan-based reasoning (e.g., buffer incoming messages).
T he JAM execution semantics and behavior is a combination of that of UMPRS and SCS. Changes to the world model or posting of new goals triggers reasoning to search for plans that might be applied to the situation (this list of plans is called the Applicable Plan List, or APL). The JAM interpreter selects2 one plan from this list of applicable plans and intends it (i.e., commits itself to execute the plan). The act of intending the plan places the now-instantiated plan (it has, at this point, a variable binding specific to the current situation) onto the agent’s intention structure, the agent’s multiple-goal runtime stack. The agent may or may not immediately execute the newly intended plan, depending upon the plan’s utility relative to that of intentions already on the intention structure. We discuss this in more depth later in this manual.
The agent developer deals explicitly with the world model, the plan library, the observer, and specification of the agent's initial goals. In addition to the primary components describe above, there exists a function library and interface for specifying and performing low-level, non-decomposable “primitive” functions. This document describes the theory behind each component, how the components interact, important representations and semantics, and any files that are necessary. Samples of files specifying plans, goals, beliefs, and observer procedures are included with the JAM distribution. Before continuing, we describe how to unpack the files in the JAM agent’s distribution and then how to compile and execute a JAM agent.
Share with your friends: |