Parameterized Behavior Trees in Robotics

• Parameterized behavior trees are hierarchical control structures where nodes are equipped with explicit parameters for actions, timing, and resource constraints.
• They are generated from temporal plans via STN transformation and algorithmic compilation that enforces causal, temporal, and concurrency requirements.
• This approach enables flexible, concurrent, and robust execution in robotics by adapting in real time to environmental uncertainty and dynamic resource demands.

A parameterized behavior tree is a hierarchical control structure in which the nodes—both internal (control flow) and leaf (action/condition)—are defined not just by their functional role but also by explicit parameters that encode arguments, constraints, execution context, or temporal relationships. Parameterization endows behavior trees (BTs) with modularity, flexibility, and adaptability critical for complex, real-world robotic and autonomous agent applications, especially those requiring concurrency and robust adaptation to environmental uncertainty.

1. Formal Definition and Algorithmic Construction

Parameterized behavior trees are generated through a sequence of transformations that begin with a temporal plan (for example, specified in PDDL 2.1 or similar), which is first represented as a simple temporal network (STN) before being systematically compiled into a BT. The process involves:

• BUILDSTN: Every durative action is decomposed into a start and end event ("snap actions"), with explicit causal, temporal, and mutual exclusion (threat avoidance) links based on action preconditions, effects, and PDDL semantics.
• PROPAGATE: All temporal constraints (minimum and maximum time bounds between actions/events) are propagated throughout the STN, typically using the Floyd-Warshall algorithm, ensuring satisfaction of direct and transitive dependencies.
• BUILDBT: The STN is traversed (generally via depth-first search), and each node is mapped into a BT subtree with parameterized nodes:
  • Each Start event creates a sequence comprising checks of preconditions, application of start effects, initiation of action (with parameterized arguments), and conditioned waits (WaitTime, WaitAction).
  • Each End event handles postconditions and end effects, also parameterized by action instance.
  • Parallel subtrees are created when multiple successors are enabled for concurrency.
  • Decorators and guards (WaitTime, CheckTime, WaitAction) carry parameters reflecting temporal constraints and resource dependencies.

Example pseudocode, reflecting Algorithm 3 in the source:

\Function{BUILDBT}{G} \Return GETFLOW(%%%%0%%%%, %%%%1%%%%, %%%%2%%%%) \EndFunction \Function{GETFLOW}{n, U, t} \If{%%%%3%%%%} \Return WAITACTION(%%%%4%%%%, %%%%5%%%%) \EndIf U \gets U \cup \{n\} // ... rest of algorithm, with per-node parameterization ... \EndFunction

2. Structure and Role of Parameters in Behavior Trees

Parameterization in BTs encompasses multiple facets:

• Action/Skill Arguments: Nodes are instantiated with concrete parameters corresponding to specific task instances, e.g., object identifiers, spatial locations, grasp types, or velocity profiles, enabling the same BT template to be reused for different tasks simply by changing arguments.
• Temporal Parameters: Control nodes and decorators such as WaitTime, CheckTime, and WaitAction are instantiated with timing constraints computed from the STN, enforcing minimum/maximum duration or synchronization windows derived from plan semantics.
• Resource/Concurrency Encoding: Parameters track resource allocations, mutual exclusions, and critical region markers, ensuring safe execution in the presence of potential conflicts (e.g., only one action may hold a resource at a time).

This structure enables robust adaptation: as conditions, timings, or resource states vary at runtime, each node evaluates its parameterized constraints, and the BT as a whole adapts its flow control and timing accordingly.

3. Execution Flow and Adaptation

The execution flow within a parameterized BT constructed from an STN is governed by:

• Sequencing: Achieved via Sequence nodes, parameterized to enforce required ordering.
• Parallelism: Realized through Parallel nodes with the degree of concurrency set by the STN’s concurrency structure; e.g., multiple actions may begin as soon as their individual preconditions and temporal constraints allow.
• Dynamic Waiting and Checking: Decorator nodes such as WaitTime, WaitAction, and CheckTime actively measure or await condition satisfaction or elapsed time, using parameters reflecting their specific plan-imposed requirements.
• Fallback and Retrying: Nodes may include Fallback/Retry constructs to respond gracefully to failures, attempting alternative strategies or re-executing actions as needed, driven by parameterized logic encapsulating behavioral alternatives.

In the MATCHCELLAR domain case, this mapping allows, for example, mend_fuse actions to be precisely nested within the interval of a light_match action, enforced via parameters encoding interval relationships; parallel lighting of multiple matches is permitted by independent BT subtrees parameterized for each instance.

4. Concurrency and Synchronization

A key capability of parameterized BTs as presented in the referenced framework is the correct and efficient management of concurrency and synchronization:

• Safe Parallelism: By parameterizing BT parallel nodes with the number of permissible concurrent activities (from the STN structure), and by inserting WaitAction or resource-guarding decorators where required, the BT can maximize concurrent execution without violating plan semantics or resource constraints.
• Interleaving and Serialization: Mutually exclusive actions are prevented from executing in parallel via threat avoidance parameters encoded at the decorator or control node level.
• Temporal Nesting: When an action must occur during the execution interval of another, decorators parameterized with temporal constraints enforce correct nesting and prevent race conditions or interference.

This is illustrated in the assembly example, where pre-pick and pre-release actions are allowed to overlap with navigation, optimizing overall plan execution time within correctness guarantees.

5. Integration and Applications in Robotic Systems

The parameterized BT framework has been validated within the PlanSys2 (ROS2) stack. The implementation specifics include:

• Executor Module: Converts temporally-annotated PDDL plans into STN representations, then invokes the BT builder to generate the parameterized BT for execution.
• Action Node Interface: BT leaf nodes call skill modules, passing parameter values derived from the BT’s instantiation; these in turn invoke hardware controllers or higher-level planners.
• Temporal Robustness: Adaptation to variable execution durations (for example, fluctuating navigation times) is naturally supported, as the BT nodes track execution status and parameters to determine readiness for subsequent actions.
• Concurrency Efficiency: Empirical benchmarks (assembly tasks on the Tiago robot) demonstrate reduced makespan (mean improvement of ~9%) compared to non-parameterized, sequential BTs.

Table: PlanSys2 Assembly Time Comparison

Algorithm	Mean (s)	Std Dev (s)
SimpleBTBuilder	220.57	9.21
STNBTBuilder	200.20	10.92

This result supports the claim that parameterized, STN-derived BTs enable more efficient and reliable execution in real robotic domains.

6. Theoretical and Practical Significance

The presented approach achieves key goals in behavior-based robotics and autonomous mission execution:

• Compositionality and Reuse: Parameterized BTs allow definition of reusable behavior templates instantiated with specific arguments at runtime.
• Correctness and Robustness: By explicitly encoding all event-based and temporal constraints as parameters in the BT structure, the execution trace is guaranteed to respect the original plan orders, concurrency patterns, and resource requirements.
• Scalability: The generic structure accommodates large, complex plans (including durative and concurrent actions), scaling to handle real-world scenarios.
• Resilience to Uncertainty: Adaptation to temporal or environmental uncertainty is handled intrinsically by the BT’s parameterized checks and, where present, retry/fallback logic.

A plausible implication is that, for robotic domains requiring the integration of planning, temporal reasoning, and robust execution, parameterized BTs constructed from STNs represent a convergent methodology enabling both declarative plan specification and practical execution in dynamic environments.

7. Limitations and Outlook

While parameterized BTs constructed via this method successfully execute complex temporal plans with concurrency requirements, several constraints and challenges are apparent:

• Complexity of STN Construction: Properly decomposing all actions into start/end events and encoding mutual exclusion or resource constraints demands comprehensive domain modeling.
• Dependency on Action Parameter Availability: The robustness of the framework is contingent on the ability to instantiate all required parameters (object identities, durations, preconditions) at runtime.
• Scalability to Highly Non-deterministic Environments: While the system is robust to timing variation, significant state uncertainty or incomplete information could challenge the BT’s implicit assumption of action outcome determinism.

Nevertheless, the framework establishes a new standard for rigorous, parameterized behavior tree construction in temporal planning and execution, aligning plan structure, temporal constraint satisfaction, and execution efficiency in both simulated and physical robotic domains.