Sequential Task

The defining property of a sequential task is that its subtasks must be executed in a single, predetermined linear sequence. This creates a total order where each subtask has exactly one predecessor (except the first) and one successor (except the last).

• Example: The task Bake Cake decomposes into the strict sequence: [Preheat Oven] → [Mix Ingredients] → [Pour Batter] → [Bake] → [Cool]. The Bake subtask cannot logically occur before Mix Ingredients.
• This contrasts with parallel tasks (concurrent execution) or unordered tasks (any order is valid).

Each subtask in the sequence establishes a specific world state that serves as the precondition for the next. Execution fails if a subtask's preconditions are not met by the state produced by its predecessor.

• Mechanism: If subtask T_i has effect E, and subtask T_(i+1) has precondition P, then the planner must ensure E → P (E implies or establishes P).
• Example: In a Print Document task, the subtask [Load Paper] has the effect paper_loaded=true, which is a direct precondition for the subsequent [Start Print Job] subtask.

Given a fixed initial state, a sequential task has a single, deterministic decomposition path. There is no branching or choice in the order of operations, which simplifies plan verification and guarantees reproducible outcomes.

• Planning Implication: HTN planners do not need to evaluate alternative orderings for the subtasks within a single sequential compound task, reducing the search space.
• Use Case: This is ideal for encoding rigid standard operating procedures (SOPs), safety-critical protocols, or physical processes where the laws of physics dictate order (e.g., assembly).

The sequence itself represents a set of implicit temporal constraints. Formally, for a sequence [T1, T2, T3, ..., Tn], the constraint T_i < T_(i+1) holds for all i, meaning T_i must end before T_(i+1) begins.

• Contrast with Explicit Constraints: In more complex hierarchical plans, explicit before(T_a, T_b) constraints may link tasks across different branches. In a pure sequential task, these constraints are inherent to the decomposition.
• Scheduling: This simplifies execution scheduling for agents, as the timeline is fully prescribed by the decomposition.

A failure in any subtask typically renders the entire sequential task incomplete or failed. The sequence acts as a logical atomic unit where success requires the success of all constituent parts in order.

• Error Handling: This characteristic necessitates robust replanning strategies. If T_k fails, the system must either retry T_k, repair the state to satisfy its preconditions, or decompose an alternative high-level task.
• Example: In a Process Customer Order task, if the [Charge Credit Card] subtask fails, the subsequent [Dispatch to Warehouse] subtask cannot be executed, and the entire order process halts.

Sequential tasks are rarely isolated; they are nested within larger HTN structures. A high-level sequential task may contain subtasks that are themselves compound tasks (sequential, parallel, or iterative).

• Hierarchical Design: A top-level task [Assemble Product] might be sequential, but its [Test Subsystem] subtask could be a compound task that decomposes into a parallel set of diagnostic checks.
• Formal Representation: In PDDL (Planning Domain Definition Language) or similar, this is represented as a method whose subtask network is a totally-ordered list.

A planning formalism where complex problems are solved by recursively decomposing high-level compound tasks into networks of smaller subtasks until primitive tasks (executable actions) are reached. It is the overarching framework that defines Sequential Tasks.

• Core Concept: Represents knowledge as tasks, methods for decomposition, and operators for execution.
• Contrast with Classical Planning: HTNs specify how to achieve tasks (procedural knowledge), while classical planners only specify what the goal state is (declarative knowledge).
• Primary Use: Foundational for automated planning in logistics, robotics, and business process automation where standard operating procedures exist.

An abstract, high-level task that cannot be executed directly. It must be decomposed into subtasks using a method. A Sequential Task is a specific type of compound task where the subtasks have a strict linear order.

• Key Attribute: Serves as a placeholder for a procedure, defined by one or more methods that detail possible ways to achieve it.
• Example: AssembleProduct is a compound task. One method might decompose it into the sequential subtasks: [FetchComponents, AttachPartA, AttachPartB, QualityCheck].
• Planning Role: Provides the hierarchical structure; the planner's job is to find a chain of decompositions from compound tasks to a sequence of primitive actions.

A task that corresponds directly to an executable action or operator in the planning domain. It is a leaf node in the decomposition tree and has defined preconditions and effects.

• Key Attribute: Has an associated operator that defines how it changes the world state. No further decomposition is possible or required.
• Contrast with Sequential Task: A Sequential Task is compound and abstract; a Primitive Task is concrete and executable. The final plan is a sequence of primitive tasks.
• Example: PickUp(Object, Location) or SendHTTPRequest(API_Endpoint) are primitive tasks with clear preconditions (object must be at location) and effects (agent is holding object).

A decomposition rule that specifies one way to accomplish a compound task. It consists of a set of preconditions and a task network (a set of subtasks with ordering constraints). A method for a Sequential Task explicitly defines a total order over its subtasks.

• Mechanism: Compound-Task -> Preconditions -> Subtask-Network.
• Role in Planning: The planner searches through applicable methods to decompose abstract tasks. The choice of method determines the specific procedure used.
• Example: A method for BrewCoffee might have the precondition HasWater==True and the totally ordered subtask network: [GrindBeans, HeatWater, PourWaterOverGrounds].

A temporal relation specifying that one task must be performed before another within a plan. In a pure Sequential Task, ordering constraints form a total order (a strict sequence). More complex HTNs use partial orders for flexibility.

• Representation: Often denoted as T1 < T2, meaning T1 precedes T2.
• Engineering Importance: These constraints encode critical procedural dependencies (e.g., ValidatePayment < ShipItem) and resource dependencies (e.g., AcquireLock < WriteToDatabase < ReleaseLock).
• Planning Impact: The planner must ensure the final sequence of primitive actions satisfies all ordering constraints derived during decomposition.

A seminal and widely implemented HTN planning algorithm. It performs task decomposition in a forward-chaining, depth-first manner, interleaving planning with state progression. It is particularly efficient for domains with primarily sequential tasks.

• Algorithm Logic: Begins with the initial task network and state. Recursively selects a task, if it's primitive and its preconditions hold, it executes it (updating state); if it's compound, it selects an applicable method, decomposes it, and adds the new subtasks.
• Key Feature: Its forward search respects the current world state at each step, making it sound and complete for its formalism.
• Modern Use: The principles of SHOP underlie many contemporary AI planning systems and agentic workflow engines where hierarchical, procedural knowledge is key.