The first step for any application is to represent the possible actions for the domain. These actions are defined (using the Act-Editor) as a collection of Acts which can be translated into the internal operator/procedure representations of both the planner and executor.
A typical use of Cypress to implement a taskable, reactive agent has the executor continually monitoring the world for additional goals and events that might require action in response. When a plan is required or requested (in response to an event in the world), the executor makes the appropriate request of the planner. The executor continues to monitor and respond to the world while the planner plans. The plans generated by the planner are translated to Acts for execution. The executor executes the plans produced by using Acts at lower levels of abstraction to perform actions that have not been explicitly planned, and invokes the planner when replanning is required.
Using the operators translated from the Act representation, the planner generates plans in response to user-specified goals. The user can optionally instruct the planner to automatically employ the uncertain reasoner to reason about uncertain information while making decisions in the planning process. In particular, the uncertain reasoner can be invoked to choose among alternative objects and resources for use in the plan and to choose among alternative operators that can be applied to achieve a goal, based on user-supplied domain information. The uncertain reasoner can be called by the executor during plan execution when so directed by an Act. Thus, the domain programmer indicates those situations in which the uncertain reasoner should be employed.
Cypress supports run-time replanning. Should an unexpected problem arise during execution of the plan, the executor recognizes the problem, calls the planner to produce a new plan, and continues executing those portions of the plan that were not affected by the problem. Upon receiving a new plan, the executor would reconcile it with its current state and continue execution.
Cypress has been applied to joint military operations planning, in a manner that parallels the above description. For this application, the planner uses domain knowledge in the form of Acts to generate employment and deployment plans for dealing with specific enemy threats, using the uncertain reasoner to choose military units based on uncertain information about both friendly and enemy units. (Click here for more details on planning in this domain.) The plan is translated to an Act for execution, and the executor employs a suite of lower-level Acts during execution that define the execution steps for the actions that the planner assumes as primitive. The executor responds to unexpected events with Acts that encode standard operating procedures. When execution of the plan reaches an impasse because of some unexpected changes in the world, it invokes the planner to provide an alternative plan, while continuing execution of activities not affected by the failure.
A critical issue in any application is dividing responsibility between the planner and executor. In principle, each can execute Acts at any level of abstraction. In practice, the planner should not plan to the lowest level of detail and the execution system should not execute very abstract actions, unless forced to do so by time limitations. For these reasons, a fixed level of abstraction is specified for each application that serves as an interface level between planning and execution. The planner plans down only to the interface level, while the executor will accept plans at that level and attempt to execute them using actions from that level of abstraction or below. For the military operations domain, nine levels of abstraction are employed in representing domain actions. The planner plans through five levels of abstraction, at which point actions are at the level of deploying forces, mobilizing units, and establishing patrols. The executor employs Acts from the remaining four levels of abstraction during execution. There are no recursive operators in these levels; thus, the executor performs at most four levels of subgoaling for this domain.