acceptodds
Under review as a conference paper at ICLR 2027

Spotter: Let the Embodied Model Lead, and the LLM Reflect for It

11 views

Abstract

Current embodied models do not respond to their own failures, although what just went wrong could inform a small adjustment on the next attempt; this is the mechanism behind the gains language models obtain from thinking, where a model reflects on an error and revises. We test whether they can repair a known error, which requires producing a correction and judging whether it is right. When an external interrupt stops them at a failure and lets them retry, their own randomness seldom repairs the error, a language description of the error changes little, and best-of-N selection cannot pick the successful candidate in post-failure states. We attribute this to training on successful demonstrations, which contain no failure or recovery, and to inputs too narrow to show what went wrong, and conclude that reflection must be supplied by a vision-language model (VLM), which can take in far more information, such as the history of the episode and text, and is more general. Prior VLM-led work has the VLM plan every step and invoke the embodied model as a tool, placing the VLM on the critical path. We propose Spotter, which reverses the roles: the embodied model leads and executes continuously, while the VLM runs in parallel, monitors through a lightweight local screener, intervenes only when an error is detected, reflects on and corrects it, and returns control. We run Spotter with Qwen and with GPT as the VLM, and both improve the embodied models; with GPT, Spotter improves Cosmos Policy and by 5.6 and 7.5 percentage points on RoboCasa, and raises from 47.2% to 57.0% on the Hard setting of RoboTwin 2.0 and from 53% to 83% on a real robot. Because the VLM steps in only when an error is confirmed, a successful episode with Qwen takes only 13 to 16 s longer than with the embodied model alone and about 70% less time than with a VLM-led baseline using the same model.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Large Language Model, Robot Agent, World Action Model, Test-time scaling, Failure recovery

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_338GOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Spotter keeps a frozen embodied policy running while a VLM monitors its actions and intervenes with a short repair plan when a failure is confirmed. The paper reports meaningful success-rate gains, but does not sufficiently isolate which component produces them.

Critical strengths

Spotter keeps a frozen embodied policy running while a VLM monitors its actions and intervenes with a short repair plan when a failure is confirmed. The paper reports meaningful success-rate gains, but does not sufficiently isolate which component produces them.

Critical weaknesses
  1. The incremental contribution over prior monitoring and recovery systems remains unclear. A matched synchronous-versus-asynchronous comparison using the same judge, repair primitives, context, information, and step budget is missing.
  2. The strongest results combine a powerful judge, repair primitives, a depth-based executor, and a retrieved demonstration. Even the “zero-shot” setting retrieves from 77 GPT-derived general lessons. Their separate contributions and the offline cost of building these resources are insufficiently characterized.
  3. The overall efficiency trade-off is substantial: with the Qwen full-context setting, mean episode time rises from 63 to 181 seconds for Cosmos Policy and from 37 to 126 seconds for π0.5. The broad claim about recovery is also supported mainly by a diagnosis of failed grasps.
Questions for authors
  1. Under matched models, inputs, primitives, and budgets, how much benefit comes specifically from asynchronous supervision?
  2. What performance remains without the general-lesson library, retrieved example, and depth-based repair executor?
  3. Can the authors report recovery by failure type and compare success rate at matched wall-clock or token budgets?
5 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer 338G (Part 1/2)

Dear Reviewer 338G,

Thank you for the precise questions on attribution and cost. W1/Q1 and W2/Q2 both ask how much each part of Spotter contributes, so we answer them together with one set of new ablation experiments on RoboTwin 2.0 (Hard), with π0.5. All changes are now in the revised PDF, marked in red.

W1 & Q1, W2 & Q2: Contribution of each component, including asynchronous supervision

The incremental contribution over prior monitoring and recovery systems remains unclear. A matched synchronous-versus-asynchronous comparison using the same judge, repair primitives, context, information, and step budget is missing. Under matched models, inputs, primitives, and budgets, how much benefit comes specifically from asynchronous supervision? The strongest results combine a powerful judge, repair primitives, a depth-based executor, and a retrieved demonstration. Even the "zero-shot" setting retrieves from 77 GPT-derived general lessons. Their separate contributions and the offline cost of building these resources are insufficiently characterized. What performance remains without the general-lesson library, retrieved example, and depth-based repair executor?

Response: Because of cost, these ablations use GPT-6.1 as the judge instead of GPT-6 Astra used in the paper, on a 150-episode subset of RoboTwin 2.0 that covers all 50 tasks (3 episodes per task). Every variant, including Spotter itself, runs on exactly the same episodes with the same judge. Table 3 changes one part of Spotter at a time (variants are defined in Appendix F.1), keeping the judge, primitives, context, information and step budget fixed.

Table 3 (Section 4.4 of the revised PDF). Matched comparison and ablations (RoboTwin 2.0 Hard, π0.5, GPT-6.1 judge)

SettingSuccessvs. synchronous
π0.5 alone50.7%−7.6
Spotter, asynchronous (as in the paper)56.7%−1.6
Spotter, synchronous (supervision pauses the policy)58.3%–
Synchronous, no screener (judge on every window)59.3%+1.0
No lesson library or retrieved example47.3%−11.0
No depth-based aiming58.0%−0.3
No execution history52.7%−5.6
No expectation checking56.0%−2.3

Asynchronous supervision (W1/Q1). In synchronous supervision, execution stays in lockstep with the screener: every window is checked, and the policy continues only after it is confirmed correct. This is why it is slightly higher than asynchronous supervision (58.3% vs 56.7%), but at a large cost in time: running supervision in parallel hides 36–38 s per episode on Cosmos Policy and 29–30 s on π0.5 on RoboCasa, about 60% and 80% of the policy's own execution time (Table 2). This is the main difference from prior VLM-led systems, in which execution waits on the VLM at every step (Table 7).

Screener. Likewise, removing the screener so that the judge checks every window raises success slightly, by 1.0 point on RoboTwin and 2.0 points on RoboCasa, but at a time cost that is hard to afford: the embodied model generates an action chunk in about 100 ms, while a GPT call takes 4.3 s on average, so the judge would sit on the critical path at every window. On RoboCasa it also takes 2.9× the tokens (Tables 1 and 2). The screener is what lets a slow judge run in parallel.

Lessons and retrieved example (W2/Q2). Without them success falls to 47.3%, below the policy alone, so they carry much of the gain. Depth-based aiming matters little (−0.3), so removing all three would not do better.

Execution history and expectation checking. Removing them lowers success to 52.7% and 56.0%.

Judge and primitives. A frontier judge is not required: with Qwen as the judge, Spotter raises RoboCasa success from 67.9% to 71.7% (Cosmos Policy) and from 64.3% to 68.4% (π0.5). The repair primitives matter: letting the policy retry after a detected failure gives no gain, even with an oracle detector (67.1% and 63.1%, against 67.9% and 64.3%; Table 1).

Offline cost is low and paid once (Appendix F.6). We run Spotter on development episodes disjoint from the test seeds and repeatedly summarize the judge's experience into general lessons: the 77 RoboCasa lessons took about 7 h (16 rounds on 367 episodes), and the 16 RoboTwin lessons about 3.7 h. We also manually reviewed 10 episodes in each of three rounds to catch bugs and add general advice, such as varying the motion after a failed grasp.

AuthorsOpenReview ↗

Rebuttal to Reviewer 338G (Part 2/2)

W3: Efficiency trade-off

The overall efficiency trade-off is substantial: with the Qwen full-context setting, mean episode time rises from 63 to 181 seconds for Cosmos Policy and from 37 to 126 seconds for π0.5.

Response: The increase comes from failed episodes (Table 2). On successful episodes Spotter adds only 13–16 s (34→47 s on Cosmos Policy, 23→39 s on π0.5), while failed episodes, where the judge keeps trying until the step limit, go from 125 to 521 s and from 62 to 313 s. An early exit, in which the judge ends hopeless episodes, cuts this time by about a third with success nearly unchanged (tested on RoboTwin with the GPT-6 Astra judge; Appendix F.3), and as repairs succeed more often, fewer episodes reach this case.

W3 & Q3: Recovery by failure type, and success at matched budgets

The broad claim about recovery is also supported mainly by a diagnosis of failed grasps. Can the authors report recovery by failure type and compare success rate at matched wall-clock or token budgets?

Response: We agree. By the judge's diagnosis at its first intervention (main RoboTwin run, GPT-6 Astra judge as in the paper; Table 10, Appendix F.5):

Failure diagnosedShare of intervened episodesRepaired to success
Missed grasp63%21%
Stuck / no progress22%14%
Dropped object4%0%
Wrong object1%0%
Other11%8%

Recovery comes mainly from grasp failures; drops and wrong objects are not repaired with the current primitives. We have narrowed the claim in the Conclusion (Section 6) to say this.

All methods already share the same step budget (1.8× the official limit). For time and token budgets, an episode counts only if it succeeds within the budget. The table below (Table 8, Appendix F.2) compares Spotter with Harness VLA using the same LLM, on RoboTwin 2.0 with π0.5. Unlike the ablations above, which use GPT-6.1, these runs use GPT-6 Astra as in the paper.

Budget per episodeSpotter (GPT-6 Astra)Harness VLA (GPT-6 Astra)Spotter (Qwen)Harness VLA (Qwen)
60 s43.310.038.08.7
120 s50.032.048.024.0
300 s52.046.051.335.3
100k tokens48.72.049.325.3
500k tokens50.738.051.338.0
1M tokens52.746.052.742.0
2M tokens55.352.752.742.0

Time budgets use modelled rather than measured time. GPT responses include network delays that vary from call to call, so to compare all methods fairly we charge each the same: simulator steps × 0.24 s, plus LLM time at a fixed single-request speed measured for Qwen on one dedicated H200 (8,000 input and 75 output tokens per second, plus 0.3 s per call).

Spotter is ahead at every finite budget, because Harness VLA consults the VLM at every step. With an unlimited budget the GPT systems tie, but Harness VLA needs 2.2× the time and 4.6× the tokens per successful episode.

We hope these results address your concerns, and we are happy to discuss further.

AuthorsOpenReview ↗

Follow-up: Additional Experiments Added

Dear Reviewer 338G,

We have added the relevant experiments and kindly ask you to take another look at our revised submission. We would be grateful to know whether these additions address your concerns.

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

This paper proposes Spotter, a framework for detecting and correcting failures in robot action policy at inference time without any parameter updates. The paper shows that existing robot policies struggle to recover from failures, even with multiple attempts, language feedback, or action selection methods.

Spotter is led by the robot action policy while taking advantage of expensive VLM judge when intervention is necessary. VLM monitors the actions in parallel to execution of action asynchronously so that the action execution does not have to wait for the screener. Only when the screener is triggered consecutively, then the expensive VLM judge takes corrective actions based on the execution history and a set of lesson libraries.

The method is evaluated with Cosmos Policy and pi0.5 on RoboCasa, RoboTwin 2.0, and a real robot. Spotter improves success rates by 5.6%-7.5% on RoboCasa, 9.8% on RoboTwin, and 30% on the real robot. Spotter also reduces the latency compared to a VLM-led framework on successful episodes.

Critical strengths
  1. Strong analysis on recovery from failures of existing embodied models, which establishes a strong problem identification and motivation.

  2. The method is training-free and intuitively makes sense.

  3. Parallel asynchronous design reduces expensive VLM calls, which allows the robot to keep executing actions and only intervene when necessary for correction.

  4. Experiments show substantial improvement across multiple policies, benchmarks, and real robot tasks.

Critical weaknesses
  1. There is no sufficient ablation study to understand the contribution of each component. It is unclear how much of the improvement comes from longer execution history or the reflection mechanism.

  2. The detection metric measures how often the baseline policy fails in episodes where Spotter intervenes but does not measure how many actual failures are detected. The paper does not report failure-detection recall, false-alarm rates, or detection delays.

  3. Qwen3.8 27B is used as the screener model. But if a smaller model is used as a screener model and the model fails to detect the failures, then it is unclear what effects that would have.

Questions for authors
  1. Could you provide ablations for the execution history and expectation checking to show how much each component contributed to the performance improvement?
  2. Can you report the failure-detection recall and false-alarm rate of Spotter to show how many actual failures are missed?
  3. Could you evaluate the model size effects on failure detection and success rate? How does Spotter perform with smaller screener models (3B, 7B)?
  4. Could you compare Spotter and Harness VLA under the same execution budget?
  5. Could you show results of free-form generation of VLM compared to retrieved general lessons?
4 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer 96gG (Part 1/2)

Dear Reviewer 96gG,

We sincerely thank you for the positive evaluation and the concrete suggestions. We added new experiments or analyses for each of them on RoboTwin 2.0 (Hard) with π0.5. Because of cost, the ablation experiments use GPT-6.1 as the judge instead of GPT-6 Astra used in the paper, and all new runs use a 150-episode subset of RoboTwin 2.0 that covers all 50 tasks (3 episodes per task). Within each comparison, every variant, including Spotter itself as the reference, runs on exactly the same episodes with the same judge. All additions are now in the revised PDF, marked in red.

W1 & Q1: Ablations of execution history and expectation checking

There is no sufficient ablation study to understand the contribution of each component. It is unclear how much of the improvement comes from longer execution history or the reflection mechanism. Could you provide ablations for the execution history and expectation checking to show how much each component contributed to the performance improvement?

Response: Table 3 changes one part of Spotter at a time (variants are defined in Appendix F.1), keeping the GPT-6.1 judge, primitives and step budget fixed. The ablations pause the policy during supervision, so we compare them with Spotter run the same way (58.3%).

Table 3 (Section 4.4 of the revised PDF). Matched comparison and ablations (RoboTwin 2.0 Hard, π0.5, GPT-6.1 judge)

SettingSuccessvs. synchronous
π0.5 alone50.7%−7.6
Spotter, asynchronous (as in the paper)56.7%−1.6
Spotter, synchronous (supervision pauses the policy)58.3%–
Synchronous, no screener (judge on every window)59.3%+1.0
No lesson library or retrieved example47.3%−11.0
No depth-based aiming58.0%−0.3
No execution history52.7%−5.6
No expectation checking56.0%−2.3

Execution history. The judge sees only the current window: no recap of earlier windows, no memo of earlier repairs, and telemetry of the current window only. Success falls from 58.3% to 52.7% (−5.6 points), close to the policy alone (50.7%): without the history, most of Spotter's gain over the policy is lost.

Expectation checking. After each repair, the judge states what it expects to see, and the next window is checked against this expectation. Without it, success falls from 58.3% to 56.0% (−2.3 points).

Q5: Free-form generation vs. retrieved general lessons

Could you show results of free-form generation of VLM compared to retrieved general lessons?

Response: Without the lesson library and the retrieved example, the judge generates repairs freely. Success falls from 58.3% to 47.3% (−11.0 points), below the policy alone (50.7%; Table 3). The retrieved lessons carry physical knowledge, such as grasping a long object in the middle rather than at an end, and without them the judge's repairs on RoboTwin do more harm than good.

Q4: Comparison with Harness VLA under the same execution budget

Could you compare Spotter and Harness VLA under the same execution budget?

Response: All methods already share the same step budget (1.8× the official limit). We further compare success under per-episode budgets of time and tokens on RoboTwin 2.0; an episode counts only if it succeeds within the budget, and each pair uses the same LLM. Unlike the ablations, which use GPT-6.1, these runs use GPT-6 Astra as in the paper.

Table 8 (Appendix F.2 of the revised PDF). Success rate (%) at matched budgets (RoboTwin 2.0, π0.5)

Budget per episodeSpotter (GPT-6 Astra)Harness VLA (GPT-6 Astra)Spotter (Qwen)Harness VLA (Qwen)
60 s43.310.038.08.7
120 s50.032.048.024.0
300 s52.046.051.335.3
100k tokens48.72.049.325.3
500k tokens50.738.051.338.0
1M tokens52.746.052.742.0
2M tokens55.352.752.742.0

Time budgets use modelled rather than measured time. GPT responses include network delays that vary from call to call, so to compare all methods fairly we charge each the same: simulator steps × 0.24 s, plus LLM time at a fixed single-request speed measured for Qwen on one dedicated H200 (8,000 input and 75 output tokens per second, plus 0.3 s per call).

At every finite budget Spotter is ahead of Harness VLA with the same LLM. With an unlimited budget the GPT systems tie, but Harness VLA needs 2.2× the time and 4.6× the tokens per successful episode.

AuthorsOpenReview ↗

Rebuttal to Reviewer 96gG (Part 2/2)

W2 & Q2: Failure-detection recall, false-alarm rate and detection delay

The detection metric measures how often the baseline policy fails in episodes where Spotter intervenes but does not measure how many actual failures are detected. The paper does not report failure-detection recall, false-alarm rates, or detection delays. Can you report the failure-detection recall and false-alarm rate of Spotter to show how many actual failures are missed?

Response: To measure detection directly, we ran Spotter on RoboTwin 2.0 with π0.5 in a monitor-only mode: it raises alarms as usual but never repairs, so each episode succeeds or fails on its own. We then checked the alarms against failure events logged by the simulator, which no model sees (missed grasp, dropped object, object off the table, stuck arm).

Table 9 (Appendix F.4 of the revised PDF). Failure detection by screener (RoboTwin 2.0, π0.5)

ScreenerFailures flagged by screenerNormal windows flagged by screenerFinal recallFinal false alarmsGPT calls per episode
Qwen3.8-27B (paper)90.0%26.7%82.2%2.6%10.1
Qwen2.5-VL-7B90.7%56.8%74.3%2.5%10.8
Qwen2.5-VL-3B98.8%100%78.6%2.5%15.1

The screener flags suspicious windows; the judge checks only these and decides whether to raise an alarm. Columns 2–3 show the screener alone (a failure counts if flagged within two windows); columns 4–5 show the final result after the judge (failed episodes with an alarm; successful episodes with an alarm). Detection columns: monitor-only runs, Qwen3.8-27B judge; GPT calls: full runs, GPT-6.1 judge. One window = 32 steps.

With the paper's screener, 90.0% of failures are flagged; after the judge, 82.2% of failed episodes raise an alarm and only 2.6% of successful ones do. The median alarm comes 1.5 windows after the failure (0.5 and 2.25 windows with the 7B and 3B screeners).

W3 & Q3: Smaller screener models

Qwen3.8 27B is used as the screener model. But if a smaller model is used as a screener model and the model fails to detect the failures, then it is unclear what effects that would have. Could you evaluate the model size effects on failure detection and success rate? How does Spotter perform with smaller screener models (3B, 7B)?

Response: We replaced the 27B screener with Qwen2.5-VL-7B and Qwen2.5-VL-3B (Qwen3.8 has no models at these sizes), keeping everything else fixed. The screener only decides when to call the judge; the judge decides whether to intervene. A smaller screener therefore mainly costs efficiency.

Detection (Table 9). Smaller screeners flag more of everything. They catch as many failures (90.7% and 98.8%, against 90.0%), but also flag many more normal windows (56.8% and 100%, against 26.7%); the 3B screener flags every window, i.e., it no longer filters. The judge rejects these extra flags, so false alarms stay at 2.5%. The lower final recall with the 7B screener (74.3%) is thus not caused by missed flags.

Success. With the 7B screener, success is 60.0%, against 58.3% with the 27B screener and 59.3% with no screener (Table 3). These differences are within random variation: whichever screener is used, GPT decides when to intervene. What a better screener saves is GPT calls on normal windows, and the 3B screener filters out none of them.

Cost. Extra flags mean extra GPT calls: per episode, 10.8 calls (604k tokens) with the 7B screener and 15.1 calls (801k tokens, about +50%) with the 3B screener, against 10.1 calls (541k tokens) with the 27B screener. The 7B screener is therefore a practical replacement.

We hope these additions address your questions, and we are happy to discuss further.

Reviewer_96gGOpenReview ↗

Rebuttal Acknowledgement

I thank the authors for the answers and new experiments. My main concerns were adequately addressed. I will maintain my positive score.

AuthorsOpenReview ↗

Response to Reviewer

Thank you for your recognition.

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

Most current embodied model does not know how to correct its own failures, or capture any intermediate failure in-time in an execution history. Existing work address this via a common agentic setting where an VLM serve as a reasoning brain and an action model serve as a tool to execute actions; The problem is the reasoning/reflection and action are still largely seperate, maining that the model still cannot early-stop and recover from an error while it is executing the action. This paper proposes Spotter, which is a parallel supervision mechanism that allows two VLMs to supervise execution in parallel and intervine on-time; A fast VLM flags error and a stronger VLM judges the flag, repairs and verifies the outcome.

Critical strengths
  • the parallel supervision design is techincally solid and novel; brining useful success-rate gain on multiple policies without substantial budget overheads;
  • the paper also did experiments beyond simulator which is a plus; supporting sim-to-real generalization
Critical weaknesses
  • some analysis in the Section 2 can be confusing; for example, the language-feedback correction does not work is using the embodied policy itself to generate the correction; while Spotter also uses language-feedback to choose corrective action and translates into primitive moves; the key difference is who is doing the heavy-lifting of generating the correction; so the wording of "language-feedback" won't work is quite misleading.

The key concern is, whether we are teaching the embodied policy to correct its failures; or we are essentially using a strong GPT-Astra model to do all the work; i.e., we can extend the Frontier VLM recovery pipeline to doing the entire task.

Questions for authors
  • how many remaining errors would attribute to the fast sceener? did you checked if we also use GPT as the Fast screener? would it improve performance or would the latency be not tolerable?
3 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer 4V9y

Dear Reviewer 4V9y,

We thank you for recognizing the parallel-supervision design and the real-robot results. We respond to each point below; all changes in the revised PDF are marked in red.

W1: Wording of the language-feedback analysis

Some analysis in the Section 2 can be confusing; for example, the language-feedback correction does not work is using the embodied policy itself to generate the correction; while Spotter also uses language-feedback to choose corrective action and translates into primitive moves; the key difference is who is doing the heavy-lifting of generating the correction; so the wording of "language-feedback" won't work is quite misleading.

We agree and have revised this analysis in Section 3.1. The point is not that language fails, but that current embodied models can hardly take in signals from their past interaction with the environment, in any form. A VLM can read the episode history, and language is its natural carrier. Spotter also uses language, but the correction is generated by the VLM.

W2: Whether GPT does all the work

The key concern is, whether we are teaching the embodied policy to correct its failures; or we are essentially using a strong GPT-Astra model to do all the work; i.e., we can extend the Frontier VLM recovery pipeline to doing the entire task.

Spotter does not train the embodied policy; the correction comes from the VLM, by design. Section 3.1 shows that current embodied models cannot reflect on their failures, so this ability has to come from a model that has it. The difficulty is that VLMs are slow. VLM-led systems such as Harness VLA let the VLM do the entire task, which puts it on the critical path, so its latency is paid at every step. Spotter is a paradigm built around latency and practicality: the policy keeps control, and the VLM steps in only when an error is confirmed. In a new comparison on RoboTwin 2.0 with π0.5 and the same GPT-6 Astra as in the paper (Figure 4, Section 4.3), Harness VLA reaches the same success as Spotter but needs 2.2× the time and 4.6× the tokens per successful episode; with Qwen, it even falls below the policy alone. Spotter thus keeps the benefit of the VLM at a latency much closer to practical deployment.

Q1 & Q2: Remaining failures due to the screener, and GPT as the screener

How many remaining errors would attribute to the fast screener?

Did you check if we also use GPT as the fast screener? Would it improve performance or would the latency be not tolerable?

Both questions are answered by the same experiment: removing the screener, so that GPT judges every window. This is the upper bound for a GPT screener, and it raises success by only 1.0 point on RoboTwin (59.3% vs 58.3%, with GPT-6.1 as the judge; Table 3, Section 4.4) and 2.0 points on RoboCasa, at 2.9× the tokens (Tables 1 and 2). At most 1–2 points of the remaining failures can therefore be attributed to the screener. An attribution of the failed episodes in the main RoboTwin run, with the GPT-6 Astra judge as in the paper, agrees: the screener, tuned for high recall (Section 3.2), forwarded windows of every failed episode to the judge; in 91% the judge intervened but the repair failed, and in the other 9% the judge saw the failure but declined to intervene. The remaining failures come mainly from repair (Table 11, Appendix F.5).

The gain from a GPT screener is thus small, but the latency gap is large: the embodied model generates an action chunk in about 100 ms, while a GPT call takes 4.3 s on average. By the time a verdict arrives, the policy is far past the chunk it judged, so a GPT screener cannot keep up in real time.

We hope these responses address your concerns and are happy to discuss further.

I thank the reviewers' response; I am keeping my already positive scores

AuthorsOpenReview ↗

Response to Reviewer

Thank you for your recognition.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.