Towards Reliable Code-as-Policies: A Neuro-Symbolic Framework for Embodied Task Planning
Authors: Sanghyun Ahn
Wonje Choi
Junyong Lee
Jinwoo Park
Honguk Woo
Venue: NeurIPS 2025 spotlight ()
Keywords: neuro-symbolic
embodied task planning
large language model
Primary area: reinforcement_learning
TL;DR: Towards Reliable Code-as-Policies: A Neuro-Symbolic Framework for Embodied Task Planning

Abstract: Recent advances in large language models (LLMs) have enabled the automatic generation of executable code for task planning and control in embodied agents such as robots, demonstrating the potential of LLM-based embodied intelligence. However, these LLM-based code-as-policies approaches often suffer from limited environmental grounding, particularly in dynamic or partially observable settings, leading to suboptimal task success rates due to incorrect or incomplete code generation. In this work, we propose a neuro-symbolic embodied task planning framework that incorporates explicit symbolic verification and interactive validation processes during code generation. In the validation phase, the framework generates exploratory code that actively interacts with the environment to acquire missing observations while preserving task-relevant states. This integrated process enhances the grounding of generated code, resulting in improved task reliability and success rates in complex environments. We evaluate our framework on RLBench and in real-world settings across dynamic, partially observable scenarios. Experimental results demonstrate that our framework improves task success rates by 46.2\% over Code as Policies baselines and attains over 86.8\% executability of task-relevant actions, thereby enhancing the reliability of task planning in dynamic environments.

Towards Reliable Code-as-Policies: A Neuro-Symbolic Framework for Embodied Task Planning
Sanghyun Ahn', Wonje Choi', Junyong Lee', .Jiwwoo Park², Honguk 1.0 Department of Computer Science and Engineering, Sungkyunkwan University DDpartment of Artificial Intelligence, Sungkyunkwan University (shyuni5, wjehoi 1995, ljy7488, pjw971022, hwoo) @skku.edu
Abstract
Recent advances in large language models (LLMs) have enabled the automatic generation of executable code for task planning and control in embodied agents such as robots, demonstrating the potential of LLM- embodied intelligence. However, these L.LM-based code-as-policies approaches often suffer from limited environmental grounding, particularly in dynamic or partially observable settings, leading to suboptimal task success rates due to incorrect or incomplete code generation. In this work, we propose a ncuro-symbolic embodied task planning framework that incorporates explicit symbolic verification and interactive validation processes during code generation. In the validation phase, the framework generates exploratory code that actively interacts with the environment to acquire missing observations while preserving task-relevant states. This integrated process enhances the grounding of generated code, resulting in improved task reliability and success rates in complex environments. We evaluate our framework on RLBench and in real- world settings across dynamic, partially observable scenarios. Experimental results demonstrate that our framework improves task success rates by 46.2% over Code as Policies baselines and attains over 86.8% exccutability of task-relevant actions, thereby enhancing the reliability of task planning in dynamic environments,
Introduction
Recent advances in embodied control have leveraged large language models (LLMs) to enable flexible, instruction following, effectively bridging natural language understanding with executable actions in physical environments. For instance, SayCan [T] combines LLM-based task interpretation with reinforcement learning (RL) affordance model construct a hybrid policy that grounds high- level language instructions, such as "bring me the sponge." into sequences of low-level, predefined robotic skills. Building on this foundation, subsequent approaches have explored more expressive and compositional modes of action specification through code generation, introducing the paradigm of code-as-pon poolices 12, 3 where LLMs directly generate executable code to control embodied agents. This shift enables task planning that is more modular, interpretable, and adaptable to diverse environments, highlighting the potential of LLMs as general-purpose planners for robotic control.
While LLM-based code-as polpiiicess approaches have demonstrated promising capabilities in fully observable and well-structured settings, their reliability deteriorates in dynamic or partially observable environments, where perceptual input is often sparse, delayed, or ambiguous. These limitations lead incorrect or incomplete code generation, ultimately resulting in suboptimal task performance. For example, attempting to grasp a fragile object without access to accurate depth or height estimation may lead to dropping or damaging the object, preventing task completion. These challenges underscore
Corresponding author
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Clean the desk
(1) Naive Code Generation
(2) Verified Validated Code Generation (ours)
Intbal Observation
Claan up the deet
Clean up the desk
Large Language
Ungrounded
divvet enerys
Coda Gemenation
Moomiodic, awer, handlt, sardk..
Ungrounded Code
Pu Nniddio drower, handle,
Coald Aveen
Ungrounded Code
pultriddie, Srower handeee.d
Ungroeable Oode
Are the drawers emply?
pid/niidie, drawwer
Are the di swarss locked?
table
pultmiddle drawerr handla, meed...
Grounded Code
2
Crounded Code
Grondd
the
pikltop whwp:ddreerreeeee
stotiop, Srrwer chnnr.h pultop prower hunde u.
pdttop Srawer, handlo, hradwr,
aeven..
middle, drower locked!
book book the bookshelf
Recursio 1
bottom, drower
Task
Task
three-lovel drawer
Fallure
Success
Recursive
Figure I: Concept of our NESYRO framework illustrated with an example of a room cleaning task where drawer states are initially unknown. While (1) naive code generation fails without detecting missing observations, (2) NEŠYRO recursively probes the environment to recover drawer states, enabling the generation of grounded code that successfully completes the task.
the critical need for embodied agents to explicitly reason about uncertainty through exploratory yet safe interactions, and to verify the correctness of generated code prior to execution.
To address these challenges, we propose NESYRO, a neuro-symbolic robot task planning framework that incorporates explicit symbolic verification and interactive validation processes during code generation. Drawing inspiration from the long-standing software engineering principle of verification and validation (V&V) 6 7. our framework distinguishes between two key processes: verification ensures that the generated code is logically consistent and satisfies symbolic preconditions, while validation assesses whether the code suitable for the current environment and task objectives. Specifically, symbolic verification statically checks code correctness using domain-specific symbolic tools, whereas interactive validation enables the agent to actively explore its environment to resolve ambiguities and acquire missing observations before task-specific execution.
Our NESYRo framework operates through a recursive composition of two phases: (i) Neuro-symbolic Code Verification, and (ii) Neuro-symbolic Code Validation. Following symbolic verification for code correctness, the interactive validation phase grounds each skill by identifying preconditions and invoking exploratory actions that establish those preconditions as effects, thereby transforming the environment state to enable the intended skill. This process resembles a form of backtracking search, where the agent navigates the environment to construct valid execution path, progressively verifying and validating the code based on current observations and feedback from symbolic tools.
Figure D shows the concept of our framework through an object relocation task, comparing a naive code generation method and our approach. The naive method attempts move an object without adequately accounting for uncertain factors, which results in the execution of actions that prevent task success. In contrast, our framework identifies the need for exploratory actions, ensures they conducted safely, and successfully completes the task without causing damage.
We evaluate NESY Ro four task categories, including object relocation, object interaction, auxiliary manipulation, and long-horizon tasks, using both the RLBench [8] simulation and real-world settings. Experimental results demonstrate that NeSYRo improves task success rate by 46.2% over the state- th-the-art baseline, Code as Policies [2] while achieving over 86.8% executability of telk-relevant actions in real-world settings. These underscore the enhanced reliability of our framework for robust task planning in dynamic, partially observable environments
The contributions of this work are summarized as follows:
We present the NESYRO framework enable the automatic generation of executable code for task planning in dynamic, partially observable environments.
We propose a novel recursive mechanism that combines symbolic verification and interactive vali- dation to actively infer and satisfy task-relevant preconditions through exploratory code execution.

---

Extensive evaluations on RLBench and real-world tasks demonstrate that NESYRO significantly improves both task success rates and the executability of task-relevant skills.
2 Related work
LLM--baed embodied control. In the field of embodied control, there is an emerging trend of
utilizing LLMs for reasoning and planning tasks [ I0 12 high-level reasoning capabilities of LLMs, recent approaches have explored generating executable code as a direct control policy, paradigm often referred to wode-as-polictss 22] Rather than mapping instructions to predefined skills or discrete action primitives, these methods prompt LLMs generate Python-like scripts that can be directly executed by embodied agents such as robots. This demonstrates that LLMs are capable of synthesizing low-level control logic, enabling greater flexibility and generalization across diverse range of tasks. Yet, in dynamic or partially observable settings, the generated code often lacks proper grounding, resulting in incomplete or non-executable outputs. To mitigate this, NESYRO enhances the environmental grounding and reliability of generated code by integrating explicit feedback into the code generation process.
13
14
15
16 Building on the
18 19).
Code verification and validation. Verification and validation are foundational techniques in software engineering for ensuring the correctness and robustness of programs. Verification typically involves static analysis methods such as formal verification, theorem proving. and model checking (20 21 22
23
aiming to prove that a program satisfies its specification before execution. Validation assesses runtime behavior through unit testing, integration testing, system-level evaluation, and runtime verification 7 25 6 26 27]. ensuring that the code performs as intended under real-world conditions. Recent works have explored combining these principles with LLMs improve code reliability via Still, existing approaches are -oolld environments, which is an essential requirement for embodied agents. Our framework addresses this by enabling agents to identify missing task-relevant observations in dynamic and partially observable environments.
various forms of static analysis and runtime feedback [28 29 5].
limited to static or simulated settings and lack grounding
Neuro-symbolic system. Recent neuro-symbolic systems combine the generalization capabilities of LLMs with the robustness and interpretabilitty of symbolic reasoning tools. This hybrid approach has been actively investigated in areas such as symbolic problem solving, planning, and program
synthesis 30 31 32
35 36]. Neuro-symbolic approaches in embodied agents commonly employ LLMs for perception and natural language instruction understanding, while utilizing symbolic tools to perform high-level task planning [37
33
34
40 [1). However, existing neuro-symbolic agents rely on fixed modular structures or pre-detined procedures, limiting their adaptability to missing observations and environmental uncertainty. NESYRO integrates symbolic reasoning with interactive validation and exploratory interactions, enabling reliable task planning in dynamic environments.
38
39
3 NESYRO Framework
3.1 Problem Formulation
We tackle the automatic generation of executable code for task planning and control in embodied agents operating in dynamic, partially observable environments. The environment is modeled as Partially Observable Markov Decision Process (POMDP) M (S,A, T, R, O) [2 43 14,, where 8 E S is a state, a E AA an action, and g E G is a high-level goal (e.g.. "pick up the red mug"). T x A + S is the transition function describing dynamics. The reward function R: S x A x G + {0, 1} returns binary success signal, which is common in robotics where only task completion is observable. Due partial observability, observations
Ω are received via O : S x A + Ω. where observations are represented in symbolic form, composed of structured predicate-based based expressions (e.g., is lo_kel (drawer), on (object, surface)). Under the code- as as-policies paradigm, the LLM generates policy code from observation history and goal as input and internally encodes the actions necessary to complete the task. When executed via tool exe, yields policy exe(x)) The set of policy codes is II {TT exe(IT) Ω² + A}. where Ω2 is the set of all finite observation histories Oct (oo....,..) 0:) with each 0; E Ω. Our goal is to find the policy code that maximizes the expected return:
3

---

Pipeinn
NoSyRo Framework
Sha Buller
Neuro-symbolic Code Verification
Sale Probe Pipelino
horet
Vertccaton
Maer
full
LLM-based code genaration
Fin
Symbolic-based code verification
Neuro symboo-ymlllc
Nowvldge
Buck
Code Verificttion
Marr-aymbett Verticatio
tehheimn
Pully Code
Neuro-symbolic Code Validation
Vertied Patlcy Codari.. U/ fo- Aur fat
Deconatraions
Sullerng
Neuro-symbolic Code Validation
Maas-emmbllc
Policy Refinament
(D) (4)
6.3+AAG,
Sule Padto
Sense Confidence
Logic Confidence
Tram
NedyConi
NeSyCouf CSC, x 14p
Recursive go
Neuro-symbolic Confidence
Figure 2: The NESYRO framework with Neuro-Symbon Code Verification and Neuro- Semro-Symbolic Code Validation phases. It recursively verifies and validates the policy code, while incrementally acquiring observations.
π = argmax TEll g~
E
R(s, cxo(T)((s))..)
Here, T = (So: Og. ag. $1, 01, 01...... denotes the trajectory generated by executing exe(T) in the environment, and (eexe (T)) (T) is the resulting trajectory distribution induced by exe(1) under g. T, and O. In our implementation, each action a, in T corresponds to a skill function composed of multiple low-level control APIs encoded within æ. Since M is partially observable, x² must balance exploration (to reduce uncertainty) and exploitation (to achieve goals), ensuring reliable task planning in dynamic environments.
3.2 Overall Framework
To achieve the objective described in Eq. ( we introduce NESYRO, designed to achieve the genera- tion of executable and grounded code through dynamic reconfiguration of reasoning components. As illustrated in Figure 2 NESYRO operates in two key phases: Phase i), Neuro-Symbolic Code Verification, which ensures the logical correctness of the policy code with respect to the generated task specification; and Phase ii), Neuro-Symbolic Code Validation, which ensures environmental feasibility by evaluating and refining skills based on their grounding.
In the verification phase i), given a language instruction g and current observation Ogt, the LLM generates task specification Tepec along with the initial policy code Tmain The symbolic tool then verifies whether Tmain satisfies Tapee- If verification fails, the symbolic tool provides feedback to the LLM, which iteratively refines maain until a verified version is obtained. In the validation phase ii), the sequence of skills defined in miain is validated sequentially using a neuro-symbolic confidence score, NeSyConf, which integrates symbolic feasibility and commonsense plausibility. If a skill's confidence score falls below a threshold e, NESYRO synthesizes a safe probe policy code _ probe to recover missing observations. probe recursively processed through the composition of the verification and validation phases until all skills are grounded.
This recursive structure induces a policy tree rooted at Tmain, where each Tprohe serves subroutine that enables successful validation of its parent. The recursive process continues until all required observations have been acquired and every skill in maain is validated. The final output is grounded version of Tmain, aligned with both Tapeo and the current environment.
3.3 Neuro-symbolic Code Verification
LLM- code generation. Given language instruction g and observation ocr, a verification LLM, denoted as Pven, is prompted to reason in a chain-of-thought (CoT) manner [44] 45), synthe- sizing key objectives and constraints into task specification Tapec It then uses this specification to generate the policy code Tr for instance in Python, defining sequence of skills along with their

---

parameters and required libraries.
veri (ogts 9, Loon D, D, mmmii veri m2) + (Tapee, T m
(2)
Here, Ogr is the current observation, initially from op and incrementally updated via probe. Leor the CoT prompt guiding the veei to generate the specification as an intermediate step. 'D denotes domain knowledge, consisting of available skills represented as parameterized function calls, each defined by its applicability conditions and resulting effects, as well as object types and attributes that map these skills to the environment. F is verification feedback from the previous iteration, used by the
LLM to generate the revised T maain Importantly, T T and veri are provided only when the previous verification attempt has failed. The index n indicates the skill function call order Tmain from which the code refinement begins, while calls prior to n remain unchanged. When n=0, it corresponds to the initial code generation. The resulting Tapes captures the high-level intent, constraints, and relevant subgoals derived from the 9 and Oge. Taain is then passed to the symbolic verification tool.
Symbolic-based code verification. Next, a symbolic verification tool veri (i.e., SMT solver) checks whether main satisfies Tspec. identifying any violations of constraints defined in the specification.
verified maain
if verification succeeds if verification fails
vers
(Tspec: Fmainn)
(3)
F
veri
If verification fails, veni provides detailed F that identifies the specific parts of x violating Tapecs such as incorrect parameter bindings or structural mismatches. This feedback is then passed to the next veri iteration to generate a revised . "main" Once Timain passes verification, resulting in a verified version of main, we proceed to the Neuro-Symholic Code Validation phase.
3.4 Neuro-symbolic Code Validation
The verified policy code maain is parsed into sequence of skill function calls, Tmain (fo. fi....,xx fN). where N denotes the maximum skill step. Unlike the Newro-symbolic code verifi- cation phase. which reasons over the entire maain holistically, the validation process evaluates and refines each skill sequentially to assess its feasibility in the current environment. The index n, as in Eq. 2 denotes the skill step under validation and represents the first unvalidated step in Mumin-
Neuro-symbolic confidence score. To assess skill feasibility, we introduce Neuro- Suuoo-yymoolic Con- fidence score (NeSyConf), which combines Common Sense Confidence (CSC) from a validation LLM denoted vali and Logic Confidence (L.C) from a symbolic validation tool Vali in parallel.
Pali : (D, Edemo: Ogt, 9: fm) + CSC,..
The CSCS, estimates the likelihood that a given skill fn E Tmain will succeed under the current observation oge and instruction g. based on both domain knowledge DD and retrieved demonstrations Edemo- To compute this, we insert the code snippet corresponding to fn into the LLM prompt along with D. Oct. 9. and Edemo- Pvali then assigns token-wirg wise probabilities compute a perplexity-basee are normalized to produce a consistent confidence CSC To reduce hallucinations and improve estimation accuracy, we retrieve skill-level demonstrations Edemo whose contexts closely resemble the current situation and include them in the prompt as guidance.
the fn. and we score to estimate the skill's plausibility. The cumulative log probabilities
T (D, Octs 9, fn) + LC
(5)
The logic-based confidence LC,, computed by the symbolic validation tool (i.e., PDDL planner), which assesses whether the fn is symbolically feasible under the oct, y, and D. We use V.ali to check whether fn fa's preconditions hold in oct- If the planner successfully generates plan including fn. we set LC 1; otherwise, set LC,, O, indicating symbolic infeasibility under the oge.
NeSyConf, CSC,, LC with: proceed NeSyConf fot1?
if NeSyConf, 2e (6)
generate Trrobe using Fese, Fie otherwise
The NeSyConl, represents the final confidence score for Sn, computed by multiplying CSC,, and I.C,,. - This score estimates whether fn is correctly grounded in the environment and likely to succeed upon execution. If NeSyConf, < e, our framework initiates a safe probe policy code Tprobe using feedback from each component, namely Fese and Fic.
5

---

Safe probe. a fn receives a low confidence score, our framework responds by generating safe probe policy code Trohe to recover missing observations. Constructed using Fesr from CSC and Fic from L.C, pmobe undergoes the same verification and validation process as maiin Because Troohe is validated before execution, the framework ensures that only safe and grounded code is deployed. This recursive structure generates a policy tree rooted at mmain- where each prrobe functions as subroutine that enables successful validation of its parent skill. Once probe is executed, it collects new observations and updates the current observation to ost+1. This updated observation is then used in the subsequent Policy code refinement process to update mmain-
Policy code refinement. Following safe probe, the 0gt+1 is used to refine Tmain at the skill level. Specifically, instead of regenerating the entire policy, our framework targets the current fn and prompts the LLM to regenerate only its code segment using the ogr+1- This regeneration is conducted through our Neuro- symoo--ymmolic Code Verification process. The updated code for fu then evaluated using Eq. (6). where its confidence score NeSyConf, is reassessed. This process of refinement and safe probe is repeated until NeSyConf, f.. 2 c. Once all skills f maiin have been successfully validated, the grounded Taain is executed.
Further implementation details, and algorithmic pseudocode are provided in Appendix
4 Experiment
4.1 Experiment Setting
Environments. We conducted experiments in both RLBench [8] and real-world settings using 7- DoF Franka Emika Research 3 robotic arm, enabling reproducible evaluations via randomized initial states and instructions to analyze safe probe strategies in dynamic, partially observable scenarios. In contrast, real-world experiments evaluated robustness and generalizability under real-world noise and variability. In dynamic, partially observable scenarios, we defined four observability levels based on initial observation availability: High Incompleteness condition removes more than half of the essential observations, constraining the task-solving process. Low Incompleteness condition retains most observations, though the observation remains partially incomplete. Stochastic Incompleteness condition provides randomly selected subset of observations, with the incompleteness level varying across episodes. Finally, Complete condition offers full relevant observations, rendering probe unnecessary. We denote these four levels as High, Low, Stochastic, and Complete, respectively, each evaluated over ten randomized trials with varied initial conditions and instructions.
Table 1: Task types and their corresponding probe types
Task Type
Probe Type
Object Relocation
Robot Pose Adjust
(c.g., moving tomatoes on a plate)
(c.g., verifying which item is a tomato)
Object Interuction
Object State Check
(e.g.. opening a drawer)
(e.g.. checking whether a drawer is locked)
Auxiliary Manipulation
Object State Change
(c.g., opening a drawer in dark room)
(c.g., turning on the light to locate the drawer)
Long-IHrizzn
Uses two or more of the above probe types depending on task structure and uncertainty
(e.g., placing a tomato inside drawer)
Task and probe types. In dynamic, partially observable enviromments, tasks often require acquiring missing observations before execution. To support structured analysis of the probe, we define task types based on manipulation goals and missing observation roles. Specifically, we distinguish whether the uncertainty concerns object identity, object state, or auxiliary conditions. These distinctions define three task types, each reflecting distinct sneevaation-seeinng pattern. In addition, long- horizon tasks involve multi-step goals. Correspondingly, we define three probe types to characterize observation acquisition: (1) Robot Pose Adjust, adjusting viewpoint to resolve ambiguity; (2) Object State Check, identifying hidden object states relevant to the task; and (3) Object State Change, performing auxiliary skills to enable observation of otherwise inaccessible states. These categories are functionally defined

---

Table 2: Task performance under varying levels of observability incompleteness in RLBench
Methods
High
Low
Stochastic
Complete
SR
GC
SR
GC
SR
GC
SR
GC
Task Type: Object Relocation
25.0
41.5
3..0
43.8
10.0
36
90.0
92.5
CaP Lemur
25.0=7.1
43.8
30.0=0.0
43.8
10.0=0.0
36.3
90.0=00
96
CaP w/ CodeSift
55.0.1..1
72.5
50.0=000
57.5
40.0
52.5
95.0
95.0.1.1
LLM-Planner
30.010.0
35.0
50.0=0.0
58.8455
30.0
43.8
80.0
88.8
AutoGen 30.0=0.0
35.0
55.0=7.1
60.0
40.0=14.1
47.5
85.0
17.5
NESYRo
70.0
12.5
75.0
87.5
65.0
75.0
95.0
97.5.13.5
Task Type: Object Interaction
CaP
20.0
35.0
25.0=1.1
40.0
35.0=7.1
51.3
75.0
77.5
CaP w/ Lemur
35.0:t.11
47.5+7.
35.0=1.1
47.5+33
30.0=14.1
46.3
85.0
86.3
CaP w/ CodeSift
40.0
65.0
50.0
55.0
4..0
60.0
90.0
90.0=14.1
LLM-Planner
5.0
15,0=00
40.0-14.1
53.8
35.0=7.1
42.5
55.0
63.8
AutoGen 40.0.10.0
48. 8.18
50.0
58.8
50.0
57,5
75.0
76.3
NESYRo
70.0
8..0
83.8
70.0
73.8 488.
90.0
92.5.10.0
Task Type: Auxiliary Manipulation
CaP
25.0=171
25.0=7.1
50.0=0.0
$1.3
40.0=000
45.8
85.0
90.0:14.7
CaP w/ Lemur
30.0:11.1
30.0
50.0=14,1
58.31771
30.0=14.1
34.2+153
85.0
90.8
CaP w/ CodeSift
5.0
5.0=7.1
55.0-2.1
57.5
35.0=7.1
35.0=7.1
90.0
93.3++0.0
LLMM-Planner
15.0=7.1
15.0=7.1
30.0-000
37.5+33
10.0=14.1
15.0
75.0=7.1
80.0:00.0
AutoGen 15.0.7.1
15.0
35.0
40.0..0.
20.0
22.5
80.0
80.0
NESYRO
60.0
80.8+112
70.0-14.1
74.2
70.0=14.1
85.8
95.0
96.7+44.7
Task Type: Long-Horizon
CaP
0.0
0.0
20.0=0.0
40.4
0.0:000
0.7=100
40.0
53.8
CaP w/ Lemur
0.0::0.0
0.0=0.0
30.0=0.0
47.1
0.0:0.0
1.6:002
55.0
67.1:15.1
CaP w/ CodeSift
0.0
0.0=0.0
30.0=14.1
45.84199
5.0+7.1
5.0=7.1
65.0=7.1
71.42667
LLM-Planner
0.0::0.0
0.0=0.0
10.0=00
11.4200
5.0.00
12.9
35.0=7.1
44.4:99
AutoGen
0.0::0.
5,5=3.0
30.0-14.1
39.2+100
20.0=000
28.5
50.0+00
55.1
NESYRO
45.0:=7.1
65.2
45.0=1.1
58.1
35.0=7.1
41.9
65.0
73.7
and implemented for distinct behavioral purposes, thereby enabling generalization to varied settings. We describe the task types and their associated probe types in Table []
Evaluation metrics. To assess the objectives in Section 3.1 we adopt metrics from prior work (46) 11 (4 48). Success Rate (SR) assigns 100% for full task completion and 0% otherwise. Goal Condition (GC) measures the percentage of sub-goals achieved. In real-world experiments, we report Inreversible Actions (IA), counting irreversible actions during task execution.
Baselines. We compare our approach against several state-of-the-arr baselines that use LLMs to generate robot control code, covering different paradigms of V&V, reasoning, and replanning. Code as Policies (CaP) generates reusable control code from task instructions via LLM. CaP w/ Lemur 49 integrates SMT verification into the code generation pipeline. CaP w/ CodeSift (5 improves the reliability of LLLL- --geerrrrrteed code through multi-stage syntactic and semantic validation, without relying reference code or actual execution. LLM-Planner (11) introduces an execution- aware replanning framework, replans after failure using new observations from the environment. AutoGen 50 extends LLMM-Planner by enabling multi-agent collaborative reasoning.
NeSYRO implementation. We employ GPT-4o-min -inniii (5I) for code generation and feedback generation. Additionally, Llama-3.2 3.naa-3..-333 2B [52] is used to compute the CSC. The decoding temperature
is fixed at 0.0 for all generation steps. For the verification phase (i), the Z3 SMT solver (20) is employed the symbolic verification tool, while for the validation phase (ii), the Fast Downward planner 53 is used as the symbolic validation tool.
Detailed descriptions of the experimental settings are provided in the Appendix B and
4.2
Main Result
Task performance on RLBBenc.. Table 2 reports the performance of robot control code across all task types in dynamic, partially observable scenarios. For each task, we consider four levels
7

---

Table 3: Task performance across task types in the real-world under partial observability (High and Low Incompleteness averaged). MEsYRR--Comple reports results under Complete.
Real- World
CaP
CaP w/ CockSin
NoNyRo
Nomplo-Compit
Tisk Type
(R)
GC(()
(A)
SR (T)
GC (1)
(A)
SR
GCX1)
(A
SR (1>
GC
IA (
Object Relocation
7,5
11.3
19
12,5
19.4
4
82.5-15
83.8
2
85.0=11
90.0c5
Interaction
12
20.0:71
24.4.41
4
75.
77.5.003
90.0
90.0.111
Auxiliary Manipalazion
00
8.3.11
20.0.4
2000.00
2000:111
20.0
Long Horizon
5.0.00
14.2
18
13.1
16
52.5
54.2
60.0
65.3
Total
10.5
15.7
53
10.6 (44
16.3
29
57.5.15
58.9144
7
68.8 53
71.5
Place dice into
Open drnwr
Move the from foor the sheil
as Policies
NeByRo
Code Policiua
NaByRo
Code Policiso
NaByRo
Figure 3: Representative failure scenarios under partial observability across real- tasks
of observability incompleteness, requiring each method to recover missing observations. NESYRo consistently outperforms baselines (AutoGen and CaP w/ CodeSift) by 26.3% in SR and 24.3% in GC across all levels of observability incompleteness.
CaP w/ Lemur outperforms the base CaP model, indicating that pre-execution verification improves robustness even without explicit safe probe. LLM-based replanning methods, such as AutoGen and LLM-Planner, perform well compared V& V-baeed approaches, such as CaP w/ CodeSift, under the Low Incompleteness condition, but their performance degrades significantly as uncertainty increases and critical observations are missing. contrast, NESYRO sustains strong results across every observability regime and task type. It accurately detects missing observations and performs safe probes, avoiding irreversible actions. Under the Complete condition, all methods achieve high performance since no additional probe is required. As observability grows more incomplete, bascline performance drops sharply. Meanwhile, NESYRo detects the missing observations, explores safely, and maintains performance close to that of the Complete setting. This tendency becomes even more pronounced in long-horizen horizon tasks, where extensive probe is required and bridging observation gaps becomes especially difficult.
Task performance on Real- Table reports the real-world evaluation results under partial observability. The NESyRo-Complet configuration serves as upper bound, representing the ideal performance achievable when all relevant observations are fully available. Across all task categories, NESYRO consistently achieves the highest SR and GC, outperforming existing basclines such as CaP and CaP w/ CodeSift. On average, NESYRO improves SR by an average of 47.0% and GC by 42.6% compared to CaP w/ CodeSift, while simultaneously reducing IA from 29 to 7.
In particular, for Object Relocation and Object Interaction, baseline methods achieve less than 30% SR, primarily due to their failure to account for missing observations. In contrast, NESYRO exceeds 75% SR by recovering these observations. Performance on Auxiliary Manipulation remains low across all models, including RESyRR--Complet primarily due to failure in pressing the light switch with sufficient accuracy. Nevertheless, NESYRO achieves the same SR and GC as its Complete variant, indicating upper-bound performance despite the physical difficulty. This highlights the challenge as tasks, baseline
one of exccution, rather than perceptual or reasoning limitations. On methods remain below 10% SR due to observation gaps and planning complexity. Nonetheless, NESYRO reaches 52.5% SR, approaching the 60.0% score of the Complete setting. This shows that our framework bridges long-range dependencies through safe probing. These results confirm that NESYRo enables robust real-world execution through safe recovery of missing observations, even under severe observability incompleteness.
Figure illustrates failure modes associated with high IA scores. Among many failure cases, we present three representative scenarios where CaP fails due to irreversible actions, while NESYRO completes the tasks by recovering missing observations through safe probe. This selection illustrates that NES y Ro not only improves success rates but also ensures safe exccution grounded in safe probe.
8

---

4.3
Ablation
Table 4: Code generation performance across LLMs long- horizon tasks under partial observability in RLBench
60
RLBench
CaP
NeSyRo
NeSyRo Complete
20.
000
LLM Type
SR
GC
SR
GC
SR
GC
CaP
CaP Codesiftt NoGyño
Osject Relecation
Aucilaay Maripubrion
GPr--4-mmni
10.0gnn
20.2g
45.0.on
61.7.am
65.0gz1
73.7
Ozject inseaction
long-lleroon
o4-mini
12.5a35
22.0=11
42.5=35
54.9
50.0=14.1
51.7+118
GPT-4.1
32.5
59.6248
50.0=21
70.9
75.0
78.1
Figure Real-world compile eπror rate over all task types
45.0=an
64.0=19
75.0=71
87.6=30
85.0=71
93.8
Effect of neuro-symbolic code verification Table 4 reports performance across different LLMs used for code generation, evaluated on long-horizon tasks and averaged over High and Low Incom- pleteness conditions. Stronger LLMs improve performance. On average, NESYRO improves SR by 28.1% and GC by 27.3% over CaP across all LLMs. The SR difference between NESYRO and the upper-bound NESYRO- Ro-Coplleee remains at 15.6% on average, indicating that our framework consistently approaches the optimal performance achievable under complete observations. This shows that NESYRO performs consistently across L.Mss. Figure | reports real-world task failures due to compile errors across task types. NESYRO consistently exhibits the lowest compile error rate, highlighting the robustness of its verification and validation pipeline. In contrast, CaP w/ CodeSift incurs more compile errors than the base CaP under partial observability, primarily due to hallucinated evaluations by the LLM in the absence of grounded feedback. NES Y Ro addresses this issue through environment-awwen aware validation, enabling reliable execution even with incomplete observations.
Table 5: Comparison of performance long- morizon RLBench Table 6: Effect of LLM parameter scale on CSC in RLBench
tasks when without LC or CSC from NESYRO
RLBench
NeSyRo w/o LC
NeSyRo w/o CSC
NeSyRo
RLBench
Long-Horizn Tasks
Task Type
SR
GC
SR
GC
SR
GC
LLM Type
SR
GC
Object Relocation
50.0=s:
6000s11
35.0s5a
51.3
67.5
73.8:53
Object Interaction
45.0=71
563-53
55.0s71
62,5635
70.0=11
75.0s35
Llama-3.2 2-B
32,5
55.4=27
Auxiliary Manipulation
57,5=35
65.4e41
35.0+11
39,2a33
65.0=11
77.5
Llama-3.2-38 3,2-BB
45,0
61.7a03
Long-Horizon
25.0
36.0
32,5
52.9
45.0.00
61.7
Llama-3. 1-BB
45,0
57.7
Total
44.3
$4.2=0.1
37.1
49.9
61.9
72.0
Qwen3-30B-A3B
45.0
64.9
Effect of neuro-symbolic code validation Tables 5 and 6 report results on long-horizon tasks, averaged over High and Low Incompleteness conditions. Table 5 compares performance when removing either LCC (w/o LC) or CSC (w/o CSC) from our neuro-symbolic code validation phase. The results indicate that both LCC and CSC contribute comparably to overall performance across task types, with average SR drop of 21.2% and GC drop of 20.0% when either component is removed. This validates the importance of the parallel ncuro-symbolic structure in reliably guiding exccution under uncertainty. To analyze CSC robustness, Table 6 examines the effect of the LLM parameter scale used in computing the CSC. While smaller models (c.g.. Llama-3, 3.2- 1B) show degraded performance, models with 3B parameters more achieve the same SR and differ in GC by less than 7.2%. These results suggest that CSC computation is robust to LLM scaling beyond a moderate threshold, allowing flexible deployment depending available compute resources.
4.4 Analysis
Real-world analysis. Figure 5 showcases how NESYRO addresses real-world uncertainty in partially observable setting involving a dark room and unknown drawer states. Initially, the LLM generates an ungrounded policy code without access key observations, such as whether the drawers are locked, what objects are inside, or where to safely place the dice. As each skill is validated, NESYRO computes NeSyConf. If the confidence falls below a threshold, the system initiates a targeted safe probe, such as checking individual drawers, to acquire missing observations. These safe probes trigger policy code refinement by updating parameters (e.g., selecting different drawer) or regenerating the policy for the skill. This iterative validation process adapts the skill sequence and produces fully grounded policy code that completes the task without causing irreversible failures. full exccution sequence and extended analysis of Figure are provided in Appendix D

---

Place one dice into a drawer in dark room
Execute
Initial Environment
Safe Probe 1 (Targel di)
+ Safe Probe (Targel (E)
Safe Probe 3: (Targei (11
Now oit butlew
prabtic swwwe
Success
plck)riddie.
pickomisdicc.k
pulltn dil H....
2 pulliss .i.
X placeltr.
ploktop_H... H...
Reado
placetin....
pulltmode Hi
pickotion..))
pickictio.....
pickicke ...
pullipo _...)
pickitos .
pickitos, -
placejtis, :))
@ place)tos,
plac elaceedos...
pick(rash,
placetdion...
placejtion..
Palicy
03
03 00 +
11 0
03
3
01
00
30
00
NeSyConf: Unvelidated
NeSyCond: Validaled (Tgrate Needed))
NeSyCont: Validated (Ready execute)
Threshold
Figure 5: Real-world example of safe probe and policy code refinement in partially observable setting
Conclusion
In this work, presented NESYRO, neuro-symbolic framework that integrates Neuro-symbollic Code Verification and Neuro-Symbolic Code Validation to generate reliable robot control code under dynamic, partially observable settings. The framework operates through recursive process alternating between symbolic verification and interactive validation, ensuring that each skill is both logically consistent and environmentally grounded. By incorporating neuro-symbolic confidence estimation that combines commonsense and logic-based reasoning, NESYRO enables exploratory yet safe interactions and adaptive code refinement under uncertainty, Extensive evaluation in simulation and real-world environments demonstrates the strong performance of NESYRO across diverse tasks.
Limitation and future work. While the NeSyConf formulation is designed to allow LC and CSC to complement each other, similar to how SayCan (T) integrates LLM scores with affordance functions, the current implementation of NESyRO employs binary LC and predefined domain knowledge, which limits its generality in real-world applications. Future work will address this limitation by incorporating probabilistic and temporal reasoning. such as probabilistic PDDL (54). We also plan to relax these assumptions and explore the framework's s applicability to more diverse and dynamic domains by extending validation skills that not explicitly defined in the domain knowledge.
Ethical concern. LLM-based robot control may lead unsafe behavior when interacting with hazardous tools (e.g., knives, scissors), To mitigate such risks, incorporate explicit safety checks and enforce transparent safeguard mechanisms that verify tool affordances and action preconditions before execution, ensuring safe and interpretable operation.
10

---

Acknowledgement
This work was supported by Institute of Information & communications Technology Planning & Evaluation (ITPP) grant funded by the Korea government (MSIT), (RS-2022-I1220043 (2022- 0-00043), Adaptive Personality for Intelligent Agents, RS-2022-1122104 (2022-0-01045), Self- directed multi-modal Intelligence for solving unknown, open domain problems, ASS2005-002187766 Accelerated Insight Reasoning via Continual Learning, RS-2025-25442566 AI Star Fellowship Support Program (Sungkyunkwan Univ.), and School Program (Sungkyunkwan University)). the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (No. RS-2023-000 22200000221111 18), HITP-ITRT (Information Technology Research Center) grant funded by the Korea government (MIST) (IITP-2025- 2025-RS-2024 00437633, 10%). IITP-ICT Creative Consilience Program grant funded by the Korea government (MSIT) (ITTP-2025-H) 2020-2222021200011 821, 10%), and by Samsung Electronics.
Artificial Intelligence Graduate
References
[1] Anthony Brohan et al. "Do as can, not as say: Grounding language in robotic affordances". In: Proceedings of the 6th Conference on Robot Learning (CoRL). PMLR, 2023, pp. 287-318.
[2] Jacky Liang et al. "Code as policies: language model programs for embodied control". In: Proceedings of the 40th International Conference on Robotics and Automation (ICRA). IEEE, 2023, pp. 9493-9500.
[3] Wenlong Huang et al. "VoxPoser: Composable 3D Value Maps for Robotic Manipulation with Language Models". In: Proceedings of the 7th Conference Robot Learning (CoRL). Vol. 229. 2023, pp. 540-562.
[4] Yao Mu et al. "Robocodex: multimodal code generation for robotic behavior synthesis". In: Proceedings of the 41st International Conference on Machine Learning (ICML). PMLR, 2024,
pp. 36434-36454.
[5] Pooja Aggarwal et al. "CodeSift: An LLM-Based Reference-Less Framework for Automatic Code Validation". In: arXiv preprint arXiv:2408. 15630 (2024).
[6] Stefan Mitsch and André Platzer. "ModelPlex: verified runtime validation of verified cyber- physical system models".. In: Formal Methods in System Design 49 (2016), pp. 33-74.
[7] Martin Leucker and Christian Schallhart. "A brief account of runtime verification". In: The Journal of Logic and Algebraic Programming 78.5 (2009), pp. 293-303,
[8] Stephen James et al. "RLBench: The Robot Learning Benchmark Learning Environment".
In: IEEE Robotics and Automation Letters 5.2 (2020), pp. 3019-3026.
[9] Wenlong Huang et al. "Inner Monologue: Embodied Reasoning through Planning with Lan- guage Models"" In: Proceedings of the 6th Conference on Robol Learning (CoRL). Vol. 205. 2022, pp. 1769-1782.
[10] Wenlong Huang et al. "Language models as zero-shot planners: Extracting actionable knowl- edge for embodied agents". In: Proceedings of the 39th International Conference on Machine Learning. PMLR. 2022, pp. 9118-9147.
[11] Chan Hee Song et al. "LL.M-llaner: Few-shot grounded planning for embodied agents with large language models". In: Proceedings of the 19th International Conference on Computer Vision (ICCV). 2023, pp. 2998-3009.
[12] Zhenyu Wu et al. "Embodied task planning with large language models". In: arXiv preprint arXiv:2307.00 00000000448 (2023).
[13] Zihao Wang al. "Describe, explain, plan and select: Interactive planning with LLMs enables open-world multi-task agents". In: Proceedings of the 37th Advances in Neural Information Processing Systems (NeurIPS). 2023.
[14] Ishika Singh al. "ProgPrompt: Generating situated robot task plans using large language models".. In: Proceedings of the 40th International Conference on Robotics and Automation (ICRA). IEEE, 2023, pp. 11523-11530.
[15] Anthony Brohan et al. "RT-2: Vision- Lasion-Language-eee Models Transfer Web Knowledge to Robotic Control". In: Proceedings of the 7th Conference on Robot Learning (CoRL). PMLR,
2023, pp. 2165-2188
[16] Danny Driess al. "PaI.M-E: an embodied multimodal language model". : In: Proceedings of the 40th International Conference on Machine Learning (ICML). 2023, pp. 8469-8488.

---

[17] Kaylee Burns et al. "GenCHiP: generating robot policy code for tegh-precision and contact- rich manipulation tasks". In: Proceedings of the 37th IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). IEFE, 2024, pp. 1596-96033
[18] Yin Li et al. "MCCoder: streamlining motion control with LLM-as LLM-assisted code generation and rigorous verification". In: arXiv preprint arXiv:2410. 15154 (2024).
[19] Xiao Wang et al. "AutoMisty: a multi-agent LLM framework for automated code generation in the Misty social robot". In: Xrviv preprint arXiv:2503. 06791 (2025).
[20] Leonardo De Moura and Nikolaj Bjørner. "Z3: An efficient smt solver". In: International
Conference on Tools and Algorithms for the Construction and Analysis of Systems. Springer, 2008. pp. 337-340.
[21] Xiang Yin and John Knight. "Formal verification of large software systems". In: Proceedings of the Second NASA Formal Methods Symposium (NFM). 2010.
[22] Daniel Kroening. Peter Schrammel, and Michael Tautschnig. "CBMC C Bounded Model Checker". In: Tools and Algorithms for the Construction and Analysis of Systems. Vol. 8413. Springer, 2014, pp. 389-391.
[23] Leonardo de Moura et al. "The Lean theorem prover (system description).. In: Automated Deduction CADE-25. Vol. 9195. Springer, 2015, pp. 378-388.
[24] Jasmin Christian Blanchette and Lawrence C. Paulson. "Three Years of Experience with Sledgehammer, a Practical Link between Automatic and Interactive Theorem Provers". In: Proceedings of the 8th International Workshop on the Implementation of Logics (IWIL). 2010,
pp. 1-11.
[25] Sina Shamshiri et al. "Do automatically generated unit tests find real faults? An empirical study of effectiveness and challenges". In: Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 2015, pp. 201-211.
[26] Yun Tang et al. "Systematic testing of autonomous driving systems using map topology- -base scenario classification". In: Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 2021, pp. 1342-1346.
[27] James A. Whittaker. "What is software testing? And why is it so hard?" In: IEEE Software 17.1 (2000), pp. 70-79.
[28) Jingkang Yang al. "Octopus: embodied vision-language programmer from environmental feedback" In: Proceedings of the European Conference on Computer Vision (ECCV). Springer, 2024, pp. 20-38.
[29] Greta Dolcetti et al. "Helping LLMs improve code generation using feedback from testing and static analysis". In: arXiv preprint arXiv:2412. /484 (2024).
[30] Jundong Xu et al. "Faithful logical reasoning via symbolic chain-of-thhught", In: Proceedings of the 62nd Annual Meeting of the Association for Computationnll Linguistics (ACL). 2024.
[31] Shraddha Barke et al. "HYSYNTH: context-free LLM approximation for guiding program synthesis". In: Proceedings of the 38th Annual Conference on Neural Information Processing Systems (NeurIPS). 2024.
[32] Sumit Kumar Jha et al. "Counterexample Guided Inductive Synthesis Using Large Language Models and Satisfiability Solving". In: Proceedings of the IEEE Military Communications Conference (MILCOM). 2023, pp. 944-949.
[33] Theo X. Olausson et al. "LINC: A Neurosymbolie Approach for Logical Reasoning by Combining Language Models with First-Order Logic Provers". In: Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2023, pp. 5153-5176.
[34] Liangming Pan et al. "LOGIC-LM: Empowering Large Language Models with Symbolic Solvers for Faithful Logical Reasoning". In: Findings of the Association for Computational Linguistics (EMNLP). Association for Computational Linguistics, 2023, pp. 3806-3824.
[35] Debargha Ganguly et al. "Proof of thought: neurosymbolic program synthesis allows robust. and interpretable reasoning". In: Workshop on System 2 Reasoning at Scale, NeurIPS. 2024.
[36] Xin Quan et al. "Verification and refinement of natural language explanations through LLM- symbolic theorem proving". In: Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2024,
pp. 2933-2958.
12

---

[37] Xinrui Lin et al. "CLMASP: Coupling Large Language Models with Answer Set Programming for Robotic Task Planning". In: arXiv preprint arXiv:2406.0333 03367 (2024).
[38] Alessio Capitanelli and Fulvio Mastrogiovanni. "A framework for neurosymbolic robot action
planning using large language models". In: Frontiers in Neurorobotics 18 (2024), p. 1342786.
[39] Vinh Luong et al. "DANA: domain- neurosymbolic agents for consistency and accuracy".
In: arXiv preprint arXiv:2410.02823 (2024).
[40] Kaizhi Zheng et al. "JARVIS: neuro-symbolic commonsense reasoning framework for conversational embodied agents". In: arXiv preprint arXiv:2208. 13266 (2022).
[41] Yujie Lu et al. "Neuro-symbolic procedural planning with commonsense prompting". In: Proceedings of the 1Ith International Conference on Learning Representations (ICLR). 2023.
[42] Richard S. Sutton and Andrew G. Barto. Reinforcement learning: an introduction. MIT Press, 2018.
[43] Lingfeng Sun et al. "Interactive planning using large language models for partially observ- able robotic tasks". In: Proceedings of the 41st International Conference on Robotics and Automation (ICRA). IEEE, 2024, pp. 14054-14061.
[44] Jason Wei et al. "Chain-of-thought prompting elicits reasoning in large language models". In: Advances in neural information processing systems 35 (2022), pp. 24824-24837.
[45] Wonje Choi et al. "NeSyC: A Neuro-symbolic Continual Learner For Complex Embodied Tasks in Open Domains". In: Proceedings of the 13th International Conference on Learning
Representations (ICLR). 2025.
[46] Mohit Shridhar al. "ALFRED: A Benchmark for Interpreting Grounded Instructions for Everyday Tasks". In: The IEEE Conference on Computer Vision and Pattern Recognition
(CVPR). 2020.
[47] So Yeon Min al. "FILM: Following Instructions in Language with Modular Methods". In: Proceedings of the 10th International Conference on Learning Representations (ICLR). 2022.
[48] Aishwarya Padmakumar et al. "TEACh: Task- Driven Embodied Agents That Chat". In: Pro- ceedings the 36th AAAI Conference on Artificial Intelligence. Vol. 36. 2022, pp. 2017- 2025.
[49] Haoze Wu, Clark Barrett, and Nina Narodytska. "LEMUR: Integrating Large Language Models in Automated Program Verification". In: Proceedings of the 12th International Conference on Learning Representations (ICLR). 2024.
[50] Qingyun Wu et al. "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conver- sation". In: arXiv preprint arXiv:2308.088 033550015555.. (2023).
[51]
OpenAI. "GPT-40 system card". In: arXiv preprint arXiv:2410.21270 (2024).
[52]
AetMeta Llama Team. "The Llama 3 Herd of Models", In: arXiv preprint arXiv:2407.21783
(2024).
[53] Malte Helmert. "The Fast Downward Planning System". In: Journal of Artificial Intelligence Research 26 (2006), pp. 191-246.
[54] Håkan LS Younes and Michael L Littman. "PPDDLI. O: An extension to PDDL for expressing planning domains with probabilistic effects". In: Techn. Rep. CMU-CS-04-162 2 (2004), p. 99.
[55] David Coleman et al. "Reducing the barrier to entry of complex robotic software: a moveit! case study". In: arXiv preprint arXiv: 1404.3788 (2014).
[56] Lirui Wang et al. "GenSim: Generating Robotic Simulation Tasks via Large Language Models". In: Proceedings of the 12th International Conference on Learning Representations (ICLR).
2024.
13

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
The main claims in the "Abstract" and "Introduction" clearly describe the proposed neuro-symbolic framework for generating grounded policy code and improving reliability in partially observable environments. These claims are supported by the results presented in the "Main Result" section.
Justification:
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made the paper.
The abstract and/or introduction should clearly state the claims made, including contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results be expected to generalize other settings.
It is fine include aspirational goals as motivation long is clear that these goals are not attained by the paper.
2. Limitations
Question:
Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
This paper discusses a key limitation of the framework in the "Conclusion", noting that the logic-based confidence score is binary and does not capture nuanced feasibility in real-world environments
Justification:
Guidelines:
The answer NA means that the paper has limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low or images are taken low lighting. Or speech-to-tex system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed not penalize honesty concerning limitations.
3. Theory assumptions and proofs
14

---

Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but they appear in the supplemental material, the authors are encouraged to provide short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
Justification: This paper provides implementation details in the "Appendix", and the source code is included in the supplementary material.
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, a No answer to this question will not perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is novel architecture, describing the architecture fully might suffice, or if the contribution be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
specific model and empirical evaluation, may
While NeurIPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make it clear how reproduce that algorithm. (b) If the contribution is primarily
model architecture, the paper should describe the architecture clearly and fully.
(c) the contribution is a new model (c.g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should possible for other researchers to have some path to reproducing verifying the results.
15

---

5. Open access to data and code
Does the paper provide open access the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
Question:
Answer: [Yes]
Justification:
We plan to release our project open-source.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (https://nips. ec/
sublic/guidess httaa//ggiides/ooeeuumiiieeee
for more details.
While we encourage the release of code and data, we understand that this might be possible, so "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https gwt.g//idisseeeeee http:///dddeeeuaassooooooooeeee
//nips ccpps.cc/ppp
for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible supplemental material (appended the paper) is recommended, but including URLs to data and code is permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: The experimental setup is described in "Experiment", with additional details provided the "Appendix".
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, as supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [Yes]
Justification: All reported results include standard deviation error bars across trials, as shown in tables in "Main Result" and "Ablation".
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by emor bars, confi- dence intervals, or statistical significance tests, least for the experiments that support the main claims of the paper.
16

---

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g., Normally distributed errors).
It should be clear whether the error bar is the standard deviation the standard error of the mean.
is OK to report 1-sigma emror bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).
If error bars reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.
8. Experiments compute resources
Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Answer: [Yes]
Justification:
We specify the compute resources used for experiments in the "Appendix".
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs as well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurlPS Code of Ethics httpp:///perrppsscc///////hhhaap
Answer: [Yes]
Justification: We have reviewed the NeurIPS Code Ethics and confirm that our research complies with its guidelines.
Guidelines:
The answer NA means that the authors have not reviewed the NeurlPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g.. there a special consid- eration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
This paper discusses potential risks associated with LLM-based robot control, such as unsafe behavior with hazardous tools, and mentions safeguards like safety checks and transparent execution control in the "Conclusion".
Guidelines:
17

---

The answer NA means that there is no societal impact of the work performed.
If the authors answer NA or No. they should explain why their work has societal impact or why the paper does not address societal impact.
Examples of negatíve societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), faireess considerations (c.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional unintentional) misuse of the technology.
there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of MI.).
11. Safeguards
Question: Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper poses such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification: All third-party assets used in the paper, including RLBench, LLMs, and planners, are properly cited with references to their original papers. We ensure that their usage complies with publicly available licenses and terms of use.
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, possible, include URL.
The name of the license (c.g., CC-BY 4.0) should be included for each asset.
18

---

For scraped data from a particular source (e.g., website). the copyright and terms of service of that souree should be provided.
assets are released, the license, copyright information, and terms use in the package should be provided. For popular datasets, patasets.ppaerssiii paperswi thcode. com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
If this information is not available online, the authors are encouraged to reach out to the asset's s creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/mmodl as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given participants and screenshots, if applicable, as well as details about compensation (if any)?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then much detail as possible should be included in the main paper.
According to the NeurlPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does not involve crowdsoureing nor research with human subjects.
19

---

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if' applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMSs if is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, originality of the research, declaration is not required.
Answer: [Yes]
Justification: LMs are used as core components of the proposed method, with detailed usage described in the "NeSyRo Framework".
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non-standard components.
Please refer to our LLM policy (https://neuri)) (btr:p///eerrrp.ccc///fffeeeeeee /c/////oreeeeeeee/222////.. for what should or should not be described.
20

---

A Details of the NESYRO Framework
NESYRO enables exploration through a recursive composition of Neuro-symbollc Code Verification and Neuro-symbolic Code Validation. A policy code produced by the LLM is first subjected to explicit symbolic verification, which statically checks logical consistency against the task specification. The verified policy code then enters interactive validation, where each skill is evaluated in neuro-symbolic manner; if an unmet precondition is detected, the system synthesizes exploratory safe probe policy code to gather the missing observations. Every probe is fed back through the same verification and validation (V&V) cycle, producing a policy tree whose nodes are recursively grounded until all skills achieve satisfactory Neuro-symbolic Confidence Score. This recursive V&V framework guarantees that the policy code is both executable and environmentally grounded, even under dynamic, partially observable conditions.
A.1 NESyRO Algorithm
We provide the full pseudocode for our neuro-symbolic task execution pipeline in Algorithm | and Algorithm 2
Below, briefly describe the functional roles of each procedure and its interaction within the recursive planning framework.
Algorithm Task Execution Pipeline
Agent:
env environment interface
D domain knowledge
Eemoo demonstration set
confidence threshold
primitive action
oct observation history up t
A action set
Returns:
executed trajectory
Tmain policy code
procedure RUNTASK(env, D, Edemo: e)
(0go,g) 9) +- env.reset () ()
Initialize empty trajectory
(Taan Ogt, env, r) +- NESYRO Ogo: D, Edemo: e, O, env, (Texe: 0gt+1, env) +- EXE(T mmiin: Ogt, env)
+- T U Texe
return (T, ogt+1; Tmain)
end procedure
procedure EXB(T,, Ogt,, env)
Texe +-1 []
for each in do
A + EXPANDSKILL (5
for each a in A do
Onex + cnv.step(a)
Texe + Tex U (a, Opex)
Oct + Oci U Onext
end for end for return (Texe: Oct; env) end procedure
RunTask and execution loop. The RUNTASK procedure (Algorithm initializes the environment and launches the neuro-symbolic reasoning process. It first resets the environment to obtain the initial observation Ocu and instruction g. and initializes an empty trajectory т. The main grounding routine NESYRO is then called to synthesize a grounded policy code mmain based on the instruction and current context. Once obtained, the policy is executed via EXE, which expands symbolic skills into primitive actions and steps through the environment. The complete trajectory and updated observation history oct returned. The EXE procedure handles the execution of symbolic skills. For
21

---

each skill in т,, it calls EXPANDSKILL to retrieve the sequence of corresponding low-level actions.
These are executed sequentially the environment, and the resulting observations are appended to both the trajectory and the observation history.
Algorithm 2 Recursive Neuro-symbole Verification & Validation
procedure NESYRO(g, oge, D, Edemo, e, k, cnv, 7) Tsppes Tmuin) <- NEURO_ SIORRO_SYMBOICC VERIHICATION oge, D, I Taains Oct, env, 7) +-
VAL.DAATNN, ogt, D, Edemo; Mmain, ft k; env, grounding policy code Tmain
return Tmain; Ogt, e) end procedure
procedure NEURO_SYMBORT SYMBOLIC VERIFICATION(G, Ogt, k)
(Tspec: Tmmin) &- & Pven 9, loot: D,
while V Vveni (TepoeT Tmain) = fail do
Fveri <- Vveril "veri(TTppe (Tseec Tmain)
(Tspec, Tmain) ) +- Qveri (0ce, lea; D, Tmain: Fveri k)
end while
return (Tspce, Taain) end procedure
procedure NEURO NEURO_SYMBOR SYMBOLIC VALIDATION(C, Ogt,, D, Edemos Taain C, kr env, T)
+- k while n < |mainn| do
Jn +- Tmain [n]
CSC + &vali (D, Edemo, Oct, fn)
LC + V V (D, Ogt, 9: fm)
NeSyConf + CSC x LC
if NeSyConf
then
Sprobe f MAKEPROBEGOALL fn. Focc,Fii
Tppobe. Oge, env, T) & NESYRO( (grobee Oct, D, Edemor c, O, env,
D recursive
(Texey Ogt-1. env) f ExE( ( probe Ogg, env)
T T Texe
(T Sspec: Tmain) <- NEURO_SYMBOLAN WER.OI/EEERRICATTTNO......o
else
12 12
end if end while
return (Tmain: Octta: cnv, T) end procedure
b a: number recursive Tprobe executed during validation.
Recursive neuro-symbolic reasoning. Algorithm 2 outlines the recursive grounding logic of NESYRo. The NESYRO procedure first invokes NEURO SYMBOLIC VERIFICATION obtain symbolic task specification Tepe and initial policy code Wmmin- Logical correctness is ensured through iterative verification using &veri and V Veris which checks whether Wmain satisfies Tapec After verification, the policy is passed to NEURO RRROO_SSMBOOR SYMBOLIC VALIDATION for skill-wise confidence assessment. For each skill fo. the framework computes neuro-symbolic confidence score (NeSyConf), If NeSyConf falls below threshold probing goal Gprobe is generated and recursively passed into NESYRO.
To construct this probing goal Sprobe. the MAKEPROBEGOAL function synthesizes a new instruction that addresses the failure feedback. Specifically, it leverages NeSyConf feedback (F Fic) to identify missing observations. This recursive routine allows skill that fails exceed the confidence threshold to be refined and validated using updated observations gathered from safe probe exccutions. Once all skills pass validation, the final grounded policy and accumulated trajectory are returned.
22

---

B Environment Settings
B.1 RLBench
We use RLBench [8] as the simulation environment for our experiments. RLBench offers a wide range of tabletop manipulation tasks and provides realistic simulations of both robot control and visual observations. All experiments are performed using a 7-DoF Franka Emika Panda robotic arm, which is supported natively by RIBennh.. The environment is particularly suitable for evaluating planning and interaction under partial observability, as it supports randomized object configurations and sensor data, including RGB, depth, and segmentation masks. Its compatibility with Python also allows straightforward integration with our code generation and execution framework.
O
Figure Example scenes illustrating the "open drawer" task in the RL.Bench. The top row shows the overhead view, and the bottom row shows the front view.
Object configuration. Each episode initializes a workspace containing seven unique objects placed on table. The objects include two tomatoes, piece of trash, bin, three-level drawer, desk lamp, and a switch for the desk lamp. The position of each object is randomized in every episode, introducing perceptual variability and scene diversity across tasks. Figure 6 shows example scene from the RLBench environment used in our experiments.
Task composition. We categorize the tasks into four types to enable structured evaluation, as summarized in Table Each task type contains multiple language instructions, with associated probe targets indicating the source of uncertainty that must be resolved during execution.
Table 7: Task types, example of instructions, and associated probe targets in RLBench.
Task Type
Example Instructions
Probe Target
two onto plate
Tomato identity
Object Relocation
Put the trash into bin
Trash identity
Open drawer
Drawer locked/unlocked state
Object Interaction
Open two drawers
Drawer locked/unlocked state
Move tomatoes onto plate in dark room
Missing visual ohservation (requires light activation)
Auxiliary Manipulation
Open drawer in dark room
Missing visual observation (requires light activation)
Move die into the drawer
Die identity, Drawer locked/unlocked state
Long-Horizon Tasks
Move dice into the drawer
Dice identity, Drawer locked/unlocked state
B.2 Real-world
Environment setup. We conducted our real-world experiments using 7-DoF Franka Emika Research robotic arm mounted on tabletop workspace. An Intel RealSense D435 RGB-D camera was positioned above the table to provide top-down RGB and depth information. This input was processed by an object detection module to identify the categories and bounding boxes of relevatl objects. Depth measurements were used to compute 3D coordinates, which were then transformed into the robot's coordinate frame. This setup enabled accurate object localization and real-time observation grounding, providing the necessary perception for reliable execution.
23

---

Figure Example scenes from the real-world environment used in our experiments.
Object configuration. The real-world environment contains ten unique objects arranged on tabletop workspace. These include two dice, two pieces of trash, a bin, a three-level drawer, a small cardboard box, paper cup filled with liquid, roll of tape, and light switch. The initial positions of all objects are randomized for each trial, introducing diverse spatial configurations and observation conditions across task instances. This variability supports evaluation under partial observability and enables direct comparison with the RL RLBench-basee simulation setup. Figure 7 shows a representative setup of the real-world environment used in our experiments.
Task composition. We maintain the RLBench task categorization in the real-world setup to ensure consistency and enable direct comparison. Each of the four task types corresponds to distinct source of uncertainty and is associated with multiple language instructions and probe targets, as summarized in Table g
Table 8: Task types, example instructions, and associated probe targets in real-world.
Task Type
Example Instructions
Probe Target
Place a die into drawer
Die identity
Object Relocation
Move dice into dnawer
Dice identity
Open a drawer
Drawer lacked/unlocked state
Object Interaction
Open two drawers
Drawer locked/unlocked state
Place a die into drawer in dark room
Missing visual observation (requires light activation)
Auxiliary Manipulation
Open drawer in dark room
Missing visual observation (requires light activation)
Place a die into drawer die into drawer
Die identity, Drawer locked/unlocked state identity, Drawer lncked/unlocked, empty/occupied
Long-Horizon Tasks
LoveLevel Control. For motion planning and control in the real-world environment, we employed Movelt [55). an open-source motion planning framework widely used for robotic manipulation. Once the target object positions were obtained from the perception pipeline, we invoked parameterized skill primitives such as pick, place, and open, which are designed to operate over arbitrary object poses. Each skill was instantiated using the transformed 3D coordinates of the corresponding object and passed to the planner as goal constraints. Trajectory optimization was handled by Movelt's built-in planners, which computed collision-free spint-space paths that respect the robot's kinematic limits and workspace constraints. The resulting trajectories were executed using the robot's s internal controller through ROS. Although continuous force control was not used for the gripper, we implemented discrete grasping strategies based on object geometry and semantic role (e.g., trash, dice). This ensured consistent and safe execution across a variety of physical configurations.
Unlike the RLBench setting, where code execution is simulated through parameterized low-level APIs, our real-world system closes the loop by grounding skill calls with real sensor observations and executing planned trajectories on physical hardware. This setup allows us to evaluate the reliability of the proposed planning framework under real-world uncertainties.
24

---

Experiment Details
C.1 Compute Resources
Most experiments were conducted on a local machine with an Intel(R) Core(TM) 17-9700KF CPU and NVIDIA GeForce RTX 4080 GPU (16GB VRAM). Each task instance used single GPU, and RLBench simulation was executed with up to 32GB of system memory. Symbolic verification and PDDL planning
the CPU. For experiments using the larger language models listed in we used cloud-based CUDA
Table 6 in main paper, such as Llama-3.1 1-B and Qwen3-30B-AR. cluster with GPUs equipped with approximately 82GB of VRAM. All OpenAl models, including GPT-4o and GPT-4.1, were accessed via the OpenAl API.
C.2 Ro Implementation
LLM usage overview. Our framework utilizes LLM as core reasoning engines in three tightly integrated components of the code generation and validation pipeline:
Code Generation (er))): Given the instruction g and the current observation history oge- the verification LLM Pveri performs chain-of-thought thought reasoning produce intermediate symbolic task specification Tspce and corresponding Python policy code mmain- the code fails symbolic verification via Veeri structured feedback Fveri is returned and used by the LLM to iteratively revise the code. Only the unvalidated portion of maain is regenerated at each step. preserving previously verified components.
CSC Computation vaaat)): For each skill fn in the primary policy Tmain- the validation LLM vall computes CSC,, that estimates the likelihood of successful execution under the current observation oge and instruction g. The LLM prompted with the code for fn- domain knowledge D, retrieved single-skill demonstrations &demo and task context. Token- level probabilities are aggregated and transformed into a negative log-likelihooe score. This value normalized to produce scalar confidence score CSCf, used for validation. Before normalization, CSCj, ranges over [0, oo); after normalization, it is scaled to the interval [0,
CSC Feedback Generation (Fas):: If NeSyConf, < the skill fn is considered to require safe probe. In such cases, CSC feedback Fese is constructed based on fn. the failure context, current observation dgt, instruction g. and single-skill demonstrations Edemo- This feedback is then used prompt the L.M to generate safe probe policy code probe- The resulting policy code is recursively verified and validated through the NESYRO pipeline before execution.
Example of prompt. Below are the representative prompts used in each stage of our framework: generating executable robot code, computing CSC for each skill, and generating feedback when the NeSyConf falls below a threshold.
Code Generator Prompt
Role: You Al assistant tasked with generating executable Python code that controls robot in a simulated environment.
Task: Complete the executable code using the provided inputs and by implementing any missing skills. The goal is to ensure the robot can achieve the specified objective by executing sequence of actions (plan).
Input Details:
Domain PDDL: Describes the available actions and predicates in the environment. It includes information about action parameters, preconditions, and effects. This provides the symbolic action space for the planner. Provided domain PDDL: [[domain_pddl]>
Observation (Initial State Description):
Represents the initial state of the envi- ronment in PDDL format, including locations objects, robot position, and other relevant state descriptions. Provided observation: {fobservation}}
25

---

Goal (Natural Language Description): The goal specifies what the robot must accomplish in plain language.
Provided goal: {[goal}}
Specification (Code Generation Guidelines): Provides strict rules and constraints that the generated code must follow.
Provided specification: {{spec}}
Skill Code (Python Implementations of Actions): A set of predefined Python functions that implement low-level skills (e.g., move, pick, place).
Provided skill code: {[skill_code}}
Executable Code Skeleton: A partially completed Python file containing environ- ment setup and control flow scaffolding.
Provided skeleton:
(ixeeletonccode))
Available Skill Names: list all valid skill function names that may be called in the generated code.
Provided skills: setrailablesskillsst
Object List: list of object names that exist in the environment. Provided object list:
Feedback: Corrections or issues identified from the previous code generation.
Feedback: {(feedback)}
Previous code: {(prev_cdee}>
Exploration Knowledge: Optional knowledge to infer or explore missing observa- tions.
Exploration knowledge:
Frozen Code: Code that must remain unchanged. New code must follow this segment.
[Frozen Code Start] (ffrozen_code, _o____pereed)_))____pp [Frozen Code End]
Implementation Requirements:
Use only the predefined skills (e.g., move, pick, place) from skill_codes do not define new functions.
Complete the provided skeleton by inserting plan logic that achieves the specified goal.
Preserve all existing imports and [Frozen Code] segments.
Output should be plain text only - do not use code blocks.
Handle errors gracefully during skill execution (e.g., invalid arguments or missing objects).
Use the following external modules as provided:
env: Environment setup and shutdown.
skill_ Contains all callable action implementations.
video: Tools for simulation recording.
For retrieving object location information.
26

---

CSC
Computation Prompt
You Al assistant responsible for estimating the likelihood that specific robotic skill will succeed in the current environment. Your evaluation will be used to compute token-level hog-probability-basee common sense confidence, rather than to generate output. Input Details:
Role:
Instruction:
(instruction}
Demonstrations:
Demo 1: {demo_1}
Demo 2: {demo_ 2}
Observation:
(observation)
Object List: (object_list}
Skill Code: {skill_code}
CSC Feedback Prompt
You an Al assistant responsible for analyzing why robotic skill code is likely to fail and for generating feedback to guide its refinement. Task:
Role:
Based the given context and the Neuro- Souro-Symbolic Confidence Score (NeSyConf) being below threshold, provide structured feedback to help revise or improve the given skill code.
Input Details:
Demonstrations:
Demo 1: {demo_1)
Demo 2: {demo_2}
Observation:
(observation}
Skill Code:
(skill_code}
Confidence Score
Current Confidence Score: (NeSyConf), Threshold: (threshold}
Instruction: (instruction)
Object List:
sbbject_iist)
Format:
Problem Identification
Justification (Why is it problem?)
. 3. Proposed Solutions (High-level ideas)
. 4. Additional Notes (0ptional)
Instruction to Model: Focus on issues such as force calibration, missing objects, logical flaws, unsafe execution. For example: "An object declared in the code is not in the actual object list." Your feedback will guide the regeneration of this skill step.
Hyperparameter setting. The only hyperparameter in our framework the confidence threshold used during neuro-symbolic validation. For each skill, perform five safe exploration probes
27

---

under varied initial conditions to estimate its execution confidence. To determine a suitable value of for given environment, we exclude outlier trials in which the probe failed due non-informative reasons, which could otherwise deflate confidence estimates. This ensures that reflects realistic and actionable lower bound of confidence for successfully grounded skills.
1.0
Confidence Score
0.8
0.6
0.4
0.2
0.0
Skill
Skill 2
Skill 3
Skill 4
Skill 5
Skill 6
Skill 7
Before Probe
After Probe
After Probe
After Probe
After Probe
After Probe
Figure 8: Confidence scores over five safe probes for each of 7 skills in long- long-horizon task.
Figure & illustrates this process using one of the monghoorzoon tasks in the RLBench environment. Each of the skills was probed five times, and confidence scores were recorded before and after each probe. The figure shows that while confidence increases with repeated probing, typically saturates after a few trials, indicating convergence, Based on this observation, we compute the final confidence distribution by averaging only those probe outcomes that resulted in successful skill grounding. We then set to the lower quartile this filtered distribution, ensuring conservative yet robust threshold that filters out unreliable executions while accepting skills with moderately confident grounding.
Single-skill demonstrations format. To support symbolic validation and LLM-based reasoning. we constructed a ceneral-purpose demonstration library consisting of synthetic examples. These demonstrations were generated entirely via a large language model (GPT-4o) (56), given domain-level PDDL definitions and representative symbolic contexts, without requiring environment-specife exe- cution human annotation. Each example encodes typical task-relevant transitions across common household activities (e.g., opening drawer, placing object, turning light), and captures both successful failure cases under varied symbolic states. In total, we synthesized approximately 500 such demonstrations spanning over 15 diverse skill types. These examples are reused across all tasks to provide reusable prior knowledge for CSC computation and to guide safe probing decisions when symbolic grounding confidence is low.
Demonstration Structure
Each demonstration consists of a sequence of transitions. Each transition is represented as dictionary with the following fields:
initial_ ciciiial_oservvttoon symbolic or structured observation before executing the action.
action: the skill function executed, such as call to (object)) or open (drawer).
post_observation symbolic structured observation after executing the action.
success: boolean value indicating whether the action was successful.
C.3 Baselines Implementation
Code Policies (CaP) serves as the foundation of our framework and is implemented by invoking the Code Generator Prompt with the frozen code length set to zero. Although symbolic specification also produced, this baseline does not include any verification process.
28

---

CaP w/ Lemur [49] extends CaP by performing verification over the generated specification. This process is conducted in the exact same manner as the Neuro-symbolic verification phase.
CaP w/ CodeSift [5] extends CaP by incorporating LLM--bsse verification and validation, In the verification stage, CodeSift performs static syntax checks using language-specific tools (pylint for Python, shellcheck for Bash) and prompts the LLM to summarize the code's s functionality. This summary then used in the validation stage assess semantic alignment with the original task instruction. The validation consists of multiple sub-steps: semantic similarity scoring, listing all functional mismatches, and determining whether the implementation is exact. If the code fails validation, the framework automatically generates refinement feedback and prompts the LLM to revise the code accordingly. The entire process is orchestrated via modular pipeline that yields detailed diagnostic outputs and a refined version of the code when necessary.
LLM-Planner [11] follows the same initial procedure CaP by generating code from the instruction using a Code Generator Prompt. During execution in the environment, if an action fails, the planner captures the current observation and provides it as additional context to the LLM. The previously executed portion of the code is marked as frozen, and a new code segment is generated to continue the task from the failure point. As CaP, symbolic specification produced, but no verification or validation is performed throughout the process.
AutoGen 50) adopts the same iterative replamning strategy LLM-Planner where code is regen- erated during execution upon failure by freezing the executed portion and providing the current observation context. The key difference is that it uses dedicated reasoning model, specifically 04-mini, to enhance task understanding and decision making. This improved reasoning enables more accurate replanning. As with L.MM-Planne explicit verification or validation is performed.
29

---

D Real-world Experiment Details
D.1 Figure I in Main Paper Details
In this section, we provide a detailed explanation of Figure [ in main paper. The complete execution sequence depicted in Figure iincluding all safe probes is illustrated in Figure To demonstrate the reliability of NESYRO in a real-world setting, we tasked an embodied agent with the instruction "Clean up the desk" and compared NESyRO against naive code generation approach. As depicted in Figure [T the naive approach failed in partially observable environments, leading it to execute an irreversible action by not recognizing that the middle drawer might be locked. In contrast, NESYRO addresses this uncertainty using a safe probe pipeline to acquire the missing observations. It initially plans safe probe determine whether the drawers validation phase. it subsequently identifies the need to observe the locked status of the drawers. Consequently, Safe Probe I, which checks the locked status of the drawers, executed first, as shown in Figure 9 Upon its completion, the agent adds observations confirming that the middle drawer locked and that the top and bottom drawers are unlocked. Subsequently, Safe Probe 2, which checks whether the drawers are empty, is executed and adds observations confirming that both the top and bottom drawers are empty. With these observations acquired, the policy code now grounded. NESY proceeds to successfully execute the "Clean up the desk" instruction.
empty. However, through its recursive
D.2 Figure 5 in Main Paper Details
This section provides detailed explanation of Figure main paper. The complete execution sequence depicted in Figure 5 of main paper including all safe probes is illustrated in Figure I0 To further evaluate the robustness of NES in real-world setting, implemented the instruction "Place one dice into drawer in dark room" which represents partially observable environments. This requires auxiliary manipulation such as turning on the light to restore visibility before executing the main task. The initial policy code Maain was ungrounded. missing observations regarding drawer visibility and lock status. To resolve this, NESYRO activates its safe probe pipeline and first generates Safe Probe 1 to turn on the light, enabling the agent to perceive object locations. However, even after Safe Probe the NeSyConf for the skill pick (middle_H) In response, NESYRO generates Safe Probe 2 to check the lock status of the drawers. This probe confirms that the top and bottom drawers are unlocked, while the middle drawer is locked. Based on these observations, the code is refined by replacing the initial skills that placed one dice into the middle drawer with new skills that place into the top drawer. As a result, the skill pick (top_H, becomes ready to execute. Subsequently, during the validation of pi (dice, ..... the agent identifies the need to check whether the drawers are empty. Consequently, NESyRo generates Safe Probe 3 to check whether the drawers are empty. This probe detects trash inside the top drawer, leading to the insertion of additional code that removes it. These added skills also undergo the same validation phase in sequence. Once all skills are marked ready execute, the policy code is considered grounded. NESYRO proceeds to successfully execute the given instruction.
...) remains below threshold.
30

---

Instruction: Clean up the desk
Safe Probe 1: Are the drawers locked?
Safe Probe 2: Are the drawers empty?
Main code
Figure 9: world execution sequence of the instruction "Clean up the desk"
31

---

Instruction:
Place one dice into a drawer in dark room
Safe Probe 1: Turn on light
Safe Probe 2: Are the drawers locked?
Safe Probe 3: Are the drawers empty?
Main code
Figure 10: Real-world exccution sequence of the instruction "Place one dice into drawer in dark room"
32


Reviews:
[{"review_id": "L81kMB5VGW", "reviewer": "Reviewer_rKZ1", "summary": "The authors propose an LLM code planner for robotic tasks that utilizes recursive functions and symbolic code verification. After verification the method uses a validation step to predict task success using common sense and confidence metrics. Lower confidence code triggers a probing phase to gather more observations prior to adjusting the policy. This continues recursively.", "questions": "Are there results for ablating the recursive element of the method?\n\nWhat are the failure modes of your method on these tasks?", "limitations": "yes", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 3, "originality": 2, "strengths_and_weaknesses": "Strengths:\n- Clearly communicated contribution, method, and results\n- Thorough experimental results on multiple tasks and against multiple baselines and with multiple ablation studies\n- Precise and high quality figures\n\nWeaknesses:\n- Limited to binary confidence\n- Domain specific aspects of method limit generalizability\n- Leans heavily on empirical results without theoretical justification for method\n- I'm unsure whether the baselines the authors choose are comprehensive", "was_revised": false, "final_justification": "", "rebuttal": "Dear Reviewer rKZ1,\n\nWe thank the reviewer for their detailed feedback and for recognizing the strengths of our work. Below, we provide point-by-point responses to the raised weaknesses and questions.\n\n---\n### W1: Limited to binary confidence\nAs discussed in the Conclusion as a limitation, the current version of NeSyRo uses a binary Logic Confidence (LC), which indicates whether a symbolic planner (e.g., a PDDL planner) confirms the feasibility of a skill under the current observation. While this binary LC is sufficient for triggering safe probes in our neuro-symbolic validation pipeline, we leave the exploration of continuous formulations of LC as future work.\n\nBy incorporating probabilistic reasoning, such as Probabilistic PDDL [1], NeSyRo could represent graded estimates of symbolic feasibility, rather than a hard 0/1 outcome. This would enable more adaptive behavior in probe scheduling and policy refinement.\n\nFor example, in open-ended long-horizon tasks involving multiple sequential or compositional subgoals, a continuous LC could help prioritize which skill to validate first based on confidence levels, such as probing a low-confidence skill before executing one with moderate confidence. This allows the agent to recover critical preconditions earlier, reducing redundant probes and improving overall efficiency.\n\nWe would like to clarify that the current use of binary LC in NeSyRo does not compromise the framework's effectiveness. Since the symbolic validation module relies on a PDDL planner that yields discrete feasibility outcomes, binary LC is sufficient to determine whether a skill $f_n$ requires further observation and reliably triggers safe probe generation during the Neuro-Symbolic Code Validation phase.\n\n---\n### W2: Domain specific design limits generalizability\nWhile our framework is primarily evaluated in the context of robotic task planning, its architecture is not domain-specific. NeSyRo can generalize to a broad range of planning problems, including non-robotic tasks such as logical puzzle solving or workflow synthesis. Adapting to these domains may require changes to the symbolic interface, but the core verification and validation paradigm remains applicable.\n\nAlthough we use a PDDL-based planner in our current implementation, the symbolic verification module is modular and can support alternative tools such as ASP-based planners. This flexibility allows our framework to interface with symbolic formalisms appropriate for different environments and planning abstractions.\n\nOur method requires domain knowledge $\\mathcal{D}$ describing available skills, object types, and symbolic predicates. However, this is a general requirement in symbolic reasoning systems, not a limitation specific to our approach. NeSyRo mitigates this dependency by incorporating commonsense reasoning through LLMs. The Common Sense Confidence (CSC) component complements symbolic logic with contextual priors and helps infer or refine $\\mathcal{D}$, reducing the need for fully specified domain definitions.\n\nOur experiments cover both RLBench and real-world scenarios across diverse task types and configurations, as shown in Tables 2 and 3, demonstrating that the same architecture performs robustly without any domain-specific tuning.\n\n---\n### W3: Heavily empirical with limited theoretical justification\nWe emphasize that while NeSyRo is supported by extensive experiments demonstrating its effectiveness, it is not purely empirical. Its core mechanisms are grounded in formal symbolic reasoning and verification principles. Specifically, the two central components of NeSyRo, Neuro-Symbolic Code Verification and Neuro-Symbolic Code Validation, are implemented using rule-based symbolic tools and offer the following theoretical justifications:\n\n- **(1) In the code verification phase,** we use an SMT solver [2] to formally check whether the generated policy code satisfies the high-level task specification. This process is deterministic and grounded in formal logic, providing a theoretically consistent guarantee of code correctness.\n\n- **(2) In the code validation phase,** we use a PDDL-based symbolic planner to assess whether a given skill is symbolically feasible under the current observation. This module is based on classic planning theory and provides a formal mechanism to validate the feasibility of executing skills.\n\nRather than executing LLM-generated code directly, NeSyRo integrates symbolic tools to ensure both logical and environmental consistency, forming a hybrid structure with theoretical grounding. Empirical evaluation remains the standard in LLM-based embodied planning, as seen in works like ZSP [3], SayPlan [4], RT-2 [5], and OpenVLA [6], which validate effectiveness primarily through experiments. In this context, NeSyRo goes further by combining symbolic reasoning with formal verification, providing both theoretical rigor and empirical strength.\n\n---\n### W4: Unclear whether baseline selection is comprehensive\nTo comprehensively evaluate NeSyRo, we selected baselines that support comparison along three axes central to our framework.\n\n- First, by comparing against CaP, we assess whether NeSyRo improves reliability under partial observability, where LLM-generated policy code lacks full environmental grounding.\n\n- Second, by including CaP w/ Lemur and CodeSift, we test whether existing symbolic Verification & Validation methods, designed for static code analysis, can be directly applied to robot control code. This reveals their limitations in dynamic environments where grounding and safe exploration are essential.\n\n- Third, by comparing against replanning-based methods such as LLM-Planner and AutoGen, which revise the policy only after failure, we examine whether NeSyRo's pre-execution validation leads to safer and more efficient task completion.\n\nThis selection ensures that NeSyRo is evaluated against both CaP methods and approaches that incorporate symbolic correctness checks. Similar baselines have been adopted in recent work. For example, planning frameworks [7, 8] have compared against CaP, LLM-Planner, and AutoGen, while neuro-symbolic verification systems [9, 10] have employed Lemur and other formal toolchains to assess the correctness of LLM-generated code. These precedents help situate our choices within the broader research landscape.\n\n---\n### Q1: Ablating the recursive element\nTo evaluate the impact of the recursive structure in NeSyRo, we conducted an ablation study on long-horizon tasks in the RLBench environment by varying the maximum recursion depth allowed during validation.\n\n|Recursion Depth|0|1|2|3|4|\n|-|-|-|-|-|-|\n|SR|20.0%|30.0%|45.0%|45.0%|45.0%|\n|GC|25.0%|48.2%|52.8%|54.3%|54.0%|\n\nSetting recursion depth to 0 disables interactive validation entirely, equivalent to CaP w/ Lemur, preventing the agent from acquiring missing observations. Depth 1 provides limited probing but cannot resolve multi-step dependencies, resulting in low success rates. With depths of 2 or more, the agent can recursively refine code and acquire missing observations through safe probes, significantly improving performance. Performance improves up to depth 3, then saturates as all missing observations can be recovered within depth 2. These results highlight the importance of recursive verification and validation in NeSyRo.\n\n---\n### Q2: Failure modes of the method\nWe discussed both quantitative and qualitative failure cases of NeSyRo in Table 3 and Section 4.2 of our paper. Understanding these limitations is critical for guiding future improvements. Beyond the main paper, we summarize some failure cases of NeSyRo as follows:\n\n- **(1) Execution failures due to hardware limitations:**\nIn real-world Auxiliary Manipulation tasks (e.g., \"place a die into a drawer in a dark room\"), NeSyRo sometimes fails to complete the task even when the policy code is correctly generated and symbolically validated. These failures are not caused by errors in perception or planning. Instead, they result from physical limitations, such as the robot's inability to press a light switch accurately. This reflects challenges that originate from hardware rather than the reasoning process.\n\n- **(2) Failures due to limited probe budget:**\nNeSyRo can complete a task by recursively generating safe probe policies until all missing observations are recovered. In principle, unbounded probing would eventually validate all skills and produce a fully grounded policy. However, in real-world deployments, we impose a maximum number of probes to account for time and resource constraints. If this limit is reached before critical observations are obtained, some skills may remain unvalidated, resulting in execution failures. These cases arise from practical constraints rather than limitations of the framework itself.\n\n---\nWe again thank the reviewer. We will incorporate these improvements in the final version.\n\n[1] Younes et al. PPDDL 1.0: An extension to PDDL for expressing planning domains with probabilistic effects. 2004.\n\n[2] De Moura et al. Z3: An Efficient SMT Solver. TACAS 2008.\n\n[3] Huang et al. Language Models as Zero-Shot Planners: Extracting Actionable Knowledge for Embodied Agents. ICML 2022.\n\n[4] Rana et al. SayPlan: Grounding Large Language Models using 3D Scene Graphs for Scalable Robot Task Planning. CoRL 2023.\n\n[5] Zitkovich et al. RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control. CoRL 2023.\n\n[6] Kim et al. OpenVLA: An Open-Source Vision-Language-Action Model. CoRL 2024.\n\n[7] Yu et al. Language to Rewards for Robotic Skill Synthesis. CoRL 2023.\n\n[8] Choi et al. NeSyC: A Neuro-symbolic Continual Learner For Complex Embodied Tasks In Open Domains. ICLR 2025.\n\n[9] Wu et al. LLM Meets Bounded Model Checking: Neuro-symbolic Loop Invariant Inference. ASE 2024.\n\n[10] Lin et al. VEL: Interactive Formal Verification Environment with Large Language Models via Theorem Proving. NeurIPS 2024."}, {"review_id": "ArvJw1bm3S", "reviewer": "Reviewer_nsGi", "summary": "This paper explores the use of LLMs to generate directly executable code for task planning and control in embodied agents. In the proposed framework, the generated code undergoes holistic verification through symbolic verification, followed by sequential validation of individual functions via interactive validation. The method is empirically shown to be effective in dynamic and partially observable environments.", "questions": "1. In section 3.3, is it possible that the task specification is unclear or incorrect for the code generation?\n\n2. In section 3.3, how should we interpret \"a sequence of skills with their parameters and required library\"?\n\n3. In section 3.3, how should we understand \"domain knowledge $D$\" consisting of available skills, object types, and environment-specific constraints?\n\n\n4. In symbolic-based code verification, how should we interpret the feedback $\\mathcal{F}\\_{\\mathrm{veri}}$ from the verification tool, and what does it look like?\n\n\n5. In the neuro-symbolic confidence score, how should we understand \"past demonstration,\" and why is it important?\n\n\n6. How should we interpret $\\mathcal{F}\\_{\\mathrm{csc}}$ and $\\mathcal{F}\\_{\\mathrm{ls}}$  in Equation 6?", "limitations": "This method may excessively rely on external tools and explorations in the environment, which could raise concerns about efficiency.", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 2, "originality": 2, "strengths_and_weaknesses": "## strengths\n\n\n1. Unlike prior works that directly generate executable code without rigorous verification, this method introduces a two-stage verification process: holistic symbolic verification and component-wise interactive validation. This decomposition is designed to address the challenges posed by dynamic and partially observable environments.\n\n2. During interactive validation, each component function is first assessed using a newly defined neuro-symbolic confidence score, which determines whether refinement through direct interaction with the environment is necessary. This interaction enables exploration and adaptation, enhancing the quality of the resulting executable code used as policy. This mechanism marks a key distinction from previous approaches.\n\n\n\n## weaknesses\n\n\n1. At each step, the symbolic verification tool is invoked to identify potential violations in the generated code. However, it is unclear whether the use of such external tools incurs significant computational cost. In the context of using LLMs for task planning, it is generally preferable to rely on the model itself for error correction, rather than heavily depending on external verification tools. I strongly recommend that the authors introduce a metric to quantify the cost associated with invoking these tools during the verification process.\n\n2. The neuro-symbolic confidence score comprises two components: common sense confidence and logic confidence. The input to the common sense confidence includes past demonstrations, but the importance of this design choice is not clearly justified. I suggest that the authors provide empirical evidence supporting the contribution of this component and offer an intuitive explanation for its inclusion.\n\n3. To enhance performance in dynamic and partially observable environments, the framework introduces a probe policy that explores the environment based on the current policy. However, it is unclear whether generating this probe policy is computationally efficient and how its safety is ensured during interaction. Given that exploration via the probe policy plays a critical role in improving the final policy, I am concerned about the potential safety risks and recommend a more detailed discussion on how these are mitigated.\n\n4. During interactive validation, excessive interaction between the probe policy and the environment is undesirable. Therefore, it is important to define a metric that quantifies the cost of refining the policy through such interactions.\n\n5. A minor issue is that some descriptions in the paper are overly abstract or ambiguous, particularly regarding certain notations. I recommend that the authors include concrete examples in the main text to clarify these concepts. Some of these ambiguities have been noted in the questions section.", "was_revised": true, "final_justification": "During the rebuttal period, the authors have addressed my concerns regarding computational cost and the importance of past demonstrations. They provided detailed explanations and responded thoroughly to my questions.", "rebuttal": "Dear Reviewer nsGi,\n\nWe are grateful for the reviewer's detailed assessment and for noting the strengths of our approach. Below, we address each of the specific concerns and questions in detail.\n\n---\n### W1, W4: Metric for external tool cost and probe cost, LLM-only correction\nIn response to the reviewer's suggestion, we provide an analysis of the computational cost associated with symbolic tool usage and probe execution during refinement. NeSyRo employs two symbolic tools:\n\n- (1) an SMT verifier that checks policy code compliance with the task specification.\n- (2) a PDDL planner that assesses skill feasibility during validation.\n\nThese tools are used for code verification and skill grounding. When the NeSyConf score for a skill falls below a threshold $\\epsilon$, NeSyRo triggers an additional safe probe refinement cycle involving further symbolic verification and validation. As a hyperparameter, $\\epsilon$ controls the frequency of symbolic tool usage, balancing computational cost and reliability. To quantify this trade-off, we varied $\\epsilon$ and measured the average number of SMT solver calls, PDDL planner calls, and safe probe executions per task.\n\n|$\\epsilon$|SMT Calls/Task|PDDL Calls/Task|Probe Exec./Task(max. 5)|SR|\n|-|-|-|-|-|\n|0.0|1.3|4.9|0.0|55.6%|\n|0.3|3.9|11.6|1.1|88.9%|\n|0.6|10.3|18.3|3.5|100.0%|\n|0.9|16.0|25.3|5.0|100.0%|\n\nAs $\\epsilon$ increases, symbolic tool usage rises, improving grounding and task success. Lower values reduce cost but may compromise performance. Thus, $\\epsilon$ serves as a tunable parameter that balances tool cost and policy reliability based on task requirements. Correspondingly, the number of probe executions also increases with $\\epsilon$, as more skills fall below the threshold and require refinement.\n\nPrior works [1, 2] show that LLMs often miss semantic errors due to hallucination. NeSyRo mitigates this through explicit symbolic reasoning, preventing irreversible actions and improving success rates, as shown in Table 3. While optimizing computational cost is an important direction for future work, this paper focuses on ensuring reliability and robustness during task execution. We hope this design choice and trade-off analysis address the reviewer's concerns, and we will include the analysis and tool usage details in the final version.\n\n---\n### W2, Q5: Role and impact of past demonstrations\nAs described in Section 3.4 (lines 173–175), past demonstrations are used in the CSC component to reduce hallucinations and ground the LLM's commonsense reasoning in the environment. While LLMs excel at general reasoning, their difficulty in producing grounded outputs under partial observability is a well-known limitation in LLM-based embodied control [3, 4].\n\nTo address this, NeSyRo retrieves demonstrations $\\mathcal{E}\\_{\\text{demo}}$ with similar context to skill $f_n$ and inputs them to the validation LLM $\\Phi\\_{\\text{vali}}$ for CSC computation (Eq. 4).\nThese demonstrations act as environment-specific priors to assess the plausibility of $f_n$ under $o_{\\leq t}$ and $g$, helping reduce hallucination and improve grounding. Recent LLM-based frameworks have similarly used retrieval to enhance contextual grounding in planning tasks [3, 4].\n\nThe table below presents an ablation of $\\mathcal{E}\\_{\\text{demo}}$ on long-horizon RLBench tasks under partial observability. We compare NeSyRo with a variant that disables demonstration retrieval in the CSC module. Removing $\\mathcal{E}\\_{\\text{demo}}$ results in notable drops in both SR and GC, highlighting the importance of contextual demonstrations in reliably estimating CSC.\n\n|Method|SR|GC|\n|-|-|-|\n|NeSyRo|45.0%|54.3%|\n|NeSyRo w/o $\\mathcal{E}\\_{\\text{demo}}$|40.0%|44.6%|\n\n---\n### W3: The efficiency and safety of probe policy\nWe address the reviewer's concerns in two parts: (1) the computational cost during probes, and (2) probe safety under partial observability.\n\n- **(1) Computational cost:**\nUnlike LLM-Planner, which regenerates full policies upon failure, NeSyRo refines only low-confidence skills through targeted safe probes. Symbolic tools are invoked selectively, only when NeSyConf falls below the threshold $\\epsilon$, with minimal overhead. This localized refinement leads to significantly fewer interactions with the environment. For example, in long-horizon tasks, NeSyRo completes execution in 18.2 steps on average, compared to 26.8 for LLM-Planner, confirming both computational and interaction efficiency.\n\n- **(2) Safety of probe execution:**\nEach probe policy $\\pi_{\\text{probe}}$ undergoes the same verification and validation process as the main policy $\\pi_{\\text{main}}$.\nIf a probe lacks sufficient grounding, NeSyRo recursively generates sub-probes, each of which is also verified and validated prior to execution. This recursive structure ensures that all code executed in the environment is symbolically consistent and grounded. As shown in Table 3, NeSyRo significantly reduces irreversible actions during execution, demonstrating its robustness under partial observability.\n\n---\n### W5, Q3, Q4, Q6: Clearer definitions and concrete examples\nTo address concerns about abstraction, we provide concrete explanations for three core components.\n\n1. **Domain knowledge $\\mathcal{D}$.** In our framework, $\\mathcal{D}$ denotes domain knowledge used for verification and validation. It consists of:\n\n- Available skills: Executable operations (e.g., pick, push, pull), which are implemented as parameterized function calls in the policy code.\n- Object types: Symbolic object classes (e.g., mug, drawer, handle).\n- Environment-specific constraints: Symbolic predicates (e.g., `is_open(drawer)`) representing action preconditions and effects.\nThese constraints are encoded in the PDDL domain file and used during symbolic verification and validation.\n\n2. **Verification feedback $\\mathcal{F}\\_{\\text{Veri}}$.** The symbolic verifier checks whether the generated policy code satisfies the task specification, which includes a high-level plan and partially instantiated parameters. If verification fails, the SMT solver returns constraint violations, which the LLM interprets into fine-grained feedback $\\mathcal{F}\\_{\\text{Veri}}$. This feedback, expressed in natural language (e.g., parameter mismatch: `drawer = \"middle_drawer\" is incorrect; expected: \"top_drawer\"`), enables the LLM to revise only the erroneous parts.\n\n3. **Validation feedbacks $\\mathcal{F}\\_{\\text{CSC}}$ and $\\mathcal{F}\\_{\\text{LC}}$.** During validation, if the NeSyConf score falls below a threshold $\\epsilon$, feedback from both components is used to generate a safe probe policy $\\pi_{\\text{probe}}$.\n\n- $\\mathcal{F}\\_{\\text{CSC}}$: Generated by prompting the LLM with the current observation and instruction, providing natural language explanations for implausible skills (e.g., `\"There is no need to open the drawer.\"`)\n\n- $\\mathcal{F}\\_{\\text{LC}}$: Produced by the symbolic planner when a skill's preconditions are not met (e.g., `\"(drawer1-open) not satisfied.\"`)\n\n  These feedbacks guide $\\pi_{\\text{probe}}$ to recover missing observations or satisfy unmet preconditions. \n  This process is repeated recursively until all skills are grounded and validated as described in Section 3.4 and Figure 2.\n\n---\n### Q1: Unclear or incorrect task specification for code generation\nUnder partial observability, task specification $\\mathcal{T}\\_\\text{spec}$ may be unclear or incorrect due to incomplete observations. NeSyRo is explicitly designed to handle such cases via recursive validation and refinement. Instead of assuming $\\mathcal{T}\\_\\text{spec}$ is complete, NeSyRo validates each skill in $\\pi\\_\\text{main}$ via Neuro-Symbolic Code Validation. If a skill’s NeSyConf < $\\epsilon$, NeSyRo invokes a safe probe, updates the observation buffer, and refines the policy and task specification.\n\nThis process is well illustrated in Figure 5 of our paper. Initially, $\\pi\\_\\text{main}$ contains an incorrect high-level plan due to missing observations (e.g., unknown drawer lock states). Through recursive validation, NeSyRo detects these issues and executes targeted safe probes (e.g., checking the lock state of each drawer). As new observations are collected, NeSyRo refines the parameters or structure of the plan, leading to a grounded and executable policy. This example shows how NeSyRo incrementally corrects $\\mathcal{T}_{\\text{spec}}$ via recursive refinement.\n\n---\n### Q2: Meaning of skill sequences, parameters, and required library\nThis phrase refers to the structure of the initial Python policy code $\\pi_{\\text{main}}$. The code consists of sequential calls to predefined skill functions (e.g., pick, place, pull), each parameterized with task-relevant arguments such as object identifiers, axes, or distances. These parameters are derived from $\\mathcal{T}_{\\text{spec}}$, which encodes subgoals and symbolic constraints.\n\nIn some cases, additional computation is needed to determine skill parameters. To support this, the LLM includes import statements for external Python libraries when necessary. For example, libraries such as numpy may be used for distance computation or coordinate transformation. This is one representative case, but the choice of library depends on the specific context and computation required for executing each skill. Thus, \"required library\" broadly refers to any module needed for correct code execution.\n\n---\nWe again thank the reviewer. We will incorporate these improvements in the final version.\n\n[1] Ji et al. Survey of Hallucination in Natural Language Generation. ACM Computing Surveys 2023.\n\n[2] Tyen et al. LLMs cannot find reasoning errors, but can correct them given the error location. ACL 2024.\n\n[3] Mon-Williams et al. Embodied large language models enable robots to complete complex tasks in unpredictable environments. Nature Machine Intelligence 2025.\n\n[4] Wang et al. Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv 2023."}, {"review_id": "bGbuz3wk5E", "reviewer": "Reviewer_xaVS", "summary": "This paper builds on the Code-as-Policies (CaP) paradigm, introducing a framework for neuro-symbolic robotic task planning (NeSyRo), for safer and more reliable plans. As in CaP, an LLM is given a task instruction, and needs to output a policy written in code, that expresses which actions to take in terms of a predefined set of control skills or primitives.\nThe main features of NeSyRo are the following: first, it introduces two processes to refine the generated code, verification and validation. The verification uses an SMT solver to check that the policy code satisfies some LLM-generated specifications and iteratively re-generates the policy taking into account feedback from the solver until this step is successful. The validation checks skill-by-skill if there exists a symbolic plan from the current state to the goal which contains that skill (Logic Confidence), and also if the LLM assigns a cumulative log probability (normalised somehow) over the code for the skill higher than a certain threshold (given some proper context). Second, in case of failed validation, it uses a safe probe code policy to gather information that might help resolving the validation step, which can fail due to insufficient contextual information. Finally, the framework uses a recursive resolution strategy, where the main pipeline to generate the code policy undergoes verification and validation, and triggers the generation of a safe probe in case of failed validation; the probe undergoes a similar verification and validation and can recursively trigger other safe probes, forming a policy tree. Experiments on simulated RLBench and real-world settings convincingly prove the strength of the method when compared to a range of strong CaP-like baselines.", "questions": "1. Can you provide a formal definition of what you intend with “dynamic environment”?\n2. Is the safe probe ever taking irreversible actions? And does it share the same action space (set of code primitives) of the main pipeline?\n3. In the validation step, it seems that you need to perform some sort of lookahead validation, as the latest observation (and the full history) that you have at disposal is used to assess the confidence that all the skills in the plan will be correct. Is this the case? If so, how does the common sense confidence take into account the assessment of whether an action will be plausible n steps in the future?\n4. Can the framework as-is handle action failures due to imperfect low-level execution (i.e. due to stochasticity in the environment)? My understanding is that the safe probe can gather information in a POMDP, but that doesn't necessarily translate to robustness to stochasticity. Could some sort of replanning mechanism (e.g. Model-Predictive Control), either at the NeSyRo level, or at the level of the synthesised policy help?\n5. Can you provide a more detailed description of the verification step, with a simple example of what a correct task specification might look like, which SMT solver you are using and how the feedback might look like? Do you assume to have a PDDL domain with operators matching the code skills/primitives, in order to do this step? And how do you ground PDDL in the environment? Do you have a ground-truth representation function of every (or at least the initial) state? Overall I think the assumptions of this step should be clarified in the main text and the answer to this question could be added as a section of the appendix.\n6. If PDDL is used so extensively, why not plan directly solely via PDDL? Is the main difference that in PDDL one cannot express the parameter for the skills, and as such it could decide which sequence of actions to take, but not which parameters these actions should have? \n7. Can you explain in more detail how the retrieved demonstrations are collected? As I understand it, your framework doesn’t include a training phase, so is it fair to assume having at disposal demonstrations to retrieve at test time? \n8. How much overlap is there between the work cited for CaP w/ Lemur baseline and your implementation of the Neuro-symbolic Code Verification? Similar question for CaP w/ CodeSift and your verification and especially validation implementations.", "limitations": "Limitation section should be definitely expanded (currently two lines) to discuss all the assumptions they make (see weaknesses and questions).", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 3, "originality": 4, "strengths_and_weaknesses": "Strengths\n- Complete and sensible system to increase the reliability of Code-as-Policies approaches; the method is well designed, with original solutions to all the sub-problems the authors had to tackle to make it work\n- Paper is clearly written and manages to present a complex method in an understandable way\n- Good experimental setup, very nice baselines, convincing main results \n- Helpful ablations on the usefulness of both verification, validation and impact of LLM model on the code generation and the LLM-based validation confidence score\n\nWeaknesses\n- Not all assumptions are clear, it would be good for the paper to explain better exactly all the extra machinery that one needs to make this approach work with respect to what vanilla CaP requires\n- The limitations section is virtually non-existent, while it should reflect for example when are the assumptions of the point above reasonable to assume. \n- Some details and citations are missing, like which SMT solver the authors use (a footnote would do).\n- The problem formulation should include some notes about how the action space looks like in the CaP case, how is the state representation handled (how high or low level it is) and what (if any) is the difference between actions and skills.\n- It’s not really clear how much the baselines considered overlap with the method proposed. \n\nOther notes\n- In the camera-ready version, please make sure to cite the appendix sections in the main text. I understand it has been submitted later as supplementary material, so it’s okay at this stage not to have that.", "was_revised": true, "final_justification": "The discussion with the authors clarified many details of the proposed method. The authors made clear plans in their final acknowledgement to include the additional explanations in the paper. Overall it's a very strong and solid paper, which will probably be strengthened by including these discussions in the camera-ready version.", "rebuttal": "Dear Reviewer xaVS,\n\nWe appreciate your clear articulation of both the strengths and the areas for improvement, which we address below.\n\n---\n### W1, W2: Missing assumptions, additional components, and limitations discussion\nBelow is a concise response structured around three aspects of the reviewer's concerns: \n\n- (1) Assumptions & resources\n    - Partial observability: Initial symbolic observation is given; additional predicates are recovered online via perception (e.g., VLM).\n    - Deterministic low-level control.\n    - Task coverage: the goal can be expressed as a sequence of skills in $\\mathcal{D}$.\n    - Resources: domain knowledge $\\mathcal{D}$, demo set $\\mathcal{E}\\_{\\text{demo}}$ (RAG), observation buffer $o\\_{\\le t}$, SMT solver (Z3), PDDL planner (Fast Downward), validation LLM for commonsense scoring.\n\n- (2) Extra machinery beyond vanilla CaP\n    - Neuro-symbolic verification & validation\n    - Safe probe synthesis when $\\text{NeSyConf}<\\epsilon$, with probes undergoing the same recursive verification & validation process.\n    - Skill refinement: only the offending skill suffix is regenerated.\n\n- (3) Limitation\n    - NeSyRo assumes deterministic execution and does not yet handle stochastic failures, as noted by Reviewer xaVS Q4. Execution-time replanning (e.g., MPC) is a promising future direction.\n\n---\n### W3, Q5: Underspecified verification and PDDL assumption details\nWe clarify the verification step and assumptions below.\n\n- (1) Verification process: We use the Z3 SMT solver to verify policy code $\\pi_{\\text{main}}$ satisfies a task specification $\\mathcal{T}_{\\text{spec}}$, including a high-level plan and parameter constraints. If verification fails, feedback is generated through the LLM and SMT solver, as detailed in our response to Reviewer nsGi Q4. The framework assumes that specification skills align with the PDDL domain knowledge, but it remains robust even when generation errors cause mismatches, as discussed in our response to Reviewer nsGi Q1. An example of the task specification is shown below.\n```json\n{\n  \"plan\": [\n    {\"skill\": \"pull\", \"args\": {\"target\": \"middle_drawer\", \"dist\": , ...}},\n    {\"skill\": \"pick\", \"args\": {\"target\": \"dice\"}, ...},\n    {\"skill\": \"place\", \"args\": {\"target\": \"top_drawer\"}, ...},\n    ...\n  ],\n  \"constraints\": {\n    \"0\": {\"dist\": [0.05, 0.15]},\n    ...\n  }\n}\n```\n- (2) PDDL grounding assumptions: We assume that the initial symbolic observation is externally provided and partially aligned with the ground-truth state, containing a subset of task-relevant predicates. This controlled incompleteness defines partially observable scenarios in a reproducible way. During execution, missing or ambiguous predicates are recovered via safe probes, with visual inputs processed by a VLM to extract symbolic information. Thus, only partial ground-truth access is assumed initially, with all further updates handled by perceptual modules.\n\nWe will include these details and the SMT solver name in the final version.\n\n---\n### W4: Unclear action/skill/state\nAn action is an atomic low-level primitive (e.g., move\\_to(x, y, z), grasp( )) that controls the robot in continuous space. By contrast, a skill is a higher-level symbolic unit that parameterizes and composes a sequence of such actions to achieve a subgoal (e.g., pull(drawer, dist=0.1) may invoke multiple move_to and grasp calls). Under this view, the action space is implicitly defined as a continuous control space over which the robot operates, while the skill space is defined symbolically by the set of parameterized function calls. The policy code $\\pi_{\\text{main}}$ consists of a sequence of skills $(f_0, f_1, \\ldots, f_N)$.\n\nThe state is symbolic and structured. Observations are stored as symbolic facts (e.g., is_locked(“top_drawer”)) in observation buffer $o_{\\leq t}$. These symbolic observations are incrementally constructed through interaction (e.g., via safe probe).\n\n---\n### W5, Q8: Ambiguous overlap with CaP baselines\n\nWhile the baselines are adapted from CaP, their mechanisms differ substantially from ours.\n\n- (1) CaP w/ Lemur:\nBoth CaP w/ Lemur and NeSyRo perform verification by generating full policy code and checking it with an SMT solver.\nHowever, CaP w/ Lemur repeatedly regenerates the entire code to match a fixed specification, whereas NeSyRo uses chain-of-thought prompting to induce the specification and performs skill-level patching when verification fails. This enables a more modular and efficient refinement process.\n\n\n- (2) CaP w/ CodeSift:\nCaP w/ CodeSift and NeSyRo both aim to improve the reliability of LLM-generated code through verification and validation, but differ fundamentally in their approach. CodeSift relies on static, multi-stage LLM-based checks without symbolic reasoning. In contrast, NeSyRo employs a neuro-symbolic strategy, combining CSC and LC, for interactive validation and environment-aware refinement under partial observability.\n\n---\n### Q1: Define “dynamic environment” formally\nWe call the environment dynamic when executing at least one action can change the symbolic state. Let $\\mathcal{S}$ be the set of states, $\\mathcal{A}$ the set of atomic motion primitives, and $T$ the transition function. The environment is dynamic if and only if\n\n$\\exists\\ s \\in \\mathcal{S}, a \\in \\mathcal{A} \\quad \\text{s.t.} \\quad T(s,a) \\neq s$\n\nThat is, some atomic action modifies the symbolic state. Let $f$ be the domain-level library of parameterized skills, each implemented as a finite sequence of actions from $\\mathcal{A}$, and thus inherits this property.\n\n---\n### Q2: Probe safety and action space consistency\nThe safe probe policy is unlikely to take irreversible actions and shares the same action and skill space as the main policy.\n\n- (1) Irreversible actions: Like the main policy, the safe probe is verified and validated to prevent unsafe actions. As shown in Table 3, NeSyRo-Complete setting (fully observable environment, no probe needed) results in 6 irreversible actions (IA), while NeSyRo with probe results in only 7. This minimal increase shows that safe probe rarely causes irreversible effects, unlike CaP, which leads to 53 IA.\n\n- (2) Shared action space: The safe probe is generated and checked using the same pipeline as the main policy. It uses the same set of parameterized skills from the domain knowledge $\\mathcal{D}$ and follows identical code generation and refinement procedures.\n\n---\n### Q3: CSC's future plausibility estimation\nOur framework performs sequential n-step lookahead validation using only the current observation history $o_{\\le t}$, assuming prior skills are validated. The process begins with the first skill $f_0$ with confidence $\\text{NeSyConf}_{f_0}$ from CSC and LC. Once $f_0$ is validated, we symbolically simulate its effects to generate a predicted observation $\\hat{o}_1$ to validate $f_1$. This recursive process continues for subsequent skills.\n\nImportantly, CSC evaluates the plausibility of each skill using $o_{\\le t}$ and retrieved demos. It does not perform explicit multi-step foresight. Instead, lookahead is realized by the framework as a whole: each step's predicted observation feeds into the validation of the next skill. This symbolic unrolling enables multi-step assessment.\n\n---\n### Q4: Handling stochastic failures\nNeSyRo is designed to handle partial observability by leveraging neuro-symbolic validation and recursive safe probing. This process recovers missing observations, improving policy grounding and task reliability. However, NeSyRo does not address low-level stochastic failures (e.g., mis-grasps). These failures are outside the scope of our framework, which assumes deterministic execution once the policy is validated.\n\nWe agree that incorporating replanning mechanisms, such as Model Predictive Control (MPC), could help recover from execution-time failures without restarting the entire plan. Future work could extend NeSyRo beyond symbolic grounding by exploring such mechanisms.\n\n---\n### Q6: Limitations of PDDL-only planning\nPDDL alone cannot express continuous parameters and requires fully observable states, making effective planning under partial observability challenging. Specifically, PDDL has two critical limitations:\n\n- (1) Limited parameter expressiveness: PDDL cannot represent continuous parameters. LLM-generated code addresses this limitation by accurately adjusting these continuous parameter values.\n\n- (2) Inability to plan under partial observability: PDDL assumes full observability, so it cannot handle uncertainty (e.g., unknown drawer states). Our framework uses safe probes to check uncertain conditions (e.g., is a drawer locked). This active observation recovery allows continual refinement of the plan based on updated environmental information.\n\nExperiments show that combining LLMs with PDDL overcomes these limits and improves task success under partial observability.\n\n---\n### Q7: Assumptions behind demo retrieval\nOur framework does not involve any training phase. Instead, it retrieves demonstrations at test time from a pre-constructed, synthetic library using retrieval-augmented generation, conditioned on the current observation and instruction. As described in Appendix C.2, all demonstrations are generated by GPT-4o without environment execution or human supervision. We synthesized 500 demonstrations covering 15 skill types. The collection proceeds as follows:\n- (1) Domain definition: A domain-level PDDL is defined to capture symbolic transitions (e.g., drawers, bins).\n\n- (2) Context specification: We instantiate concrete symbolic states (e.g., “the third drawer is locked, a cup is on the table”).\n\n- (3) Instruction \\& plan generation: GPT-4o generates a natural language instruction and the corresponding symbolic plan.\n\n- (4) Demonstration structuring: Plans are segmented into skill-level demonstrations with pre/post observations and success labels.\n\n---\nWe again thank the reviewer. We will incorporate these improvements in the final version."}, {"review_id": "Q2VT9MN09D", "reviewer": "Reviewer_UanP", "summary": "This paper introduces NESYRO, a neuro-symbolic framework designed to improve the reliability of LLM-generated code for robotic task planning, particularly in environments with partial observability. The core contribution is a recursive planning loop that integrates code generation with two feedback mechanisms: a symbolic verification stage that checks logical correctness, and an interactive validation stage that assesses environmental feasibility. When the framework's confidence score (NeSyConf) for a planned action is low, indicating missing information crucial for success, it autonomously generates and executes a \"safe probe.\" This probe is an exploratory sub-policy designed to gather necessary observations from the environment (e.g., checking if a drawer is locked before trying to open it). The new information is then fed back to the LLM to refine the original plan. This process of generating, verifying, validating, and probing repeats until a high-confidence, grounded plan is produced. The authors demonstrate through extensive experiments in both the RLBench simulator and the real world that NESYRO significantly outperforms state-of-the-art baselines, improving task success rates by over 46% and ensuring high executability of actions in dynamic settings.", "questions": "1. The recursive validation loop is a powerful idea for ensuring robustness. However, what is the trade-off in terms of computational time and overall task completion time? Could you report on the average number of probe-refinement cycles required for the different levels of observability incompleteness and the associated latency?\n2. How does the system guarantee that a probe action is indeed safe and reversible? Is this based on a manually curated set of \"safe\" skills, or can the symbolic verification module reason about the potential side effects of a probe?\n3. The experiments are performed on tabletop manipulation tasks. How do you see the NESYRO framework scaling to more complex, longer-horizon tasks, such as mobile manipulation in a full home environment? Would the complexity of symbolic verification and the state space make the process intractable?", "limitations": "yes", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 4, "originality": 3, "strengths_and_weaknesses": "### **Strengths**\n1. The reliability of LLM-generated plans in partially observable, dynamic environments is a major bottleneck for real-world robotics. This paper tackles this head-on with a practical and effective solution. The focus on grounding high-level plans in low-level, verifiable actions is exactly what the field needs to move beyond constrained lab demos.\n2. The NESYRO framework is technically solid. Its recursive verify-and-validate loop is effective, and the \"safe probe\" elegantly enables active uncertainty reduction. The hybrid confidence score (NeSyConf), combining learned commonsense and symbolic logic, thoughtfully guides the probing process.\n3. The paper’s evidence is robust: tested on four task categories and observability levels in both simulation and hardware, the method outperforms strong baselines (CaP, CaP + static analysis, AutoGen) by 46.2 % and reaches 86.8 % executability in the real world. Ablations show that each module (LC, CSC) is essential.\n4. By testing on a physical Franka Emika arm and showing successful task completion in challenging scenarios (e.g., Figure 5's \"dark room\" task), the authors demonstrate the practical relevance of their work. The framework's design inherently promotes safety by ensuring that preconditions are met before execution, which reduces the rate of irreversible and thus potentially unsafe actions.\n\n\n### **Weaknesses**\n1. **Latency and Efficiency:** The recursive design, while robust, may introduce latency due to repeated probing, code regeneration, and validation. The paper lacks metrics on planning time or interaction steps, which are key for real-time applications.\n2. **Assumptions about “Safe” Probes**: The framework assumes probes preserve task-relevant states, which may not hold in all scenarios (e.g., probing fragile objects). Clarifying the scope of this assumption would strengthen the work.\n3. **Originality in Synthesis:** The novelty lies in the effective integration of existing ideas rather than in a fundamentally new algorithm. While NeSyConf and the overall design are impactful, the core components have prior precedent [1, 2, 3].\n\n\n[1] Liang, J., Huang, W., Xia, F., Xu, P., Hausman, K., Ichter, B., ... & Zeng, A. (2023, May). Code as policies: Language model programs for embodied control. In 2023 IEEE International Conference on Robotics and Automation (ICRA) (pp. 9493-9500). IEEE.\n\n[2] Choi, W., Park, J., Ahn, S., Lee, D., & Woo, H. NeSyC: A Neuro-symbolic Continual Learner For Complex Embodied Tasks In Open Domains. In The Thirteenth International Conference on Learning Representations.\n\n[3] Singh, I., Blukis, V., Mousavian, A., Goyal, A., Xu, D., Tremblay, J., ... & Garg, A. (2023, May). Progprompt: Generating situated robot task plans using large language models. In 2023 IEEE International Conference on Robotics and Automation (ICRA) (pp. 11523-11530). IEEE.", "was_revised": true, "final_justification": "The authors have addressed my concerns, and I do not find other major flaws in this paper.", "rebuttal": "Dear Reviewer UanP,\n\nWe thank the reviewer for the insightful and encouraging evaluation. We especially appreciate your focus on practical applicability and thoughtful questions about efficiency, safety, and scalability, which we address below.\n\n---\n### W1, Q1: Latency and computational cost of recursive validation\nIn response to the reviewer's suggestion, we report component-wise computational metrics for the cost-incurring modules of our framework, evaluated under different levels of observability incompleteness in long-horizon RLBench tasks.\nThe table below summarizes average planning time, number of probe refinement cycles, and detailed per-task statistics on symbolic tool and LLM usage, including the number of calls and average time per call.\n\n|Observability Level|Planning Time/Task|Probe refinement Cycles/Task|Symbolic tool Calls/Task|Symbolic tool Time/Call|LLM Calls/Task|LLM Time/Call|\n|-|-|-|-|-|-|-|\n|High Incompleteness|517.8s|2.9|16.9|2.3s|26.8|8.3s|\n|Low Incompleteness|264.1s|2.4|11.2|2.1s|19.8|6.0s|\n\nThe primary contributor to planning time is LLM response latency, while symbolic tool usage (e.g., SMT and PDDL solvers) adds relatively little overhead.\nWhile planning incurs a moderate overhead per task, NeSyRo prioritizes reliable task completion over speed. Our focus is on accurately grounding policy code under partial observability rather than minimizing response latency.\nThe table below illustrates the trade-off between computational cost and success rate, controlled by the validation threshold $\\epsilon$. As $\\epsilon$ increases, NeSyRo performs more probe refinement and symbolic checks, resulting in higher planning time but improved task success.\n\n|$\\epsilon$|SMT Calls/Task|PDDL Calls/Task|Probe refinement Cycles/Task|Planning Time/Task|SR|\n|-|-|-|-|-|-|\n|0.0|1.3|4.9|0.0|140.9s|55.6%|\n|0.3|3.9|11.6|1.1|167.6s|88.9%|\n|0.6|10.3|18.3|3.5|250.1s|100.0%|\n|0.9|16.0|25.3|5.0|294.7s|100.0%|\n\nNeSyRo adopts a more conservative validation strategy as $\\epsilon$ increases, triggering more probe refinement cycles for uncertain steps. This raises planning time (from 140.9s to 294.7s) but significantly improves success rate (from 55.6% to 100%). The results highlight how tuning $\\epsilon$ enables a controllable trade-off between reliability and computation, depending on task demands.\n\n---\n### W2, Q2: Assumptions and guarantees of probe safety\nWe address both the assumptions made about safe probing and the mechanisms that ensure its safety and reversibility below.\n\n- **(1) Scope of the safe probe assumption:** \nWe assume that probe policies preserve task-relevant symbolic states by avoiding irreversible changes to the environment during execution. This is supported by our use of deterministic low-level controllers, which allow skills such as pull, pick, or place to execute consistently when preconditions are met. As a result, even fragile objects can be safely manipulated under ideal conditions. However, the framework does not account for stochastic physical effects such as slippage, unstable contact, or object deformation. Handling such dynamics is beyond the current scope of our work and presents a promising direction for future extensions. Further discussion on this aspect can be found in our response to Reviewer xaVS W1, Q4.\n\n- **(2) Safety guarantee mechanism:** \nOur framework does not rely on a manually curated set of “safe” skills. Instead, NeSyRo ensures the safety of each probe policy $\\pi_{\\text{probe}}$ through neuro-symbolic validation. Specifically, the NeSyConf combines symbolic feasibility $\\text{LC}\\_{f_n}$ and commonsense plausibility $\\text{CSC}\\_{f_n}$ for each skill $f_n$. This dual criterion helps detect both logical violations (e.g., unmet preconditions) and contextually unsafe actions. Because only skills with high NeSyConf are executed, and low-confidence probes are recursively refined, the system prevents unsafe code from reaching execution. Thus, the validation process acts as a safeguard, filtering out probe policies likely to cause task failure or irreversible effects.\n\n- **(3) Side effect reasoning:** \nThe symbolic planner $\\Psi\\_{\\text{vali}}$ verifies whether a skill $f_n$ satisfies preconditions defined in the PDDL domain, such as “a cup with water must be placed on a low surface.” However, it cannot reason about side effects that are not explicitly modeled, like a cup tipping over when placed too high. To complement this, the Common Sense Confidence $\\text{CSC}_{f_n}$, computed by $\\Phi\\_{\\text{vali}}$, leverages retrieved demonstrations and LLM priors to assess contextual plausibility. This allows the system to filter out physically unsafe actions even when such risks are not encoded symbolically.\n\n- **(4) Empirical safety evidence:** \nOur recursive validation strategy effectively minimizes failure modes. In Table 3, we report that NeSyRo executes only 7 irreversible actions under partial observability, compared to 53 with CaP. This empirically confirms that the combined symbolic and commonsense validation significantly improves the safety of information-seeking behavior.\n\n---\n### W3: Originality of the proposed framework\n\nAs discussed in the Related Work section, we argue that NeSyRo represents a novel neuro-symbolic robot task planning framework that goes beyond a simple combination of existing components. Below, we clarify key distinctions between NeSyRo and the cited methods.\n\nCode as Policies (CaP) and ProgPrompt directly generate control code, but the resulting code often lacks proper grounding in dynamic or partially observable environments due to the absence of explicit feedback integration. This leads to incomplete or non-executable outputs. In contrast, NeSyRo improves code grounding and reliability by incorporating explicit feedback into the generation process.\n\nWhile NeSyC leverages environmental feedback and a neuro-symbolic framework for embodied task planning, its goal is to construct generalized symbolic knowledge through continual interaction between symbolic tools and LLMs in iterative loops. In contrast, NeSyRo focuses on generating environmentally grounded policy code by recursively gathering missing observational information, thereby strongly regularizing ungrounded execution.\nSpecifically, the scoring method in NeSyC, called the HI score, differs from NeSyConf in both purpose and computation. HI measures alignment between transitions and demonstrations, whereas NeSyConf estimates skill feasibility by combining logic-based planning and commonsense priors. The two scores address fundamentally different objectives and are not interchangeable.\n\nNeSyRo's robustness cannot be achieved by simply combining components from prior work. Its key novelty lies in detecting uncertainty during code generation and recursively generating safe probes to recover missing observations before execution (Figure 2, Lines 185–192). This mechanism is essential for reliable performance in dynamic environments, as demonstrated by the empirical results in Section 4.2 and Table 2.\n\n---\n### Q3: Scalability and tractability in complex domains\nWe address the reviewer's question in two parts:\n\n- **(1) Scalability to complex domains and long-horizon tasks:** \nNeSyRo's modular design allows it to scale from tabletop manipulation to more complex embodied domains, including mobile manipulation in full home environments [1, 2, 3]. In particular, both symbolic tools used for verification and interactive validation can be replaced to suit the target application domain. Recent neuro-symbolic studies [4, 5] have shown that symbolic tools such as SMT solvers and PDDL planners can be adapted to diverse planning problems. NeSyRo is compatible with these approaches and can incorporate domain-specific symbolic tools, such as those for spatial navigation or mobile interaction, without modifying its core architecture [6,7].\nWhile our experiments focus on tabletop settings, we also include long-horizon tasks in both simulation and the real world, involving multi-step sequences, recursive probing, and dynamic observation recovery, as shown in Table 2 and Table 3 in our paper. These results demonstrate NeSyRo's robustness under uncertainty and its applicability to more complex task structures.\n\n- **(2) Managing complexity in NeSyRo:** \nTo address complexity in large environments, NeSyRo adopts two strategies. First, validation is performed at the skill level, using symbolic tools and commonsense estimation based on partial observations. This localized reasoning keeps the process tractable even when the symbolic state space is large. Second, while verification currently applies to the full policy code, it can introduce overhead as task length grows. A natural extension is to decompose tasks into subtasks with local specifications, enabling more efficient verification. This aligns with hierarchical planning approaches [8,9] and is reflected in our framework design.\n\n---\nWe again thank the reviewer. We will incorporate these improvements in the final version.\n\n[1] Puig et al. Virtualhome: Simulating household activities via programs. CVPR 2018.\n\n[2] Kolve et al. AI2-THOR: An Interactive 3D Environment for Visual AI. arXiv 2017.\n\n[3] Shridhar et al. ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. ICLR 2021.\n\n[4] Pan et al. Logic-LM: Empowering Large Language Models with Symbolic Solvers for Faithful Logical Reasoning. Findings of EMNLP 2023.\n\n[5] Lin et al. CLMASP: Coupling Large Language Models with Answer Set Programming for Robotic Task Planning. arXiv 2024. \n\n[6] Lu et al. Neuro-symbolic Procedural Planning with Commonsense Prompting. ICLR 2023.\n\n[7] Zheng et al. JARVIS: A Neuro-Symbolic Commonsense Reasoning Framework for Conversational Embodied Agents. arXiv 2022.\n\n[8] Mirakhor et al. Task Planning for Object Rearrangement in Multi-room Environments. AAAI 2024.\n\n[9] Chen et al. EMOS: Embodiment-aware Heterogeneous Multi-robot Operating System with LLM Agents. ICLR 2025."}]

Author rebuttal:

Meta-review: The paper introduces NeSyRo (Neuro-Symbolic Robotic Task Planning), a framework that extends the Code-as-Policies (CaP) paradigm by adding recursive verification and validation mechanisms to improve the reliability of LLM-generated policies for embodied agents. The framework operates in a loop: an LLM generates task code; a symbolic verification step checks the logical correctness of the code against task specifications; a validation step assesses environmental feasibility via a neuro-symbolic confidence score that combines logical constraints with commonsense priors. If validation fails (confidence is low), the system deploys a safe probe policy to gather additional observations, refining the plan recursively until a high-confidence, executable policy is obtained. Empirical Results show substantial gains in success rate and executability over strong CaP baselines. 

**Strengths** The paper addresses a critical bottleneck in LLM-based robotics by improving the reliability of code-generated policies in dynamic environments. The proposed framework combines symbolic verification, neuro-symbolic validation, and safe probing into a recursive loop that ensures robustness. The empirical evaluation spanning RLBench tasks and real-world robotic experiments shows substantial improvements over strong CaP baselines. Ablation studies further validate the necessity of both verification and validation components.

**Weaknesses** Reviewers raised several concerns related to efficiency, assumptions, and scope. The recursive design can slow down planning, which may limit real-time use and make long-horizon tasks challenging. The framework also assumes that probes are always safe and reversible, which might not hold in fragile or irreversible situations. Finally, the reliance on external verification tools raises questions about computational cost.

The authors provide compelling responses, showing that these limitations are reasonable trade-offs for the practical benefits the framework provides. Overall, NeSyRo combines verification, validation, and adaptive probing in a way that is both novel and directly applicable to real-world robotics. Coupled with strong experimental results and a clear, practical system design, the work stands out as highly relevant to the AI and robotics community.
Decision: Accept (spotlight)