Integrating Intent Understanding and Optimal Behavior Planning for Behavior Tree Generation from Human Instructions

1 Introduction

Issuing instructions using natural language is a convenient and user-friendly way to control robots in everyday life scenarios, such as home, restaurants, and factories. However, enabling robots to autonomously follow these instructions remains a challenge in the field of robotics and AI. On the one hand, due to the openness of natural language, the robot must understand the user's intents, clarify the goals of tasks, and acquire sufficient high-level skills to accomplish these tasks. On the other hand, the robot must automatically generate reliable plans and execute them safely and robustly.

Behavior Trees (BTs) employ a logical tree structure to control various high-level robot behaviors, which offer many advantages, includingmodularity, interpretability, reusability, reactivity, and robustness. Due to these characteristics, BTs have become a popular robot control architecture in recent years. Moreover, approaches to automatically generate BTs have also been widely studied, including evolutionary computing [Colledanchise et al., 2019], reinforcement learning [Banerjee, 2018], and BT synthesis [Li et al., 2021]. BT Expansion [Cai et al., 2021] is a sound and complete algorithm for constructing BTs through behavior planning, theoretically ensuring the success of the BT. However, existing methods typically generate BTs from fitness functions, reward functions, or formalized goal conditions, but few studies have focused on generating BTs directly from natural language instructions.

Large Language Models (LLMs), trained on extensive corpora to generate text sequences based on input prompts, exhibit remarkable multi-task generalization capabilities. This ability has recently been used to generate plausible task plans, which can be represented as action sequences [Song et al., 2023], codes [Singh et al., 2022], and more. However, for the method of having LLMs directly generate BTs [Lykov and Tsetserukou, 2023], it not only necessitates gathering a large dataset of instruction-BT pairs for supervised fine-tuning, but also cannot guarantee theoretical correctness and optimality of the generated BTs.

This paper proposes a two-stage framework for efficient and reliable BT generation from human instructions. In the first stage, we utilize the LLM's capability in understanding intent to interpret a goal from the user's instructions. In the second stage, we design the Optimal Behavior Tree Expansion Algorithm (OBTEA) to construct a BT that theoretically can ensure the completion of the goal with minimal cost. The task goals, expressed as Well-Formed Formulas (WFFs) in first-order logic [Hodel, 2013], serve as a natural and ingenious bridge connecting these two stages. In a caf´e scenario, for instance, there is a customer who says to the robot: Could you please clean the table and give me a cup of coffee or tea? The LLM generates a goal condition: G = ¬Dirty(Table)∧ (On(Coffee,Table)∨On(Tea,Table)). Then, OBTEA traverses the action and condition space to find actions that can be used to achieve the goal, such as Clean(Table) and PutDown(Coffee,Table). These actions are then structured to generate the final optimal BT, as shown in Figure 1.

Our experiments demonstrate that the LLM (GPT 3.5), powered by few-shot demonstrations and reflective feedback, achieves high performance in both grammar and interpretation accuracy for intent understanding. The analysis of optimal behavior planning shows that the OBTEA produces BTs with lower costs and fewer condition node ticks compared to the baseline BT Expansion algorithm. Finally, the success of deployment in a caf´e scenario highlights the promising future of our framework.

2 Preliminaries

Behavior Tree. A BT is a directed rooted tree structure in which the leaf nodes control the robot's perception and actions, while the internal nodes handle the logical structuring of these leaves [Colledanchise and ¨Ogren, 2018]. At each time step, the BT ticks from its root. The tick, according to the environment state, creates a control flow within the tree, ultimately determining the action that the robot will execute. In this paper, we focus on five typical BT nodes:

• Condition: A leaf node that evaluates whether the observed state satisfies the specified condition, returning either success or failure based on this assessment.
• Action: A leaf node that controls the robot to perform an action, returning success, failure, running depending upon the outcome of execution.
• Sequence: An internal node that only returns success if all its children succeed. Otherwise, it ticks its children from left to right, and the first child to return failure or running will determine its return status. It is often visualized as a → inside a box.
• Fallback: An internal node with logic opposite to the sequence node. It returns failure only if all of its children fail. If not, the first occurrence of success or running during ticking becomes its return status. It is often visualized as a ? in a box.
• Not-Decorator: An internal node with a single child. It inverts the return statuses success and failure of its child. It is often visualized as a ! in a diamond.

Behavior Planning. Based on [Cai et al., 2021] and [Colledanchise and ¨Ogren, 2018], we describe the behavior planning problem as a tuple: < S,A, P, s0, g >, where S is the finite set of environment states, A is the finite set of action, P defines the state transition rules, s0 is the initial state, g is the goal condition. Both the state s ∈ S and the condition c are represented by a set of literals, similar to STRIPS-style planning [Fikes and Nilsson, 1971]. If c ⊆ s, it is said that the condition c holds in the state s. The state transition affected by the action a ∈ A can be defined as a triplet P(a) =< pre(a), add(a), del(a) >, comprising the precondition, add effects, and delete effects of the action. An action a can only be performed if pre(a) holds in the current state s. After the execution of the action, the subsequent state s′ will be:

In well-designed BT systems, for each literal or its negation, there is a condition node to verify its truthfulness, and for each action, there is a corresponding action node for implementation. Given the initial state s0 and the goal condition g, the objective of behavior planning is to construct a BT T capable of transitioning s0 to g in a finite time.

Problem Formulation. In this paper, we extend the problem to optimal behavior planning, as the user's instructions often imply that the robot should complete the ordered task at minimal cost. Considering a well-defined cost function D, where ∀a ∈ A,D(a) ≥ 0, for each BT T produced by behavior planning, if the actions required to transition from s0 to g are a1, a2, ..., an, then the cost of the BT is calculated as D(T ) = ∑ni=1 D(ai). Our aim is to identify the optimal BT, T∗, which can achieve the goal condition g, as interpreted from human instructions, at the minimum cost.

3 Methodology

In this section, we first demonstrate how to represent goals as WFFs in first-order logic. Then, we dive into our two-stage framework for generating BT, where the input instruction is interpreted into the goal condition, and the OBTEA is applied to generate an optimal BT that guarantees to achieve the goal at the minimal cost. Our framework is illustrated in Figure 2.

3.1 Representing Goals as Well-Formed Formulas

To describe the environment in first-order logic, we introduce a triplet ⟨O, Pc, Pa⟩, where O is the set of available objects in the environment, Pc is the set of condition predicates, and Pa is the set of action predicates. For a predicate p ∈ Pc ∪ Pa, its domain may be a subset of the Cartesian product of O. In this formulation, a literal can be denoted as pc(o1, ..., ok) while an action can be denoted as pa(o1, ..., ol). Literals can be further formed into WFFs using three fundamental logical connectors: ∧ (conjunction), ∨ (disjunction), and ¬ (negation). The three fundamental connectors effectively cover a wide range of user intentions, and more intricate connectors may be integrated in future work. This high-level formulation is advantageous for LLM to understand and interpret, as well as for the design and implementation of modular and reusable behavior nodes.

3.2 Intent Understanding

Given the relatively interpretable nature of first-order logic grammar in everyday service scenarios, we believe that pretrained LLMs have the potential to interpret the instruction without supervised fine-tuning on specialized datasets. We achieve this process through the following three methods.

Prompt Engineering. We deliberately design LLM prompts to provide context for goal generation, similar to [Singh et al., 2022; Ahn et al., 2022]. Our prompts consist of four components: (1) Objects. The set of available objects. To better define the domains of predicates, we categorize objects into several classes, such as <food> and <place>. (2) Condition Predicates. The set of condition predicates. The domain of a predicate is indicated by category, such as RobotNear(<place>) and On(<food>,<place>). (3) Few-shot Demonstrations. A few instruction-goal pairs as examples to teach the LLM on goal interpretation. The number of demonstrations does not need to be large, but it is beneficial to showcase as much diversity in both grammar and user's intention as possible. (4) System. An explanatory text provides context and the prompt for instructing the LLM to produce a goal in the correct format. We found that few-shot demonstrations have a significant impact on the LLM's ability to interpret goals, as language models have been shown to be few-shot learners [Brown et al., 2020]. We conducted ablation experiments in Section 4.2 to analyze its impact.

Reflective Feedback. We introduce automatic reflective feedback to further enhance grammar accuracy, drawing inspiration from [Liu et al., 2023b]. When the LLM produces an output, the syntax checker evaluates whether the output forms a WFF, while the semantic checker further verifies the validity of predicates and objects. If errors are detected, we re-input the instruction to the LLM with additional prompt to correct these errors. While we initially provide whitelists of objects and condition predicates in the original prompt, we augment the prompt with blacklists and additional context to instruct the LLM not to include the blacklisted texts in the output again. If errors persist, we continue to apply reflective feedback, gradually expanding the blacklists, until all grammar errors are corrected, or the maximum retry limit is reached.

Goal Normalization. A grammatically correct goal will ultimately undergo normalization into Disjunctive Normal Form (DNF). This normalization offers two significant advantages. Firstly, it effectively eliminates ambiguity from WFFs, which is crucial when assessing the equivalence of two goals, particularly in evaluating the semantic correctness of the model's outputs on the evaluation dataset. Secondly, each conjunction within DNF can be regarded as a sub-goal. When the robot accomplishes any one of these sub-goals, it is considered a success, as these sub-goals are represented as disjunctive relations. This enables us to design a modular algorithm for optimal behavior planning.

Algorithm 1 OBTEA

Input: Goal G, init state s0, action set A, transition rules P Output: The optimal BT T∗ 1: Gsub ←ParseSubGoals(G) ▷ the set of sub goals 2: for gi ∈ Gsub do 3: T ←Fallback(gi) ▷ init sub-BT 4: D(gi) ← 0 ▷ for ∀c, c ̸= gi, D(c) ← +∞ 5: CU ← {gi} ▷ explored but unexpanded conditions 6: CE ← ∅ ▷ expanded conditions 7: while CU ̸= ∅ do 8: c ← argminc∈CU (D(c)) ▷ explore and expand c 9: for each a ∈ A do 10: if (c ∩ (pre(a) ∪ add(a) \ del(a)) ̸= ∅) and (c \ del(a) = c) then 11: ca ← pre(a) ∪ c \ add(a) ▷ Exploration 12: if ca /∈ CE and D(c) +D(a) <D(ca) then 13: D(ca) ←D(c) +D(a) ▷ update D(ca) 14: CU ← CU ∪ {ca} ▷ add ca to CU 15: M(ca) ← Sequence(ca, a) 16: CU ← CU \ {c} ▷ remove c from CU 17: if c ̸= gi then 18: T ←Fallback(T ,M(c)) ▷ Expansion 19: if c ⊆ s0 then 20: D(T ) ← D(c) ▷ total cost of T 21: break ▷ T is the optimal BT for sub-goal gi 22: CE ← CE ∪ {c} ▷ add c to CE 23: Ti ←Compact(T ) ▷ Compaction 24: T ′ 1 , T ′ 2 , ..., T ′ |Gsub| = SortAscending key=D(T ) (T1, T2, ..., T|Gsub|) 25: T∗ ←Fallback(T ′ 1 , T ′ 2 , ..., T ′ |Gsub| ) ▷ Assembly 26: return T∗

3.3 Optimal Behavior Planning

We introduce the OBTEA for optimal behavior planning based on the goal G represented in DNF (Fig. 2 and Alg. 1). At the beginning of OBTEA, we parse the goal G to identify sub-goals separated by ∨. Each sub-goal is then further divided by ∧ to form a set of literals, each consisting of a goal condition gi. This process results in a set of goal conditions that constitute the sub-goal set Gsub (line 1). For example, if the goal in DNF is G = (l1 ∧ l2) ∨ (l1 ∧ l3), this translates to two sub-goals: l1 ∧ l2 and l1 ∧ l3. Consequently, the sub-goal condition set becomes Gsub = {g1, g2}, where g1 = {l1, l2} and g2 = {l1, l3}. Note that we facilitate more flexible human instructions by allowing negative literals ¬l, which are often banned in action planners for performance reasons. Users must weigh the trade-off between interpretability and computational complexity in practical applications.

For each sub-goal gi ∈ Gsub, we construct an optimal subtree (line 2). Initially, each subtree is rooted in a fallback node, with its child node being the sub-goal condition gi (line 3). To track the shortest distance, we maintain a cost function D, which is initialized with D(cg) = 0 and D(c) = +∞, ∀c ̸= gi (line 4). Furthermore, we maintain two sets: CU and CE. CU encompasses explored but unexpanded conditions, initialized with {gi} (line 5). CE includes conditions that have been expanded, initially empty (lines 6).

Exploration. We continuously pop the condition c ∈ CU with the minimum cost (line 8). This process aims to explore the condition space following the shortest path from gi. For each popped condition c, we explore its neighboring conditions by iterating through all available actions (line 9) and identifying those that can reach the condition c after execution. The neighboring conditions are generated similarly to the process in the BT Expansion [Cai et al., 2021] (lines 10-11), and can be denoted as: ca ← pre(a) ∪ c \ add(a). Then we disregard ca in the following two cases (line 12): (1) ca ∈ CE, indicating that it has already been expanded and its shortest path is found. (2) D(c) +D(a) ≥ D(ca), showing that ca has been explored and the path cost found is equal or lower. In both cases, further exploration or updates of ca are unnecessary. If neither case applies, we explore ca by updating D(ca), adding ca to CU, and recording the subtree Sequence(ca, a) leading to ca (line 13-15). After exploring all the neighbors of c, it is removed from CU (line 16).

Expansion. After exploring c, we integrate it into the current BT T . This involves adding the subtreeM(c) as a child node of the root fallback node (line 18). The algorithm continues to explore the condition space until it expands a condition c that holds in the initial state s0 (line 19). At this point, we record the total cost of the subtree for gi as D(T ) = D(c) (line 20), and the exploration-expansion loop is immediately terminated (line 21). If s0 is not reached, we add c to the expanded set CE (line 22). It is important to note that this method of expansion might include conditions that are not part of the shortest path. However, this does not affect the optimality since these extra conditions will not be visited along the shortest path. This approach enhances the BT's reactivity and robustness when the state deviates from the original path, ensuring that the path starting from each expanded condition is optimal.

Compaction. For an expanded optimal subtree, we propose a simple but efficient method to compact its structure and improve runtime efficiency. During compaction, we recursively extract common literals from two adjacent conditions to create smaller conditions for checking. Consider a BT produced through the exploration and expansion process. If two adjacent subtrees have conditions c1 and c3, respectively (as illustrated in Fig. 2), both conditions need to be checked during runtime. After compaction, if c1 ∩ c3 ̸= ∅, a new condition c′ = c1 ∩ c3 will be created and checked first during ticking. If it does not hold, the conditions c1 \ c3 and c3 \ c1 will be skipped, thereby saving time. The compacted subtrees can recursively join the compaction with its neighbors due to the modularity of BT. We evaluated the impact of the maximum recursion depth during compaction on condition check count in Section 4.3.

Assembly. Once all subtrees have been generated, we can assemble the final optimal BT. We start by sorting all the subtrees in ascending order according to their total costs (line 24). This ensures that the BT will prioritize the feasible paths with the lowest cost. Then, we construct the final BT T∗ by adding the sorted subtrees under a fallback node (line 25). After this, the algorithm ends and returns T∗ as the optimal BT to achieve the final goal G at minimal cost.

presents the performance of the model in three levels of difficulty, with each result being the average of 5 runs. We studied the impact of two factors on our method: the number of demonstrations and the maximum retry limits. Our standard setting involves five demonstrations with a limit of five retries for reflective feedback. At the easy level, we find the LLM performance is surprisingly high, with GA and IA reaching 100%, 99.3% and 96%, respectively. At medium and hard levels, the decrease in IA is faster than in GA. This suggests that the grammar of first-order logic is easier for LLMs to learn, but the translation from natural language is more challenging. Overall, both GA and IA are relatively high even at the hard level, demonstrating the LLM's potential for interpreting WFFs even without any supervised fine-tuning.

Ablating Few-shot Demonstration. To conduct the ablation analysis on the number of demonstrations, we reduced the number of demonstrations while keeping the objects, predicates, and system explanations constant. It is observed that when no demonstrations are provided (zero-shot), both GA and IA significantly decrease across three levels of difficulty. Furthermore, IA is particularly lower than GA in the zero-shot setting, which again confirms the challenge for LLM to learn intent understanding rather than learning logical grammar only in explanatory prompts. Without any demonstrations, the pre-trained LLM struggles to provide WFF-represented goals that align with the user's intent. However, there is a notable improvement in performance after adding just one demonstration (one-shot). This phenomenon indicates that one example can be more effective than a lengthy explanation. The results underscore the importance of including examples in prompts and also highlight the LLM's few-shot learning ability in interpreting goals.

Ablating Flextive Feedback. We then performed the ablation analysis on the maximum retry times with reflective feedback. The results show that without feedback (GA-NF), the

Evaluation

The BT generated by OBTEA is theoretically guaranteed to be finite-time successful and optimal, assuming that all subgoals can be reached from the initial state s0 within the BT system. Similar to BT Expansion [Cai et al., 2021], the time complexity of OBTEA is also O(|A||S| log(|S|)) in the worst case, which is polynomial in terms of the system size. Proofs and a detailed discussion are in the appendix.

4 Experiments

4.1 Settings

We conducted experiments and deployed our framework in a hospitality industry scenario, where the robot plays the role of a waiter in a caf´e. It is responsible for serving customers and performing various tasks following human instructions. In this scenario, the design of object and action sets is similar to the Virtual Home [Puig et al., 2018] and Alfred [Shridhar et al., 2020] benchmarks, but it is tailored to better suit the specific requirements of a caf´e. The scenario includes a total of 80 available objects, 8 condition predicates: Pc = {RobotNear,Holding,On,Closed,Exists,Dirty ,Activate,Low} and 6 action predicates Pa = {Make, MoveTo,PickUp,PutDown,Clean,Turn}. Different predicates have different domains and implementations on behavior nodes, resulting in a total of 1318 extendable literals and 1269 extendable actions.

4.2 Analysis for Intent Understanding

To evaluate the intent understanding capabilities of LLM for goal interpretation, we created an evaluation dataset comprising 100 instructions and their corresponding expected goals, categorized into three difficulty levels. As exampled in Table 1, the Easy set consists of goals formed by a single positive literal. In the Medium set, goals consist of two literals connected by ∨ or ∧. The Hard set involves three literals that incorporate ∨, ∧, and ¬. The performance of the LLM in the interpretation of goals is evaluated primarily based on two metrics: grammatical accuracy (GA) and interpretation accuracy (IA). GA is the fraction of output goals that are free from grammatical errors. IA is the fraction of goals that are equivalent to the ground truth.

Our methods are model-agnostic, allowing for application to any LLM. We conducted the experiments with GPT-3.5, specifically using the gpt-3.5-turbo model (2024.06). Table 1

performance is markedly decreased, especially in the absence of demonstrations. Similarly to the number of demonstrations, GA improved when the LLM is allowed to retry only once (GA-1F), and an increase in the number of feedback times continuously improved grammar correctness. These results confirm the effectiveness of reflective feedback.

4.3 Analysis for Optimal Behavior Planning

Once the LLM produces the correct goal, OBTEA is guaranteed to generate an optimal BT to achieve that goal. We evaluated the BT generation performance for 100 ground-truth goals in the caf´e scenario, where the action cost is set based on human experience. We focus on two key metrics: total costs of the BT and the condition node ticks during the BT's execution. Table 2 shows the performance comparison between OBTEA and the baseline BT Expansion algorithm [Cai et al., 2021]. The results demonstrate that our OBTEA generates BTs with lower costs and fewer condition node ticks than the baseline, and thereby has higher execution efficiency.

Random Test Sets. In addition to the dataset in the caf´e scenario, we also designed random test sets to verify the generality of OBTEA. Inspired by [Cai et al., 2021], we randomly generate various optimal behavior planning tasks by creating action sequence paths from the initial state to the goal and then randomly adding other actions. In contrast to previous work, our datasets are represented using first-order logic. The problem scale is mainly determined by the number of objects (O), condition predicates (Pc), and action predicates (Pa). To increase the number of valid paths to the goal, we can randomly copy the actions in the original path several times, but assign different costs, denoted as maximum action copies (MAC). Further details can be found in the appendix.

Table 3 shows the results averaged over 1000 runs. The results again emphasize OBTEA's proficiency in achieving lower action costs and condition node ticks across all cases with varying complexity. In particular, in the most complex case 9, OBTEA significantly reduces costs by more than 50%, and condition node ticks decrease by approximately 30%. When there are more available paths to reach the goal, the costs of BTs found by OBTEA are smaller than the baseline. Note that while OBTEA has achieved improvements, its additional time overhead is also acceptable. The test results and discussions regarding planning time are in the appendix.

Ablating Compaction. We then performed an ablation analysis on the impact of the maximum recursion depth during compaction. Table 3 shows that when we remove compaction (OBTEA-NC), the condition node ticks increase significantly in all cases. Experiments in caf´e scenarios (Figure 3) show that condition node ticks decrease rapidly as the recursion depth increases when the recursion depth is small and then become rather constant when we continuously increase the depth. This means that the recursion depth does not need to be set too large to achieve optimal performance in the caf´e scenario.

4.4 Deployment

We implemented our framework in a digitally twinned caf´e environment constructed using the simulator used in MOVLN [Liang et al., 2023], as shown in Figure 4. In the simulator, a humanoid robot acts as a waiter and has 21 active joints for precise movement control. We implement 8 condition nodes and 6 action nodes, corresponding to conditions and action predicates. To gather object information, the robot initially performs visual segmentation and detection to determine object poses from multiple perspectives. For efficient condition checks, the robot actively explores and continuously updates a semantic topological map for task execution queries. By integrating these technologies, we ultimately achieve an adaptable, comprehensive, and reliable caf´e waiter robot system capable of visual-language navigation, manipulation, and handling complex combination tasks. Our work was presented and won the First Prize in a competition at ChinaSoft 2023. The successful deployment demonstrates the utility and practicality of our framework, representing a promising behavior tree generation framework in embodied intelligence scenarios.

5 RelatedWork

BT Generation. The study of automatic BT generation is a significant area of research in robotics and AI. Various methods have been explored for this purpose. Heuristic search methods, such as grammatical evolution [Neupane and Goodrich, 2019], genetic programming [Colledanchise et al., 2019; Lim et al., 2010], and Monte Carlo DAG Search [Scheide et al., 2021], have been widely investigated. In addition to heuristic approaches, machine learning techniques have been applied to generate BTs. In particular, methods such as reinforcement learning [Banerjee, 2018; Pereira and Engel, 2015] and imitation learning [French et al., 2019] have gained attention. There are also research efforts that employ formal synthesis methods to generate BTs, such as Linear Temporal Logic (LTL) [Li et al., 2021] and its variant approaches [Tadewos et al., 2022; Neupane and Goodrich, 2023]. However, it is worth noting that this approach can be resource intensive in terms of modeling the environment and the computational resources required to solve the problem.

LLMs for Task Planning. LLMs have gradually gained widespread application in the field of robot task planning recently. Some research focuses on directly controlling the lowlevel actions of robots using multi-modal language models [Driess et al., 2023], while others use large language models to generate high-level behavior planning for robots. Generating BTs based on human instructions is an area that has seen limited exploration. One straightforward approach is to train a large language model to generate behavior tree structures represented in XML format [Lykov and Tsetserukou, 2023; Lykov et al., 2023]. This approach is similar to the methods where LLMs directly generate action sequences [Song et al., 2023; Liu et al., 2023a; Ahn et al., 2022; Chen et al., 2023], or codes [Liang et al., 2022; Singh et al., 2022; Zeng et al., 2022]. However, these approaches may not fully leverage the modularity and computability of BTs for planning, potentially resulting in a loss of the reliability and interpretability advantages that BTs offer.

Our approach combines the ability of LLMs to understand intent with first-order logical reasoning for correctness assurance, ultimately achieving BT generation based on human instructions. This approach aligns with the concepts of neurosymbolic approaches [Chaudhuri et al., 2021] and symbolic planning [Liu et al., 2023b]. In the future, it is possible to enhance the generalization of robot planning in new scenarios by combining techniques like rule discovery [Zhu et al., 2023]. Hence, our framework is considered a promising approach for creating interpretable and reliable embodied intelligent agents.

6 Conclusion

This paper proposes a two-stage framework for BT generation, leveraging the strengths of LLMs for intent understanding and introducing the OBTEA for optimal behavior planning. The goal is represented as a well-formed formula in first-order logic, serving as a natural and innovative link between these two stages. Our framework integrates intent understanding and optimal behavior planning, which shows promise in creating adaptable and reliable generative embodied agents. In addition, we deployed our framework in a caf´e scenario, showcasing its significant potential.

In the future, many tasks can be undertaken. For example, we can test and improve the effectiveness of goal interpretation on more benchmarks such as the RoboCup@Home competition. We can enhance the OBTEA's planning efficiency using heuristics like modern planners. Last but not least, we can integrate rule discovery algorithms to automatically learn environment transition rules from experience, thereby enhancing robots' capabilities for rapidly adapting and planning BTs in unseen scenarios.

Acknowledgments

This work was supported by the National Natural Science Foundation of China (Grant Nos. 62106278, 91948303-1, 611803375, 12002380, 62101575), and the National Key R&D Program of China (Grant No. 2021ZD0140301). The authors also thank Dataa Robotics for organizing the competition and providing technical assistance.

Contribution Statement

The contributions of Xinglin Chen and Yishuai Cai to this paper were equal. Corresponding author: Minglong Li.