acceptodds
Under review as a conference paper at ICLR 2027

RoboPhys: Beyond Outcomes, Toward Physically Correct Execution of LLM-Generated Robotic Programs

Abstract

Large language models (LLMs) are increasingly used to generate executable programs for robotic systems. As generated code moves from purely digital environments to embodied systems, however, conventional notions of correctness become insufficient. Existing code-generation benchmarks primarily measure functional correctness, considering a program correct if it executes successfully and passes functional tests. Yet robotic programs must also satisfy constraints imposed by physical execution. To capture this requirement, we formalize physical correctness as a distinct evaluation dimension that measures whether a program respects physical constraints throughout its execution in the environment. Importantly, outcome correctness does not necessarily imply physical correctness: a program may complete the intended task while violating physical constraints during execution. We introduce RoboPhys, an evaluation protocol that augments functional testing with physical execution constraints. RoboPhys identifies LLM-generated programs that satisfy terminal task predicates, then re-executes them under diverse physical conditions while monitoring constraint violations throughout their trajectories. Across five code-generation systems and 300 generated robot programs, 38 of the 136 nominal functional successes incurred at least one physical violation (27.9%). Trajectory audits guide task-conditioned repairs that restore task completion without executed violations or rejected hazardous requests in 42 of 57 initially unsafe-success program–scene cases. Cross-stage regressions motivate complete-execution revalidation and identify state-aware, task-agnostic repair as a direction for further study. These findings expose a blind spot in outcome-only evaluation, demonstrate the value of execution-level diagnosis for repair, and support evaluating physical execution correctness alongside task completion in generated robot programs.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Code Genetration, embodied AI, Code Evaluation

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_PeNtOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper argues that a robot program that reaches the correct final outcome may still violate physical constraints while it runs, and it proposes RoboPhys to evaluate this separately. RoboPhys is an evaluation protocol that complements terminal task predicates with trajectory-level physical monitoring under diverse physical conditions. Across five code-generation systems and 300 programs, the results show that trajectory-level diagnoses can guide effective repair.

Critical strengths
  1. RoboPhys clearly distinguishes task completion from physical execution quality and uses held-out re-execution without giving feedback to the generator.

  2. The trajectory audit provides useful mechanism-level analysis, while complete-run validation exposes downstream failures and repair regressions.

Critical weaknesses
  1. The physical oracle is tied to a narrow, hand-specified Panda/MuJoCo setup. Its thresholds, overlapping F/A predicates, and treatment of rejected requests limit the generality of the conclusions.

  2. The repair evaluation is based on inspected cases and uses task-specific rules and unequal information access. It therefore does not establish a general repair method or isolate which design choices produce the reported gains.

Questions for authors
  1. Can you validate the physical monitors outside the current Panda/MuJoCo stack, or provide independent expert/hardware labels and event-level error rates? Please also report the headline results after separating the predicates shared by F and A, and after treating rejected requests L separately from executed physical violations.

  2. Can you evaluate one frozen repair policy on tasks, geometries, and generation sources that were not used for the trajectory audit or pilot repairs, with matched information access and a simple no-repair baseline? Please report paired uncertainty estimates and all F, A, L, strict-success, and regression outcomes.

2 comments
AuthorsOpenReview ↗

Response to Reviewer PeNt

Thank you for the specific validation requests. We added event-label analysis, paired cross-arm execution, and repair tests.

  1. Overlapping predicates, rejected requests, and monitor validation

We reanalysed all 2,736 saved executions, retaining the programs, thresholds, completion labels, refusal records, and experimental groups. These are existing records, not additional runs.

Alongside the original A label, A_exec retains events supported by executed states. It excludes release_instability, which overlaps with terminal stability, and the request/protocol flags premature_release and unverified_transport. The latter can arise before IK or gateway acceptance and does not establish executed motion.

Nominal violation counts fall from 46 to 44, while all 38 unsafe successes among 136 functional successes remain. The two held-out groups retain 94 and 493 executions with actual violations, including 63 and 455 unsafe successes. No saved execution contains release_instability. Among 123 nominal completions without gateway refusal, 31 still contain executed violations. Separating request flags and overlapping predicates therefore preserves the main finding.

We also replayed 29 unchanged programs on Panda and iiwa. Reference programs completed all six nominal tasks on each arm without violations or refusals. Each arm had four unsafe successes, with only two violating sources shared. Base, home configuration, and controller were adapted before freezing the setup. Joint-speed limits were arm-specific; Panda's TCP limit was not applied to iiwa because no verified global iiwa bound was available. All violating runs involved collision, monitored on both arms.

Both setups still share MuJoCo, the gripper, and monitor code. Independent expert or hardware labels, event-level error rates, and threshold-sensitivity measurements remain missing. Cross-arm replay broadens the evidence but does not validate detector accuracy independently.

  1. Frozen repair, matched information, and regressions

The original 42/57 and 6/57 results compare complete repair strategies with different observations, candidate construction, and edit locations. They cannot isolate the effect of task knowledge. The former uses rules developed from inspected trajectories; the latter is a state-dependent geometric prototype. Rule application and evaluation are automatic, while rule design occurs during development.

We froze the prototype before testing five existing programs under two new geometries each. Against the unchanged-program baseline, strict successes rose from 3 to 4 across ten configurations, while completions fell from 7 to 5. Strict success requires completion without violations or rejected requests. A separate pilot used one project-aware assistant-written source across five tasks and two settings each; strict successes remained at four. This was one shared source, not ten independently generated programs.

An additional release test gave geometric, transition, and complete-run selectors the same candidate bank. Transition and complete-run checking selected the same safe 30-mm adjustment on the inspected Panda C1 source. Neither found a safe candidate on iiwa. Thus, this test shows no extra recovery from complete-run selection over transition checking. Candidate selection consumed execution feedback and was not an independent held-out performance estimate.

A safe B1 control required no edit, while a B2 program that aborted before release remained unrepaired. Fixed release edits preserved completion for two known C1 sources on both arms but removed all recorded violations only on Panda.

We report both recoveries and regressions. The experiments support repair of some inspected cases, while a frozen policy tested on unused tasks and generation sources, with matched information and paired uncertainty estimates, is still needed to establish general repair performance.

Thanks for the responses by the authors. The event-label reanalysis resolves my concern that overlapping predicates might explain the main finding, and the iiwa experiment adds useful evidence beyond Panda. Both setups still share the simulator and monitor code, however, so monitor accuracy remains independently unverified. The repair evidence is also limited: the main results concern inspected cases, and the transfer pilots show mixed gains alongside functional regressions. These additions address part of my concerns, but stronger validation and evidence of transfer are still needed. I therefore maintain my original rating.

Reviewer_nzowOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
3
Read review
Paper summary

RoboPhys separately tracks task completion (F), executed violations (A), and rejected hazardous requests (L), then audits trajectories and evaluates researcher-guided repairs. This highlights limitations of outcome-only evaluation, but the paper appears to offer few new concepts and reads primarily as an engineering record.

Critical strengths

Using LLM-generated programs to control robotic arms is interesting and practically relevant.

Critical weaknesses

The methodological novelty remains unclear, particularly beyond standard event monitoring, trajectory inspection, and task-specific repair rules.

Questions for authors
  1. Detecting violations is relatively straightforward with simulator ground truth. How would collision, overspeed, and grasp-loss monitoring work on real robots? What sensing, estimation, and uncertainty handling would be required?
  2. What events or failure mechanisms would RoboPhys identify that existing tools such as RoboCritics, RoboEval, or SafeManip would miss on the same programs and scenes? Please clarify the substantive methodological contribution beyond combining existing checks.
  3. The 42/57 repair result concerns previously inspected cases. How well do frozen repair rules generalize to unseen programs, geometries, and tasks? Please distinguish automated processing from researcher intervention and report the required manual effort.
  4. F/A/L alone contain limited diagnostic information. Although event logs and trajectories provide additional evidence, how are violation details converted into specific program edits? Please illustrate the feedback passed to the repair procedure and clarify which diagnosis and repair steps are automatic versus manually designed.
2 comments
AuthorsOpenReview ↗

Response to Reviewer nzow

Thank you for the questions. We clarify the contribution, the role of researchers in repair, and the additional evidence.

  1. Monitoring on real robots

The current implementation uses simulator states and configured geometry. Hardware monitoring would require timestamped encoders and calibrated kinematics for speed checks, plus contact or torque sensing and object tracking for collision and grasp-loss checks. Measurement uncertainty would require margins and a stop or indeterminate outcome when evidence is insufficient. Hardware validation remains future work. Our present contribution concerns generated robot code evaluated through repeatable physical simulation.

  1. Relation to prior work

RoboCritics, RoboEval, and SafeManip already address motion defects, traces, or temporal properties. Our contribution is the experimental analysis of failures concealed by successful task outcomes. We keep source code fixed across physical conditions, locate failures within action sequences, and examine whether corrective edits preserve safe completion.

Among 136 nominal functional successes, 38 contain executed violations. Of 92 programs that pass nominal task and safety checks, 53 violate a constraint in at least one held-out scene. The latter includes both successful and unsuccessful runs.

In the additional experiment, we replayed 29 unchanged programs on Panda and iiwa after adapting and freezing the iiwa setup. References completed all six nominal tasks on each arm without violations or refusals. Each arm produced four unsafe successes, but only two violating sources were shared.

One C1 source completed placement on both arms yet first collided 40 ms and 34 ms after gripper opening, respectively, with unchanged arm targets. Checking the preceding motion therefore did not establish clearance during opening. We have not compared the cited tools on identical traces and do not claim they would miss this event.

  1. Repair generalization and human effort

Repair rules were developed from trajectory analysis. Once fixed, code transformation, runtime adjustment, and complete re-evaluation were automatic. The 42/57 result concerns inspected program-scene cases from 54 sources. Per-case human time was not recorded.

We also tested a state-dependent prototype that constructs and checks candidates from current state and geometry. It uses shared rules for object-scaled height adjustments and obstacle-derived detours, without selecting repairs by A/B/C task label. It still reads the target structure to identify placement geometry. Accepted candidates pass through the original motion gateway, with new checks at subsequent requests.

The candidate rules are predefined. Sampled forward kinematics assume a fixed object-to-hand pose, so full execution remains necessary to assess contact and slip. The prototype restored strict success in 6/57 cases. After freezing the policy, five existing programs under two new geometries each yielded strict successes of 3 to 4, but completions fell from 7 to 5. A separate pilot using one project-aware assistant-written source across ten task/settings retained four strict successes. These results do not establish reliable repair generalization.

  1. From traces to code

Diagnosis uses timestamps, contact pairs, grasp states, gripper commands, and surrounding actions. In C1, contact after opening motivated a release-clearance rule. A template or API wrapper applies the edit, then the whole program runs through subsequent actions and settling. The wrapper uses the last successful Cartesian command as its reference, rather than a measured tool pose.

Researchers perform diagnosis and rule design during development. The state-dependent prototype additionally selects candidates automatically at runtime within predefined rules. Neither procedure learns new rules from execution. Complete re-execution checks whether removing one violation leaves another or prevents completion.

The gripper-opening example clarifies how researchers used contact timing to design a clearance rule. The additional simulated replay of 29 programs on Panda and iiwa also shows that changing the arm can change which programs violate a constraint. This result appears in the rebuttal only. Its value is limited by the question left open in my review: which failures can RoboPhys diagnose beyond those identifiable by existing tools on the same traces?

The 42/57 repair result still concerns cases inspected during rule development. Frozen rules produced mixed results on new geometries, including a drop in task completions from seven to five across ten runs. The proposed hardware sensing procedure also remains untested. The response makes the human role in diagnosis clear, but provides insufficient evidence of a distinctive diagnostic capability or a repair method that transfers reliably.

I maintain my rating of 1/4.

Reviewer_wDAQOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper identify a gap between the current final-outcome based evaluation and physically correct execution. A benchmark is proposed to evaluate LLM-generated robotic program with multiple trajectory-level physical simulation. Experiments shows that a large portion of generated robotic program contains physical violation, and trajectory audit is proposed to fix the problem.

Critical strengths

This work identifies the practical weakness in LLM-generated robotic program, in terms of the trajectory-level physical correctness.

Critical weaknesses
  • The proposed trajectory-level benchmark is mostly covered by the LIBERO-Safety and the experimental depth is limited.
  • The proposed fix mechanism, the trajectory audit, relies on the simulation and is not practical for the real-world deployed robotics.
Questions for authors
  • Could the trajectory audit be performed in the real-deployed robotics? If yes, real-time environment reconstruction and simulation shall be proposed. If not, a new training framework shall be proposed and evaluated to let the LLM agent learn with the trajectory audit feedback.
  • On the experiment and evaluation. The examples presented in the paper focus on simple scenarios. What are the differences in physical behavior performance of different models in different environments? How can these performance be attributed to the characteristics of the underlying model and different components in the Agent framework?
  • Recently, cutting-edge LLMs have made progress in engineering simulations of simple scenarios. What are the difficulties in constructing evaluations that are difficult to automate with LLMs? This shall be explicitly written. If an evaluation can be automated constructed by LLM, then the paper cannot bring additional value to readers.
1 comment
AuthorsOpenReview ↗

Response to Reviewer wDAQ

Thank you for the questions about prior benchmarks, practical scope, and what the experiments establish.

  1. Relation to LIBERO-Safety

LIBERO-Safety studies physical process safety, including unsafe objective achievement. Its contribution extends beyond domain randomization. Its physical evaluation terminates an episode on a safety violation and requires violation-free completion.

RoboPhys follows unchanged LLM-generated Python programs across physical conditions and retains final outcomes after violations when simulation can continue. This lets us investigate which failures remain concealed by task success, where they arise in the action sequence, and how they change after a code edit.

The contribution is the resulting evidence about program behavior and failure mechanisms. Among 136 nominal functional successes, 38 contain executed violations. Keeping code fixed also allows us to examine whether nominal qualification transfers: 53 of 92 nominally strict programs violate a constraint in at least one held-out scene, including successful and unsuccessful executions.

  1. Real-world applicability

The current audit uses simulator states and configured geometry. Hardware use would require sensing, calibration, state estimation, and uncertainty handling that we have not validated. Hardware testing, real-time reconstruction, and a new training framework remain future work.

We added a second arm model to examine dependence on Panda. After platform adaptation, we replayed 29 unchanged sources on Panda and iiwa. Reference programs completed six nominal tasks on each arm without violations or refusals. Each arm had four unsafe successes, but only two violating sources were shared. An obstacle-transfer collision disappeared on iiwa, while two narrow-support executions acquired collisions absent on Panda.

The same C1 source completed placement on both arms but collided shortly after opening, despite unchanged arm targets. Fixed release edits removed violations from two known Panda sources but left collision or slip on iiwa. The failure mechanism recurs across the tested arms, while the correction does not reliably transfer. Both setups share MuJoCo and the gripper, so this remains simulation evidence.

  1. Model and execution-environment effects

The generation systems differ in serving interfaces, reasoning settings, and agent tools. These comparisons cannot isolate model architecture or individual agent components. Fixing source code lets us study its response to physical variation, with controller and geometry effects included in the execution conditions.

The earlier external CaP-X S1 control helps identify execution-system effects. Its human-written reference also exceeds joint-speed limits. Retiming motion to the same IK targets preserves completion and removes monitored overspeed in both generated programs and the reference. Mean generated-program execution time increases from 8.31 to 13.27 seconds. This shows why attributing every violation to the LLM would overlook the shared execution system.

  1. What is learned beyond building a simulator?

The experiments explain specific failures that successful final outcomes leave undetected. The carried object's swept volume exceeds a commanded point. An earlier positive grasp query does not establish continued retention. Opening the fingers changes collision geometry after the arm reaches its target. In C1, the timing of contact identifies this release transition even though placement succeeds.

Repair then tests whether changing the diagnosed action resolves the problem throughout execution. A transport correction removes the first contact but leaves a later placement collision. A release adjustment can conflict with an existing guard. A correction that works on Panda can leave collision or produce slip on iiwa.

These results connect task outcomes to action-level failure evidence and the consequences of intervention. They explain why a checked move or a locally successful correction is insufficient evidence for safe execution of the complete program. Repair rules were developed from trajectory analysis, with automatic application and re-evaluation. The results do not establish a general autonomous repair method.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.