Jam agents in a Nutshell Version 65 76i 1



Download 391.89 Kb.
Page1/15
Date09.06.2017
Size391.89 Kb.
#20093
  1   2   3   4   5   6   7   8   9   ...   15
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


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

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



    1. Download 391.89 Kb.

      Share with your friends:
  1   2   3   4   5   6   7   8   9   ...   15




The database is protected by copyright ©ininet.org 2024
send message

    Main page