- Rating
- 3
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
The paper asks how to make an LLM robot planner obey safety rules beyond reaching the goal, such as not grabbing a hot cup bare-handed. Given a PDDL model and formal rules, the method reweights each next token by the probability that the plan can still be finished safely, following each hypothetical action into the world it produces. This probability is computed exactly on a small HMM distilled from the LLM over action and object symbols, with the product of parser, rules and world explored lazily. Since the weight is positive exactly when a safe completion exists, one pass returns a safe plan whenever one exists within the horizon, and since it follows the LLM, the plan should stay close to the model's own choice. On DESPITE and a new set with temporal rules, an 8B model becomes safe on about 98% of tasks, against well under 30% for rejection sampling.
Critical strengths
The framing is clean and useful. Splitting the look-ahead into its support, which gives safety and completeness, and its size, which keeps the LLM's preferences, makes clear what each part of the method is for, and the link to shields and nonblocking supervisors is stated openly. The move to a symbol-level surrogate is also well motivated by a concrete case where a subword HMM badly misjudges two equally likely routes.
The experimental bookkeeping is careful. Held-out test tasks, an audit of the rule translation, paired tests, attribution of every failure, and the honest admission that a classical planner already solves almost every task when everything is formalized all make the results easy to trust.
Critical weaknesses
My main concern is that the part that is really new, using the size of the look-ahead to stay faithful to the LLM, is not isolated. The safety guarantee alone is what a shield gives, and a classical search over the same world and rules solves nearly every task in about a second. What would show the idea works is an ablation that samples from the LLM restricted to the exact safe support, with no HMM weighting, compared on preference following. Another natural baseline is to let the planner enumerate safe plans and have the LLM pick among them by likelihood.
The case for needing the LLM at all is also thin. It rests on a small preference study built from easy tasks with LLM-written phrasings, and on a text-only rule study where the guarantee no longer holds; the comparison to the target distribution uses only a few dozen selected instances. The local mask baseline fails because it lets the model start spelling an action that cannot be taken, which a standard mask over admissible action prefixes would avoid. Finally, the "about twice one generation" overhead comes from a sample whose mean compile time is about half the full-set mean, and scaling to larger worlds is untested.
Questions for authors
What preference-following rate do you get by sampling the LLM restricted to the exact safe support, without HMM weighting? This is the cleanest test of what the look-ahead magnitude buys.
How does the method compare with having the planner enumerate safe plans and the LLM rerank or sample among them, and with weighted rejection sampling or SMC at matched compute?
How does a mask over currently admissible action prefixes perform, and how many local-mask failures are real action-level dead ends rather than spelling dead ends?
What is the overhead over the full test sets, and how does compile time grow with the number of objects, plan length and rules?
Is the backward recursion computed in log space, and could numerical underflow turn a positive look-ahead into zero and break the completeness guarantee?
4 comments
Response to Reviewer N17C (2/3)
Q2: Planner enumeration, weighted rejection sampling, and SMC
A2: Following your suggestions, we compare GUARDCTRL with planner enumeration followed by LLM ranking or sampling, weighted rejection sampling, and SMC. GUARDCTRL solved 48 of the 61 main-set tasks where enumeration returned no candidate within the search budget (Table 2). On the 50 ablation tasks, GUARDCTRL solved all 50, compared with 33–40 for the tested weighted rejection sampling and SMC configurations. GUARDCTRL also had the lowest mean runtime per task (Table 3).
The planner enumerates safe plans up to two actions longer than the shortest plan. On the preference instances, the resulting lists contain both routes by construction and average 228 plans per instance. Selecting the most likely plan gives the preference-following rates in Table 2. Sampling from the same list in proportion to LLM likelihood yields P of 99.0% for explicit requests and 82.0% for implicit requests. On 33 D-Short and 28 D-Long tasks, the planner returned an empty list, so neither selection strategy could return a plan.
Table 2. Planner enumeration with LLM selection (Llama). P, plans listed, and runtime are measured on the 400 preference instances in Section 4.4. P is reported for explicit / implicit requests. The final two columns give results on D-Short / D-Long (500 tasks each).
| Method | Preference following P (%) ↑ | Plans listed per instance, mean (max) ↓ | Runtime (s), mean (median) ↓ | Safe success S (%) ↑ | Tasks with no listed plan ↓ |
|---|---|---|---|---|---|
| Enumeration + most likely plan (new) | 98.5 / 82.5 | 228 (3,604) | 22.1 (2.8) | 93.2 / 94.0 | 33 / 28 |
| GUARDCTRL | 93.0 / 81.5 | — | 8.5 (7.1) | 98.4 / 98.2 | — |
For the particle comparison, each method ran alone on one A40. Weighted rejection sampling draws independent paths using the action-prefix mask in A3. Increasing the particle count from three to ten solved seven more tasks and increased both runtime and sampled tokens. SMC resamples paths by weight. With five particles in this run, it solved 37 tasks to weighted rejection sampling’s 38. The weights reflect the LLM probability mass retained along a prefix. GUARDCTRL uses to estimate the chance of safe completion within the remaining token budget.
Table 3. Timed runs on the 50 Llama ablation tasks from Table 15 in our paper. Time covers setup through generation and excludes judging. Sampled tokens are summed over particles and averaged over tasks. Length is measured in actions over returned plans. All returned plans were safe.
| Method (particles) | Tasks solved ↑ | Time (s), mean (median) ↓ | Sampled tokens, mean ↓ | Length (actions), mean (median) |
|---|---|---|---|---|
| Weighted rejection sampling (3) | 33 | 11.7 (4.5) | 632 | 9.6 (8) |
| Weighted rejection sampling (5) | 38 | 14.1 (14.8) | 1,070 | 10.9 (8) |
| Weighted rejection sampling (10) | 40 | 18.1 (26.6) | 2,101 | 8.1 (7) |
| SMC (5) | 37 | 19.6 (5.2) | 816 | 10.3 (8) |
| GUARDCTRL (1 path) | 50 | 6.7 (4.7) | 41 | 7.2 (7) |
With ten particles, SMC also solved 37 of 50 tasks and returned no plan on the other 13. Its returned plans averaged 8.4 actions (median 8). We used one random seed and did not tune the SMC resampling parameters.
Response to Reviewer N17C (3/3)
Q3: Masking admissible action prefixes and causes of local-mask failures
A3: We agree that masking admissible action prefixes can provide a stronger local baseline. We therefore reran Llama on the 50 ablation tasks from Section 4.5 (25 D-Short and 25 D-Long) with a mask over currently admissible action prefixes, which increases safe completions from 0/50 to 27/50 but still underperforms GUARDCTRL's 50/50 (Table 4). The original mask’s “No plan” outcomes in Table 4 and Appendix Table 15 of our paper were all traced to blocked action prefixes in Appendix L.3, where all 50 failures were identified as spelling dead ends and none as action-level dead ends.
After (navigate_to_spill), the original mask lets Llama start (get_mop and blocks the closing parenthesis because the mop must be fetched in the storage area. The suggested mask blocks the first token that no longer matches any action allowed at the spill. This eliminated spelling dead ends. Of its 23 remaining failures, five had no applicable, permitted action with the goal or an obligation still unmet, and 18 reached the token limit. A1’s exact mask looks ahead to check whether an accepted completion remains reachable within the budget.
Table 4. Mask comparison on the 50 ablation tasks in Section 4.5 (Llama). The four outcome counts sum to 50 per row. A dash indicates an unreported length.
| Method | Safe completion (tasks) | Spelling dead end (tasks) | Action-level dead end (tasks) | Token limit reached (tasks) | Length (actions), mean (median) |
|---|---|---|---|---|---|
| Local mask | 0 | 50 | 0 | 0 | - |
| Action-prefix mask | 27 | 0 | 5 | 18 | 10.6 (8) |
| GUARDCTRL | 50 | 0 | 0 | 0 | 7.2 (7) |
Q4: Full-set runtime and scaling with task size
A4: We agree that the timing results should cover the full test sets, and we have now added runtime measurements for all 1,000 tasks (Table 5). Across all 1,000 tasks, GUARDCTRL averaged 13.6 s per task for Llama and 18.9 s for Qwen, including 10.7 s and 12.8 s for compilation, respectively (Table 5). The 50-task sample underestimated mean compilation time, but its median was within 0.1 s of the full-set median for both models. Mean runtime outside compilation was also similar across the two sets.
A few large reachable state graphs raise the full-set mean. Compilation accounts for the entire 5.6 s increase in mean end-to-end time for Llama and 6.0 s of the 6.6 s increase for Qwen. Median compilation time rises from 1.8 s in the smallest quarter of graphs to 34.7 s in the largest 5%. Larger graphs also have longer plans, so we cannot isolate the effect of plan length. Object counts vary too little to show a trend. Comparing rule counts across different tasks leaves the cost of adding a rule to a fixed task unmeasured.
Table 3 in our paper times one unconstrained generation on the 50-task sample (Llama 2.4 s, Qwen 2.6 s). We will clarify that “about twice one generation” describes Llama's extra cost on that sample. A full-set ratio requires the same baseline on all 1,000 tasks.
Table 5. GUARDCTRL time per task on one A40. Runtime is end-to-end time minus compilation time.
| Model and task set | Compilation (s), mean | Compilation (s), median | Runtime (s), mean | End-to-end (s), mean |
|---|---|---|---|---|
| Llama, 50-task sample | 5.1 | 3.5 | 2.9 | 8.0 |
| Llama, all 1,000 tasks | 10.7 | 3.5 | 2.9 | 13.6 |
| Qwen, 50-task sample | 6.8 | 4.4 | 5.5 | 12.3 |
| Qwen, all 1,000 tasks | 12.8 | 4.5 | 6.1 | 18.9 |
Q5: Numerical underflow in the look-ahead probabilities
A5: Numerical underflow is a valid concern for our implementation. The submitted backward recursion computes in probability space using double precision. If the only feasible next token has a positive that rounds to zero, the decoder can fail even when a valid plan exists.
However, returning no plan can sometimes be a good outcome. Suppose the only route to the goal requires action B immediately after action A. If the HMM assigns a vanishingly small probability to completing the task along this sole route, that low weight may reflect how rarely B follows A in the LLM-generated plans used for distillation. The learned weights can therefore act as a soft constraint on an action sequence that the explicit rules permit. If the consequences of executing B after A are poorly understood, it may be good to stop rather than recommend a plan that depends entirely on that sequence.
Thank you again for your insightful review. We will incorporate these new results and clarifications into the revised paper within 8 hours, with changes highlighted in blue.
We apologize again for the delayed response and for leaving you limited time to review these additions. We hope these results and analyses address your concerns, and we are happy to provide further clarification.
Best regards,
Authors of Submission 59705
Revision Uploaded: Follow-Up to Reviewer N17C
Dear Reviewer N17C,
Thank you again for your careful reading and detailed questions, and for your patience with our delayed response. We have revised the paper to incorporate the additional baseline comparisons, distributional analysis, full-set timing results, and clarification of the numerical limitations discussed in our responses. We have also added a table of contents for the appendices to make the relevant experiments, analyses, and clarifications easier to find. The table below lists where each of your concerns is addressed.
| Your comment | Revision | Location |
|---|---|---|
| W1 / Q1: What probabilistic weighting adds beyond exact safe support | Added an exact safe-support mask using the same parser, PDDL model, rule monitors, and horizon. The comparison reports safe success, preference following, plan length, and runtime. | Section 4.5 and Appendix M.1 |
| W1 / Q2: Planner enumeration followed by LLM ranking or sampling | Added both selection strategies and evaluated preference following and main-set performance. | Section 4.4 and Appendix M.4 |
| Q2: Weighted rejection sampling and SMC at matched compute | Added comparisons with weighted rejection sampling and SMC on the same 50 ablation tasks, reporting safe completions, plan lengths, and end-to-end runtimes under the same hardware and timing protocol. | Section 4.5 and Appendix M.4 |
| W2: Limited evidence for fidelity to the LLM’s distribution | Added complete-plan distribution comparisons on 16 tasks, using accepted LLM plans as the reference and reporting TV and KL divergence. We also measure variation between two reference samples and clarify that fidelity with the distilled HMM is empirical rather than guaranteed. | Section 3.4, Section 4.5, Section 6 and Appendix M.2 |
| W2: Scope of the evidence for needing the LLM | Expanded the comparison with planner-based alternatives and clarified when enumeration with LLM selection is a strong alternative. | Section 4.4, Section 6 and Appendix M.4 |
| W2 / Q3: Action-prefix masking and the causes of local-mask failures | Added a mask over currently admissible action prefixes. | Section 4.5, Appendix L.3 and Appendix M.4 |
| W2 / Q4: Whether the timing sample represents the full test sets | Added compilation and end-to-end timings over all 1,000 tasks. | Section 4.3 and Appendix M.8 |
| W2 / Q4: Scaling with objects, plan length, and rules | Added an analysis of compilation cost across reachable graph sizes. We explain why the available tasks do not isolate the effects of plan length, object count, or added rules, and explicitly acknowledge that scaling to larger worlds remains untested. | Section 6 and Appendix M.8 |
| Q5: Numerical underflow and the completeness guarantee | Clarified that the backward recursion uses probability-space double precision. Underflow can cause the decoder to return no plan on a solvable task, so the implementation’s completeness is limited by numerical precision. | Section 6 and Appendix C |
Thank you again for helping us strengthen the comparisons and clarify the scope of our claims. We would be happy to address any remaining questions.
Best regards,
The Authors of Submission 59705
Response to Reviewer N17C (1/3)
Dear Reviewer N17C,
We apologize for the delay in posting our detailed response and appreciate your patience. Thank you for your careful review and for recognizing the clear framing of our approach and the motivation for our symbol-level HMM, as well as the care and transparency of our experimental evaluation and reporting. Following your comments, we compare GUARDCTRL with an exact safe-support mask to assess preference following, plan length, and runtime (A1). Then we evaluate planner enumeration followed by LLM ranking or sampling, weighted rejection sampling, and SMC (A2), and test a mask over admissible action prefixes while analyzing the original local mask’s failures (A3). We also report runtime across all 1,000 test tasks and how compilation time varies with the number of reachable states (A4), and clarify the numerical implementation and how underflow can affect the completeness guarantee (A5). We provide detailed point-by-point responses below.
Q1: Preference following with exact safe-support masking
A1: We agree that comparing GUARDCTRL with an exact safe-support mask helps isolate the contribution of our probabilistic weighting. The clearest benefit is shorter plans: GUARDCTRL averages 6.6 actions, compared with 22.2 for the exact mask (Table 1). Both methods achieve comparable high safe success and preference following.
Both methods use the same parser, PDDL world, rule monitors, 512-token horizon, and temperature 1. Under the assumptions of Proposition 1, they allow the same tokens (see A5 for finite precision). Only GUARDCTRL weights them by estimated acceptance probabilities. Section 4.4 tests two routes for each of 100 easy tasks using LLM-written requests (200 explicit, 200 implicit). Both methods follow preferences more often than the instruction-blind planner.
The mask produced longer plans on 291 instances and shorter ones on 29, averaging 15.7 extra actions. GUARDCTRL's mean length is close to the 5.9 actions of accepted LLM plans. Five mask outputs of 86–98 actions timed out during checking and count as unverified failures in S. GUARDCTRL had the lower mean runtime and the mask the lower median.
Table 1. Safe success, preference following, length, and runtime on 400 preference instances (Llama, Section 4.4). Percentage pairs are explicit / implicit requests, with all 200 instances per phrasing in the denominator. S counts safe completions and P additionally requires the preferred action.
On the main benchmarks in Section 4.2, the mask averages 24.1 versus 7.1 actions for GUARDCTRL on D-Short, and 24.6 versus 7.4 on D-Long, with similar safe success (98.0% versus 98.4% and 97.0% versus 98.2%, respectively).
The mask puts the package down upstairs and picks it up again four times, adding eight actions. The binary mask leaves the LLM's relative probabilities unchanged among the allowed tokens, including the tokens for an extra put-down whenever a safe finish is still reachable. Thus, when termination is blocked, the model can take another allowed action, including a repeat that leaves enough tokens to finish.
GUARDCTRL weights those choices by their estimated probability of leading to an accepted plan. If the HMM estimates that having to pick up the package again reduces that probability, weighting makes the extra put-down less likely. The two trajectories illustrate how weighting can shorten plans even when the mask follows preferences well overall. We did not trace step-by-step probabilities for this instance. We will include these exact-mask comparisons in the revised main tables.