Towards Reliable LLM-based Robots Planning via Combined Uncertainty Estimation

Thank you for your thoughtful comments and valuable feedback. Below are our detailed responses.

Q1. O is a description of the current environment. Is that correct? Are there any real examples of O?

Yes, you are correct. An example of $O$ is as follows:

You are a robot operating in an office kitchen. You are in front of a counter with two closed drawers, a top one and a bottom one. There is also a landfill bin, a recycling bin, and a compost bin. On the counter, there is an orange soda, a Pepsi, and an apple.

Q2. Does this method apply to visual observations? What if the image is used as input for a foundational model with visual capabilities?

In the specific implementation presented in this paper, which uses LLaMA, images cannot be directly inputted as LLaMA only supports text input. Therefore, it is necessary to first convert the image into a text description using a VLM before feeding it to subsequent models for processing.

However, if a multimodal model supporting images (such as LLaVA) is adopted and the text encoder is replaced with the corresponding multimodal encoder, images can be directly inputted and encoded into feature vectors, keeping the subsequent process unchanged.

Q3. How is the success rate measured? So, how is the actual success rate measured? Did you conduct multiple experiments?

The success rate measurement method is as follows:

In the constructed training set and test set, each sample (case) has only one clear binary label: successful cases are marked as 1, and failed cases are marked as 0.

Success is defined as whether the robot's action meets the user's requirements. For example, if the user needs a caffeinated beverage and the robot provides Red Bull, it is considered a success (label 1); otherwise, it is a failure (label 0).

Note that here each sample has only a single binary label, without involving multiple repeated experiments to calculate probabilities.

You understand correctly; the "expected success rate" is indeed an estimate of the actual success rate.

The expected success rate is provided by the model. After training on the training set, the model outputs a value between 0 and 1 as the "expected success rate" for that sample.

Neither the actual success rate nor the expected success rate is statistically calculated through multiple experiments.

Q4. How is Equation 4 formulated? Has there been a discussion on why this form of equation is most effective?

Equation 4 is designed to comprehensively reflect uncertainty in the planning process, combining three main factors: task clarity, expected task success rate, and task similarity.

1. Task Clarity: Task clarity is evaluated using two methods: a query-based LLM method and a multi-layer neural network inference method. Both results are represented as $A_{\text{amb}}$, reflecting the ambiguity or difficulty of understanding the task.

2. Expected Task Success Rate: Predicted using a multi-layer neural network, yielding success rate $p$, representing the likelihood of completing the task given the conditions.

3. Task Similarity: Estimated using RND to obtain task similarity, $A_{\text{sim}}$, indicating the similarity of the current task to known tasks.

The Equation reflects uncertainty's comprehensive performance under different task conditions through a weighted combination of these three factors.

We formulate Equation 4 as a heuristic model to simulate the generation of uncertainty. It starts from maximum uncertainty (1), subtracting the influence of success rate and task clarity correction to increase certainty, while compensating for extra certainty brought by task familiarity through negative weight parameters. The equation simulates human thinking processes when facing uncertainty, considering the influence of success rate, task clarity, and familiarity comprehensively.

Some ablation study results are integrated into Section 5.1, Table 1. The complete ablation study results are as follows:

L1 & L2. Some important terms are not clearly defined.It lacks discussion on how to resolve uncertainty.

Thank you for your suggestion. We will add this part of the definitions and discussions to explore possible directions for reducing uncertainty to the paper.

L3. The reliance on neural networks (MLP) leads to higher computational.

The computational resources are mainly consumed in the UAN and RND parts, which are both relatively small multi-layer neural networks, resulting in very low computational consumption during actual inference. Specifically, the UAN network and RND network both have a three-layer structure, with neuron numbers of 4096, 128, and 32 respectively. The computational consumption of a single inference is only 0.53 MFLOPs, requiring relatively few computing resources.

Additionally, the computation of feature vectors can utilize the cache after planning by the planning model, avoiding extra computational resource consumption. Although the network training process does require significant resource investment, this part of the computation can be completed in the cloud, not requiring execution on the device, and can be reused after training once.

Overall, although there is an increase in computational resource cost, it is almost negligible. On the other hand, the significant improvement in safety makes this cost increase trivial.

L4. Some baselines are too trivial to demonstrate the effectiveness of the proposed method.

Thank you for your suggestion. Since the main focus of this paper is on reducing unexpected actions, we have added some experiments comparing some new metrics, which are defined in IntroPlan[1]. Meanwhile, we tested the IntroPlan method combined with the CURE method.

The experimental results of Overstep Rate, Overask Rate, Help Rate (target success rate 90%) for the IntroPlan method, CURE method, and IntroPlan+CURE method are as follows:

It can be seen that:

• In terms of Overstep Rate, the Introplan + CURE method achieved absolutely optimal results, greatly reducing the occurrence of unsafe events.
• In terms of Help Rate, Introplan is the lowest, indicating it is most confident and requires the least human intervention. However, considering the small gap in Overask Rate between Introplan + CURE and Introplan, it suggests that the help requests of Introplan + CURE are not ineffective, significantly improving safety performance.
• In terms of Overask Rate, the CURE method is the best, attributed to the initial low success rate of the KnowNo basic method, making the effective help range larger.

L5. The appendix does not provide enough experimental details.

You are correct, here is a real prompt:

Complete Procedure for Kitchen Operation Experiment

First, we grasp the initial information including the scene and task, for example:

Scene: a bottled unsweetened tea, an orange, and a bag of jalapeno chips Task: Put jalapeno chips in the drawer.

Next, we supplement the complete scene information to form a complete scene description:

We: You are a robot operating in an office kitchen. You are in front of a counter with two closed drawers, a top one and a bottom one. There is also a landfill bin, a recycling bin, and a compost bin.
We: On the counter, there is an orange soda, a Pepsi, and an apple.

Based on this, we generate action according to the complete scene and task. This generation process is consistent with KnowNo[2]. It is emphasized that this generation method is independent of the method proposed in this paper and can adopt any method to generate operation instructions. The generated operation instruction is (if the instruction is not in this format, it will be reformatted by LLM):

action: pick-up jalapeno chips to bottom drawer

Next, we combine the aforementioned content into a prompt with specific content:

You are a human and there is a robot operating in an office kitchen. The robot is in front of a counter with two closed drawers, a top one and a bottom one. There is also a landfill bin, a recycling bin, and a compost bin.
On the counter, there is {scene}.
You say: "{task}".
Then the robot {action}.

We input this prompt into the Llama3-8B model and extract the last layer's hidden state (last_hidden_state) as the feature vector $T$.

Subsequently, the feature vector is input into the UAN network and RND network to obtain the final expected success rate $p$, ambiguity $A_{\text{amb}}$, and familiarity $A_{\text{sim}}$:

• $p$: 0.962
• $A_{\text{amb}}$: 0.928
• $A_{\text{sim}}$: 0.048

Finally, the uncertainty (Uncertainty) is calculated using Eq.4; Confidence is calculated as: 1 - U. The confidence value in the example is 0.378.

References

[1] Liang, Kaiqu, Zixu Zhang, and Jaime F. Fisac. "Introspective Planning: Aligning Robots' Uncertainty with Inherent Task Ambiguity." Advances in Neural Information Processing Systems 37 (2024): 71998-72031.

[2] Ren, Allen Z., et al. "Robots that ask for help: Uncertainty alignment for large language model planners." arXiv preprint arXiv:2307.01928 (2023).

Thank you for your thoughtful comments and valuable feedback. Below are our detailed responses.

W1. Why can uncertainty be divided into task familiarity and task clarity?

Thank you for your valuable feedback. The potential correlation between task familiarity and task clarity in complex scenarios, as pointed out, is very reasonable. However, the definition of "task clarity" in this paper differs from the focus you described. The concept of "task clarity" you mentioned is closer to the level of detail of the task.

1. Core Definition of Task Clarity: In this paper, task clarity primarily assesses whether the instructions themselves provide sufficient information for the robot to perform the correct operation to fulfill the user's need. Taking the two examples you provided:

   • "Visit building A, then B, then C."
   • "Visit all buildings with the shortest paths." Both instructions are sufficiently clear, and the robot can execute the corresponding tasks based on the instructions. However, consider another scenario: the user's need is for the robot to "visit the tallest building," but due to the ambiguity of human language, the operator's actual instruction might be "visit that building" without specifying which one (missing the "tallest" key information). In this case, the robot will struggle to complete the task correctly. The core of task clarity as defined in this paper lies in addressing the consistency between the instruction information and the user's need. Therefore, task clarity does not refer to the level of detail of the instructions, but whether the instruction unambiguously conveys the essential elements needed to complete the task as intended.

2. Necessity of Distinguishing Clarity and Familiarity: Based on the above definition, if the task instructions themselves lack clarity, the robot cannot correctly complete the task, even if it is very familiar with actions like "visiting buildings." Therefore, this paper considers it necessary and meaningful to distinguish task clarity (the clarity of instruction conveying the need) and task familiarity (the proficiency in executing specific types of tasks) as two distinct dimensions.

W2. Methods for evaluating task familiarity and clarity. However, is there any explanation to support the rationality and reliability of these designs?

Your point is very valuable. Regarding the rationality of the task familiarity evaluation method, its design inspiration comes from Random Network Distillation[1]. This method has been widely used in the field of reinforcement learning to assess the novelty of states. The task familiarity metric is mainly used for relative comparison. Indeed, if the distilled neural network is poorly trained, it might lead to an overall high level of gaps corresponding to all tasks, but the relative size differences between different tasks still exist. Therefore, this metric can still effectively reflect the relative familiarity of tasks.

Task clarity can be obtained through supervised learning on the training set or inferred using large language models.

W3. This method has limited generalization capability because the trained neural network is supposed to contain preset datasets related to the test tasks.

Your point is very meaningful. The main goal of the paper is to enhance the reliability of embodied intelligent systems and reduce potential dangerous and undesirable behaviors. Therefore, when the system receives tasks outside the training set, opting to refuse execution is a well-considered strategy (our method uses task familiarity evaluation to perform refusal). Although this strategy may limit generalization ability in some situations, we believe this trade-off is worthwhile as it significantly improves the system's reliability and safety.

Q1. How the authors constructed the training dataset for UAN. How were tasks and plans selected, and how was the successful execution of sub-tasks judged?

The construction of the UAN training dataset is mainly achieved through the following two methods:

1. Based on LLM Generation:

   • Randomly select three objects.
   • Then, guide the LLM to specify the desired object indirectly. For example, given objects water, orange, chips, the LLM might generate a task description: "I'm thirsty, give me something to quench my thirst."
   • This constitutes a task sample:
     • scene: Mainly water, orange, chips
     • task: "I'm thirsty, give me something to quench my thirst"
   • Success Judgment: If the agent's action is to give water to the user, it is considered successful; otherwise, it is considered a failure.

2. Based on Script Generation:

   • Directly generate scenes and tasks through scripts. For example, generate a scene containing water, orange, chips, with the task description: "Place the chips next to the fruit."
   • Success Judgment: If the agent's action is to place chips next to orange, it is considered successful; otherwise, it is considered a failure.

Note: The actual generation process is more complex than the above examples. Please refer to the dataset_generate.py file in the code for specific implementation details.

Regarding the generation of task planning (Plan): The planning generation method adopted in the paper follows the method of the KnowNo[2], which involves querying the LLM to generate task planning.

Q2. Expressed in different formats, such as "pick up Sprite" vs. "I want to provide Sprite for the user because...". Could these different expressions cause the system to deviate from the training distribution?

After the LLM completes the planning, we implemented an additional grounding step to align planning actions with robot executable actions. Therefore, the two different expression formats you mentioned will ultimately be unified into the standard form of "pick up Sprite for the user." This step not only ensures the reliability of subsequent execution but also effectively guarantees that the system does not deviate from the training distribution.

For more complex or novel actions that cannot be grounded, considering the safety requirements of the embodied intelligent system, such tasks fall outside the training distribution and will be rejected for execution by the system based on task familiarity assessment. While this approach sacrifices some generalization capability, it significantly enhances the operational safety and reliability of the robot system.

Q3. Regarding the two test environments, show specific examples to help readers better understand the testing capabilities of the LLM.

In this experiment, the action format is predefined as either placing an item in a location or giving the item to the user.

Thank you for your suggestion, here are specific examples.

Complete Procedure for Kitchen Operation Experiment

Due to length limitations, please refer to the response to item 5 under "Limitations" in "Rebuttal by Authors For Reviewer hD99" for the specific details of this example.

Some brief details are as follows:

Scene: a bottled unsweetened tea, an orange, and a bag of jalapeno chips Task: Put jalapeno chips in the drawer.

Based on this, we generate action with KnowNo[2].

Action: pick-up jalapeno chips to bottom drawer

Next, we combine the aforementioned content into a prompt and input this prompt into the Llama3-8B model and extract the feature vector $T$.

Subsequently, the feature vector is input into the UAN and RND network to obtain the final expected success rate $p$, ambiguity $A_{\text{amb}}$, and familiarity $A_{\text{sim}}$:

• $p$: 0.962
• $A_{\text{amb}}$: 0.928
• $A_{\text{sim}}$: 0.048

Finally, the confidence value in the example is 0.378.

Desktop Rearrangement Experiment Process

This process is similar to the kitchen operation experiment, with some specific details as follows:

Scene: blue block, yellow bowl, yellow block, green bowl, green block, blue bowl Task: put the yellow block in the yellow bowl. Action: put the green block to the back of the blue bowl.

Combined prompt is:

You are a human and there is a robot. The robot is in front of a table.
On the table there are these objects: blue block, yellow bowl, yellow block, green bowl, green block, blue bowl.
The robot is asked to put the yellow block in the yellow bowl.
Then the robot put the green block to the back of the blue bowl.

• $p$: 0.181
• $A_{\text{amb}}$: 0.185
• $A_{\text{sim}}$: 0.051

Confidence value is 0.109.

Q4. What are the reasons for the robot failing to execute tasks? What is the difference in applying this framework to robots versus digital games?

Here is a failed example:

Failure Example

Scene: a RedBull, a bag of jalapeno chips, and an orange soda Task: Bring me something with a kick. Action: pick up RedBull Success: 0.893 Ambiguity: 0.056 Familiarity: 0.084 Confidence: 0.778

This is a typical failure case: the generated action is incorrect, yet the confidence is high. Specifically, the task instruction "Bring me something with a kick" is quite ambiguous. The user actually needs "a bag of jalapeno chips," but the model erroneously chose "RedBull," resulting in an excessively high confidence. This is mainly due to the model's inadequate understanding of the instruction and overestimating the instruction clarity.

The uncertainty estimation method proposed in this paper is mainly aimed at the action plan. Therefore, the proposed method is applicable to both robot scenes and digital worlds. And there is no difference because the experiment does not involve motion planning.

References

[1] Burda, Y., Edwards, H., Storkey, A., & Klimov, O. (2018). Exploration by random network distillation. arXiv preprint arXiv:1810.12894.

[2] Ren, Allen Z., et al. "Robots that ask for help: Uncertainty alignment for large language model planners." arXiv preprint arXiv:2307.01928 (2023).

Thank you for your thoughtful comments and valuable feedback. Below are our detailed responses.

W1. Provide further analysis explaining why these new metrics negatively impact some baseline performances.

Regarding the poor performance of IntroPlan on the new metrics, our hypothesis is that it possesses more comprehensive information, making the model overly confident in its chosen answers. Below are the confidence distribution statistics for IntroPlan and KnowNo in the test questions:

KnowNo:

• Average Confidence: 0.320416
• Minimum Confidence: 0.214667
• Maximum Confidence: 0.498671
• Standard Deviation: 0.054888

IntroPlan:

• Average Confidence: 0.905210
• Minimum Confidence: 0.300099
• Maximum Confidence: 1.000000
• Standard Deviation: 0.198491

In IntroPlan, there are 242 items with confidence values exceeding 0.99, which leads to low differentiation in confidence levels. Our new metrics (SR-HR-AUC and Spearman correlation) mainly focus on the differentiation of confidence between successful and failed tasks, thus resulting in poor performance for IntroPlan on these two metrics.

Q1. Can you explicitly report the original metrics for IntroPlan and KnowNo?

Figure 6 in the original text shows the overall success rate when there is no uncertainty-based intervention. When the Help Rate is 0, it represents the overall success rate. The specific success rates are as follows:

Since CURE is a subsequent step based on the planning results of KnowNo, the original metrics should be consistent with KnowNo. Therefore, no additional explanation is provided in the paper.

Q2. Can you provide additional analysis explaining how your proposed metrics interact differently with existing baselines and discuss specific scenarios or limitations where these metrics might distort actual baseline performance?

The metrics we propose differ significantly from the objectives of existing baseline tests. Existing baselines primarily focus on the overall success rate of tasks, aiming to enhance the performance of planning models. In contrast, our proposed metrics (SR-HR-AUC and Spearman correlation) emphasize the accuracy of uncertainty to prevent robots from exhibiting unexpected behavior. This metric is similar to the Overstep Rate in IntroPlan but still differs:

Overstep Rate is defined as the proportion of overconfident or incorrect options generated by the planner when certain. It is calculated as: Count (robot is certain but wrong)/Count (robot is certain).

We conducted additional experiments to evaluate the Overstep Rate, Overask Rate, and Help Rate of the IntroPlan method, CURE method, and IntroPlan+CURE method when the target success rate is 90%. The experimental results are shown below:

The results show that the IntroPlan + CURE method achieved the absolute optimal effect in terms of Overstep Rate, significantly reducing unsafe incidents. In terms of Help Rate, IntroPlan demonstrated the lowest rate, indicating higher confidence and reduced need for human intervention. However, considering the small difference between IntroPlan + CURE and IntroPlan in the Overask Rate metric, it suggests that the help behavior of IntroPlan + CURE was not ineffective, significantly improving safety performance. CURE performed best in the Overask Rate, partly due to the lower initial success rate of its base method, KnowNo, making the effectiveness of the help more significant.

Q3. Given that IntroPlan implicitly addresses epistemic uncertainty through introspective knowledge base retrieval, can you clarify the actual advantages and potential trade-offs (e.g., scalability, complexity) of explicitly modeling task similarity, ambiguity, and expected success rate using separate neural networks? Additionally, can you provide qualitative examples to illustrate the success and failure cases of your method (CURE)?

Compared to IntroPlan, the proposed method has significant advantages in scalability. A typical example is that IntroPlan can be integrated with CURE to further enhance system performance. As demonstrated in the experiments concerning the previous question, when IntroPlan is used in conjunction with CURE, both the sr_hr_area and Overstep Rate (with a target success rate of 90%) improve compared to using IntroPlan alone. This indicates that there is still room for improvement in the accuracy of uncertainty estimation in IntroPlan, and by introducing CURE, this accuracy can be further optimized.

Regarding complexity, the main disadvantage of the method proposed in this paper is the need for a large training set for model training. However, considering that a mature robotic system typically requires numerous training cases for pre-training, this limitation has relatively little impact on practical applications, making this disadvantage acceptable in practice.

Examples of CURE are as follows:

Success Example 1

• Scene: a bottled unsweetened tea, an orange, and a bag of jalapeno chips
• Task: Put jalapeno chips in the drawer.
• Action: pick-up jalapeno chips to bottom drawer
• Success: 0.9624221324920654
• Ambiguity: 0.9281229376792908
• Familiarity: 0.04835970117710531
• Confidence: 0.3781147508416325

Success Example 2

• Scene: a bag of kettle chips, an apple, and a Pepsi
• Task: Put that apple in the bottom drawer.
• Action: move apple to bottom drawer
• Success: 0.9762726426124573
• Ambiguity: 0.17079491913318634
• Familiarity: 0.03660911461338401
• Confidence: 0.8396180854178965

In the above two examples, the first example has a high task ambiguity due to the lack of specification on which drawer. Despite high expected success and familiarity, the execution confidence remains low. The second example clearly specifies "bottom drawer," significantly reducing task ambiguity. Although the expected success and task familiarity are similar to the first example, the execution confidence is significantly improved due to the clearer task instructions.

Failure Example

• Action: pick up RedBull
• Scene: a RedBull, a bag of jalapeno chips, and an orange soda
• Task: Bring me something with a kick.
• Success: 0.8931169509887695
• Ambiguity: 0.056598808616399765
• Familiarity: 0.08403261657804251
• Confidence: 0.7787547493353486

This is a typical failure example where the planned action is incorrect, but the confidence is high. The instruction is quite ambiguous here; the user actually wanted a bag of jalapeno chips, but the model mistakenly interpreted it as requiring RedBull. This reflects a lack of understanding from the model, failing to correctly interpret the instruction while erroneously perceiving it as clear.

Thank you for your thoughtful comments and valuable feedback. Below are our detailed responses.

W1. Requires more input data compared to baseline methods. acquiring prerequisite tasks might be challenging.

We can obtain task datasets by simulating tasks in virtual environments, which is a common and effective way to gather data. In this paper, we employed the following two dataset generation methods:

1. LLM-based generation: We first randomly select three items and then use a large language model to indirectly indicate the desired option. For example, if the selected items are water, oranges, and chips, the LLM might say, "I am thirsty; give me something to quench my thirst." This constitutes a task dataset.

2. Script-based direct generation: For instance, we generate water, oranges, and chips and set the task as placing the chips next to the fruits.

For more complex tasks, we can use virtual simulation environments to generate data and combine them with real-world datasets. While obtaining data for prerequisite tasks may present certain challenges, we believe these methods can effectively address the issue.

Moreover, in a mature robotic system, pre-training typically requires numerous training examples. These pre-training examples can serve as prior tasks, thereby resolving the issue in practical applications.

W2. Training and Tuning of hyperparameters, resulting in higher computational and engineering costs.

The primary computational cost comes from the UAN and RND components, both of which are relatively small multi-layer neural networks. Consequently, the inference cost is very low. Specifically, the UAN and RND networks are three-layer neural networks with 4096, 128, and 32 neurons, respectively. Each network inference consumes only 0.53 MFLOPs.

The feature vector computation can leverage caching at the end of the planning model’s execution, so it does not incur additional computational overhead. While training the networks indeed requires considerable resources, this process can be conducted in the cloud, eliminating the need for on-device computation. Moreover, the trained model can be reused multiple times. Overall, although the computational resource cost increases, it is justified given the improvements in safety.

Regarding hyperparameter optimization, this paper uses the same hyperparameter settings for two distinct tasks, and the experimental results demonstrate that this configuration achieves good performance. Therefore, there is no need to spend too much effort on hyperparameter tuning.

W3. Cannot generalize without retraining.

This is indeed an important consideration. However, the main goal of this paper is to enhance the reliability of embodied intelligence systems, reducing dangerous and unintended behaviors. Therefore, when the system encounters tasks outside the training set, we recommend refusing to execute them. This can be achieved by evaluating task familiarity. While this approach may sacrifice generalization capability, by refusing to perform unfamiliar tasks, we can significantly enhance the system's reliability.

Q1. How sensitive is the performance of the CURE model to the quality or scale of prior task datasets used for RND?

We conducted experiments on dataset scale, and the results are as follows:

The experimental results demonstrate that increasing the dataset scale significantly improves the performance of the CURE model. When the dataset reaches about 10,000 samples, the performance improvement becomes noticeable, and further scaling up to 100,000 samples still yields continuous gains.

Additionally, we investigated the impact of dataset quality on the model. The datasets in this paper were generated both via LLM (large language model) automation and manual definition. For specific generation methods, please refer to our response in W1. The model performed well on datasets constructed using these methods, indicating that CURE’s performance is relatively less dependent on data quality. In other words, the model can effectively utilize automatically generated datasets to achieve robust performance.

Q2. Can CURE still function effectively without RND, i.e., in the absence of task familiarity data?

Yes. In Table 1, we present the experimental results of the CURE algorithm without using RND (i.e., CURE w/o sim). These results show that even without task familiarity data, CURE outperforms baseline methods and maintains a certain level of advantage.

Q3. Have you tested generalization to new task types or domains unseen during training?

We tested on objects that were unseen during the training phase, and the results are as follows:

1. Task: Give me a hamburger Action: Pick up the hamburger and give it to the user. Scene: An orange, an apple, and a hamburger. Success Rate: 0.9565 Ambiguity: 0.3486 Task Familiarity: 0.0667 Confidence: 0.6898

   In this example, although the hamburger is an unseen object, CURE can determine that the task instruction "give me a hamburger" is relatively clear, achieving a high success rate with a confidence level of 0.69.

2. Task: Give me a hamburger Action: Pick up the hamburger and place it in the bottom drawer. Scene: An orange, an apple, and a hamburger. Success Rate: 0.3540 Ambiguity: 0.3025 Task Familiarity: 0.0796 Confidence: 0.2102

   In this example, the same task instruction "give me a hamburger" was executed incorrectly, with the model mistakenly placing the hamburger in the bottom drawer. The success rate is low (0.3540), and confidence drops to 0.21. These two examples demonstrate that the CURE model can accurately assess uncertainty even when handling unseen objects, showcasing a degree of generalization capability.

3. Task: Heat the hamburger Action: Pick up the hamburger and place it in the microwave. Scene: An orange, an apple, and a hamburger. Success Rate: 0.9311 Ambiguity: 0.7558 Task Familiarity: 0.2581 Confidence: 0.2508

   The third example illustrates another scenario where the task instruction "heat the hamburger" is unseen in the training set, which is a new task type. Since this task is unfamiliar, the task familiarity is very low, leading to low confidence. This result reflects the model's ability to prevent execution of unknown actions, thereby avoiding potential risks.

Q4. Can you provide some example tasks? How much annotation effort (e.g., success/clarity labels) is required to train UAN?

In this paper, we generated 100,000 training samples.

Crucially, the generation of success/clarity labels for these 100,000 samples was achieved through automated methods (LLM simulation, scripted checks in simulation), requiring minimal manual intervention. This significantly reduces the practical labeling burden.

Additionally, we tested the results with varying training dataset sizes; please refer to the response to Q1 for detailed results.

Here are some example tasks:

Success Example 1

• Scene: A bottled unsweetened tea, an orange, and a bag of jalapeño chips.
• Task: Put jalapeño chips in the drawer.
• Action: Pick up jalapeño chips and place them in the bottom drawer.
• Success: 0.9624
• Ambiguity: 0.9281
• Familiarity: 0.0484
• Confidence: 0.3781

Success Example 2

• Scene: A bag of kettle chips, an apple, and a Pepsi.
• Task: Put the apple in the bottom drawer.
• Action: Move the apple to the bottom drawer.
• Success: 0.9763
• Ambiguity: 0.1708
• Familiarity: 0.0366
• Confidence: 0.8396

In the first example, the task does not explicitly specify which drawer, resulting in higher task ambiguity. Despite relatively high success and familiarity rates, the execution confidence remains low. In the second example, the task explicitly specifies "bottom drawer," significantly reducing task ambiguity. Although the expected success rate and task familiarity are similar to the first example, the clearer task instruction leads to significantly higher execution confidence.

Failure Example

• Scene: A RedBull, a bag of jalapeño chips, and an orange soda.
• Task: Bring me something with a kick.
• Action: Pick up RedBull.
• Success: 0.8931
• Ambiguity: 0.0566
• Familiarity: 0.0840
• Confidence: 0.7788

This is a typical failure case where the planned action is incorrect, yet the confidence is high. Here, the instruction is somewhat ambiguous; the user actually wants a bag of jalapeño chips, but the model incorrectly interprets the instruction and selects RedBull. This reflects the model’s limited understanding and failure to correctly interpret the instruction while mistakenly assuming the instruction is clear.

Q5. How to calibrate?

Our approach involved splitting the test set into two parts: one for calibration and the other for testing. Given a target success rate, we first determined a threshold on the calibration set. Tasks with confidence below the threshold were completed with human assistance, while tasks with confidence above the threshold were executed autonomously. By adjusting the threshold, we could make the success rate approach the target success rate, thereby achieving calibration.

We tested this method for a target success rate of 85%. The results showed that the success rate on the test set reached 84.33%, differing from the target by only 0.67%. This demonstrates that the CURE method achieves good calibration accuracy.

Q6. Why were different models used for different tasks?

Since the second tabletop placement task was relatively simple, we achieved satisfactory results with the 8B model. To save computational resources, we opted to use the 8B model.

Q7. How should the model be selected when encountering new domains?

If computational resources allow, selecting a larger model generally leads to better performance.