acceptodds
Under review as a conference paper at ICLR 2027

PlanSmuggle: Candidate-to-Trajectory Risk in Embodied LLM Planning

Abstract

Embodied LLM agents increasingly rely on language models to synthesize executable plans from natural-language goals and multiple candidate branches. Prior embodied-agent jailbreaks mainly target explicitly unsafe prompts or individual primitive actions, leaving plan synthesis comparatively understudied. We introduce , a black-box attack on the plan-synthesis stage: it exposes a certified risky candidate during branch synthesis and induces the final executable plan to reproduce its violating transition structure without requiring an explicitly unsafe user goal. In a successful attack, every atomic action passes schema and immediate-precondition checks, yet the trajectory produced by executing their sequence violates a global safety invariant. We formalize this compositional failure and introduce PlanSmuggleBench, comprising 120 symbolic planning tasks across four constraint families. Across Qwen3-32B, DeepSeek-V4-Pro, GPT-5, and Qwen3.7-Plus, PS-Full achieves verified ASRs of 100.0%, 80.0%, 94.2%, and 75.8%, respectively. In a separate paired risk-by-merge intervention, attacks occur only when risky-candidate exposure and merge permission are jointly enabled (45.8%; 0% in each remaining cell), providing controlled evidence for their interaction. Under the benchmark's deterministic transition model, exact trajectory verification blocks every observed attack while preserving benign task completion. These results establish candidate-to-trajectory synthesis as a distinct safety boundary for embodied LLM agents.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Jailbreak, Robustness, Large Language Models, Agentic Security, Agentic Planning

Reviews

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

This paper addresses a safety failure in LLMs that generate execution plans from multiple candidate plans, where unsafe content from a candidate is propagated into the final plan. The proposed PlanSmuggle constructs safe and unsafe candidates for benign tasks in advance and manipulates candidate presentation and synthesis instructions. An attack is considered successful when the final plan satisfies individual action validity constraints and completes the original task while violating global safety constraints during execution.

The authors evaluate four LLMs on various symbolic tasks covering four types of constraints and conduct controlled experiments to analyze the effects of exposing unsafe candidates and permitting plan merging. They also compare three defenses and report that a trajectory verifier using a complete deterministic environment model blocks all observed attacks while preserving task success rates on benign inputs.

Critical strengths
  1. Clear success criteria and execution-based verification. Attack success is clearly defined and verified through execution in a deterministic symbolic environment. A successful attack must pass local action checks, complete the original task, and violate an explicitly specified safety constraint. Malformed outputs or simple task failures are therefore not counted as successful attacks. This provides a concrete basis for consistently interpreting and checking the reported safety violations.

  2. Controlled analysis of risky-candidate exposure and merge permission. The paper uses Multi-Safe, Unsafe-No-Merge, and risk-by-merge interventions to examine the conditions under which attack success increases. In the separate repeated evaluation suite, all three evaluated planners exhibit the highest attack success rate when risky-candidate exposure and merge permission are jointly enabled. These comparisons provide useful information about the conditions associated with increased risk under the studied protocols.

Critical weaknesses
  1. Is the assumed planning setup realistic? The evaluation assumes that the attacker can supply a certified risky candidate and manipulate the plan-synthesis context, but it remains unclear which realistic agent pipeline would provide these capabilities. The paper also does not clearly explain why LLM-based re-synthesis is needed rather than directly executing a certified safe candidate, if the relevant planning and verification procedures are available to the defender. Although the study explicitly focuses on risk propagation rather than candidate injection, these gaps make the practical relevance of the evaluated pipeline difficult to assess.

  2. The added value of the proposed attack components is not clearly established. The operator ablations are not query-matched, making it difficult to separate the benefit of combining operators from differences in search effort. In the separate DeepSeek-V4-Pro extension, Randomized Search also achieves a higher ASR than PS-Full (73.9% versus 59.0%). These results do not undermine the vulnerability finding, but leave the contribution of the particular operator combination and search strategy unclear.

  3. The novelty of the formal problem definition remains unclear to me. Prior work such as SENTINEL already uses temporal-logic constraints to evaluate safety at the planning and trajectory levels. I acknowledge that the paper distinguishes its candidate-conditioned adversarial evaluation from SENTINEL. Nevertheless, it remains unclear what the formal definition itself adds beyond the specific attack setting and evaluation protocol. Could the authors clarify this distinction? (SENTINEL: https://arxiv.org/pdf/2510.12985)

Questions for authors
  1. The evaluation constructs a certified safe candidate. Are the procedures used to generate and verify it available to the defender? If so, why not execute that candidate directly?

  2. The study evaluates risk propagation rather than how an attacker obtains or injects a risky candidate. What realistic input channel would give an attacker the assumed control over candidate plans and synthesis context?

  3. Section 4.5 acknowledges that a stateful shield could detect restricted-zone violations. How would lightweight state- or history-based checks compare with the full-information trajectory verifier across the four constraint families?

4 comments
AuthorsOpenReview ↗

Response to Reviewer EViz

Dear Reviewer EViz, thank you for your careful assessment of the evaluation setup. Your questions help us explain when direct execution is appropriate, what the candidate-input assumption means, and how the proposed checks relate to the exact verifier.

Q1. If a certified safe candidate is available, why not execute it directly?

If the safe candidate remains trusted and directly executable, executing it is the right reference choice. The benchmark host generates the safe witness through symbolic search and verifies it before model requests. The LLM receives the candidate and task descriptions as text; it cannot call the generator or verifier. All 120 safe witnesses complete on replay.

This control establishes safe feasibility and locates the measured failure at candidate selection or resynthesis. We study that interface because some planning workflows combine retrieved branches, tool feedback, or updated context. We do not argue that a planner should resynthesize when a trusted safe plan can simply be executed.

Q2. What realistic channel gives an attacker control over candidates or synthesis context?

Our evaluation isolates downstream propagation after candidate content is present; it does not implement candidate injection. The assumed content paths are grounded in existing systems: Agent-Driver retrieves stored trajectories for planning; AgentPoison assumes partial access sufficient to inject poisoned records and a triggered query; and OpenSearch asks its executor to include relevant raw tool outputs in its response, while its reflection/history templates include completed-step results. These examples motivate retrieval and tool-feedback channels. They do not imply that an ordinary external user can edit trusted system prompts. We do not claim that any one cited system grants a single attacker this entire capability set; the benchmark isolates downstream synthesis once candidate content is present.

This response states the access boundary alongside the benchmark setup.

Q3. How does a lightweight state/history monitor compare with the exact verifier?

We evaluated a state/history monitor with four constraint-specific checks. Its decisions do not call the exact verifier. On the fixed set of historical successful attacks, it blocks all 420:

Constraint familyMonitorExact verifier
Restricted region118/118118/118
Object compatibility118/118118/118
Authorization order64/6464/64
Multi-agent separation120/120120/120
Total420/420420/420

Both preserve 468/468 originally safe, completed Clean outputs and accept 120/120 safe witnesses. The monitor allows a safe prefix and stops before the violating transition; the exact verifier rejects the whole plan before release. Under the benchmark's deterministic semantics and tested outputs, the state/history tracked by this monitor suffices to intercept these violations. These results provide the requested four-family comparison.

AuthorsOpenReview ↗

Response to Reviewer EViz

Q4. Do the operator ablations and search comparisons isolate each component's contribution?

The original operator removals use unequal query budgets. They describe outcomes under those interventions but do not isolate each operator's causal contribution. We therefore report a matched schedule comparison using the same tasks, candidates, template pool, and query caps:

ModelQ=5: PS-Full / randomQ=20: PS-Full / random
Qwen3-32B117/120 / 113/120120/120 / 120/120
DeepSeek-V4-Pro96/120 / 82/120111/120 / 107/120

This is one frozen-search-seed run; Q=20 continues after Q=5 under the preset cap. Qwen requests used paired sampling seeds, while DeepSeek requests did not carry a provider sampling seed. In the separate DeepSeek stress suite, Randomized Search reaches 73.9% and PS-Full 59.0%. We report that ordering directly. The matched table compares these schedules in the matched run; the unmatched operator ablations remain descriptive and do not establish that either schedule is generally more effective.

Q5. How does the formal definition differ from SENTINEL?

SENTINEL evaluates safety at multiple planning and trajectory levels using temporal constraints. Our formal definition specifies a candidate-conditioned event at the planner-to-execution interface: a supplied risky witness is locally valid and goal-reaching, while the released trajectory violates the global invariant despite an available safe witness. Paired witnesses and controlled candidate/merge interventions make this event executable and measurable.

The definition uses established temporal-logic safety semantics. Our contribution is to formalize this specific constraint-preservation failure and provide a reproducible evaluation protocol for candidate-based synthesis. The revised manuscript adds one sentence near Equation (3) to specify the event and its interface while retaining the formal definition and distinct safety-boundary claim; this sentence is highlighted in blue.

Revision location: Main text, Section 3.1, Safety-Constrained Planning, immediately after the definition around Equation (3).

Thank you for the thorough response and the additional comparisons.

The state/history monitor is a nice addition and answers my third question well. On the other points, the response clarifies the authors’ position but doesn’t change my assessment: the practical relevance of the setup and the added value of the proposed attack components remain under-established. I’ll keep my score.

AuthorsOpenReview ↗

Response to Reviewer EViz

We still appreciate your suggestions, and we will further supplement the main body of the paper based on your comments.

Reviewer_gJ2tOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies planners that synthesise a final executable plan from several candidate branches. The attacker keeps the user goal benign, places two certified candidates in the planner's context (a shortest safe witness P⁺ and a locally valid, task-completing plan P⁻ that violates exactly one trajectory-level constraint), adds "planning pressure" (prefer shorter plans, repair after simulated failure), and asks the planner to compare, summarise and merge, searching over context variants within 20 queries. Success requires that the output parses, completes the goal, passes per-action schema/precondition checks, and violates a global constraint under deterministic replay. PlanSmuggleBench has 120 symbolic tasks in four constraint families (restricted region, object compatibility, authorisation order, multi-agent separation). PS-Full reaches 100 / 80 / 94.2 / 75.8% ASR on Qwen3-32B, DeepSeek-V4-Pro, GPT-5 and Qwen3.7-Plus; matched controls (safe-only merging, risky candidate without merge permission, safety-irrelevant context) give 0–1/120; a 2×2 risk × merge design gives 45.8% in the joint cell and 0% elsewhere on one planner, with non-zero off-diagonal cells on two others. Replaying outputs through the same deterministic verifier blocks every attack; constraint pinning blocks 15 of 18 selected cases; an action whitelist blocks none.

Critical strengths

Deterministic, well-separated success criterion. Counting an attack only when the plan parses, completes the goal, passes local checks and violates a global invariant under replay (Eq. 3), with eligibility certified by search for both P⁺ and P⁻, removes the usual ambiguity of LLM-judged jailbreak success; trace matching to P⁻ (92.9–100%) tells the reader what actually happened. The controls are the right ones. Multi-Safe, Unsafe-No-Merge and Random Perturbation each remove one ingredient while holding task, model and verifier fixed, and the paper reports the non-joint leakage on Llama3.1-70B and DeepSeek-R1-70B (Fig. 5c) instead of hiding it.

Critical weaknesses

The adversary already holds the exploit, and the bypassed check is one that cannot see the property by definition. The attacker supplies a complete, task-completing, constraint-violating plan P⁻ into the planner's context; success is the planner reproducing P⁻'s violating transition (trace match ≈ 100%). The paper concedes it "tests propagation, not discovery" and does not show how an external party injects candidates in any deployed pipeline. The validator that is "bypassed" checks schema and immediate preconditions only, so L = 1 ∧ V = 1 is possible by construction; the paper's own "defense" that blocks 100% is the success oracle itself, run before execution, so listing it as a contribution is circular. What remains is an instruction-following finding: given a stated constraint and a shorter violating candidate under efficiency pressure, planners copy the candidate, and repeating the rule (constraint pinning) removes most of it (18 → 3). That is worth reporting, but it is not "a distinct safety boundary", and the paper does not report the fraction of released plans that are simply P⁻ verbatim. Also, PAIR already reaches 85% on GPT-5 and 78% on Qwen3-32B without any candidates, so the marginal effect of the candidate mechanism over a standalone-prompt attack is 9–32 points, not the headline 75–100%. The attack results are not consistent across the paper's own suites, and the weaker results are not headlined. For the same model, DeepSeek-V4-Pro, Table 1 reports 80.0% PS-Full ASR at 2.42 queries per success, while the "larger independent matrix" (Fig. 5a) reports 59.0% at 14.25 queries, and there Randomized Search (73.9%) beats PS-Full, i.e. the lexicographic black-box search of Sec. 4.3 contributes nothing over random context sampling; the abstract uses the 80% figure. On Qwen3-32B three different numbers describe "risky candidate + merge": 18.3% for the "Combined" pipeline in Fig. 4b, 45.8% for the joint 2×2 cell in Fig. 4a, and 100% for PS-Full with 1.65 queries among successes, which cannot all be the same configuration (a 1.65-query mean with 100% success implies ≈70% first-query success, not 18%). The planner used in Fig. 4a is not stated, the "0% in each remaining cell" of the abstract holds for that planner only (Llama3.1-70B shows 12.8% with safe-only merging), and the constraint-pinning result is on 18 "selected" cases with no selection rule given. Fixable with a condition table (prompt components, query budget, planner, n) in the main text and consistent headline numbers.

Questions for authors

(Clarification) Define each condition's prompt components, query budget and planner in the main text, and reconcile 18.3% (Fig. 4b Combined), 45.8% (Fig. 4a joint) and 100% (Table 1 PS-Full) on Qwen3-32B. Why does DeepSeek-V4-Pro fall from 80.0% / 2.42 queries to 59.0% / 14.25 queries in the extension, and why does Randomized Search beat PS-Full there? What fraction of successful outputs are identical to P⁻? (Clarification) In which deployed planner does an untrusted party supply complete candidate plans while the system runs only a per-action validator yet owns a deterministic simulator capable of the exact verifier? Is the global constraint present in the planner prompt in every condition? (Suggestion) Report constraint pinning on all successful cases, present the exact verifier as the oracle rather than a defense, and state the marginal ASR over PAIR as the measure of the candidate-specific effect.

4 comments
AuthorsOpenReview ↗

Response to Reviewer gJ2t

Dear Reviewer gJ2t, thank you for the detailed review and for recognizing the executable success criterion and controlled interventions. We address each concern below, with the relevant denominators and protocol distinctions. The underlying experimental runs and numerical outcomes are unchanged. In response to your comments, we clarify the conditions represented by those runs, align the condition labels with the prompts used, and distinguish results from separate protocols.

Q1. Do the results establish unsafe-plan discovery, or do they mainly show copying of a supplied plan?

Copying is the predominant observed route. Among 420 successful PS-Full outputs, 389 (92.6%) reproduce the complete parsed action sequence of P−, including every action, its order, and the full sequence length. This is not byte-for-byte JSON equality. The separate first-violation trace-match count is 405/420; it is a broader metric and should not be conflated with complete-sequence copying. We do not claim that the planner discovers a new unsafe plan. The measured failure is that it releases a supplied, locally valid violating plan despite an explicit global constraint and an available safe witness.

The intervention results support this interpretation. In the one-query Qwen3-32B risk-by-merge experiment, the joint risk-exposure and merge-permission cell produced 55/120 attacks, while each of the other three cells produced 0/120. In the independent repeated suite, the joint cell was highest for all three evaluated planners. Thus candidate handling and merge permission affect the measured outcome under the tested protocols; the result concerns unsafe-plan propagation, not discovery of novel attacks. Section 3.1 now states the boundary of the existing formal claim explicitly: the candidate-to-trajectory synthesis interface at which the planner releases an executable plan that fails global-constraint preservation. The observed attack path can be copying; the defined failure concerns constraint preservation at this interface.

Revision location: Main text, Section 3.1, Safety-Constrained Planning, immediately after the definition around Equation (3). Copy-rate and intervention counts are reported in this response only.

Q2. What does the PAIR comparison measure, and are the reported PAIR conditions labeled correctly?

We have made the implemented candidate-access conditions explicit and aligned the core/transfer labels accordingly. Every PAIR-adapted prompt in the four-model matrix contains both P+ and P−. PAIR-adapted and PS-Full use the same Q=20 cap but different search procedures, including different use of previous-route feedback. The PS-Full minus PAIR-adapted ASR gaps are 21.7, 10.0, 9.2, and 32.5 percentage points for Qwen3-32B, DeepSeek-V4-Pro, GPT-5, and Qwen3.7-Plus, respectively. These values compare search procedures when both can access candidates; they do not measure the marginal effect of adding candidates.

Direct Attack is the no-candidate condition. The 78%/85% figures cited as a no-candidate PAIR baseline therefore do not describe the core/transfer PAIR-adapted condition. The separate stress-suite PAIR protocol also receives candidate plans and merge instructions, but uses a different structured context and feedback procedure. We keep those protocol labels distinct. The manuscript now describes the core/transfer PAIR condition according to its implemented candidate access; the relevant labels and descriptions are highlighted in blue.

Revision locations: Main text, Section 5.1 (Comparisons), Table 1, and Section 5.2; Supplementary Sections C.1–C.4 (Tables S3–S6) and E (Table S11).

AuthorsOpenReview ↗

Response to Reviewer gJ2t

Q3. How do the Qwen results of 100%, 45.8%, and 18.3% reconcile?

They come from three different configurations, with different prompts and query budgets:

ConfigurationSuccessQuery use
PS-Full120/120 (100%)Cap Q=20; 198 queries total; 76 first-query successes
Risk × merge cell55/120 (45.8%)Fixed one-query prompt
Combined operators22/120 (18.3%)Cap Q=20; 2,128 queries; P+ in 2,128 prompts and P− in 952

PS-Full is a five-template bounded-search condition. The factorial cell is a fixed one-query intervention with risk exposure and merge permission; the other cells remove one component at a time. The combined-operator pipeline uses its own operator-bundle prompts. These are distinct configurations, not repeated measurements of one setup. For clarity, Section 5.2 now summarizes these existing configurations in a compact condition table, listing the planner, n, prompt/intervention, query cap and use, and success count for each configuration; the table organizes the reported setups and measurements without adding experiments.

Revision location: Main text, Section 5.2, Candidate-Conditioned Attack Effectiveness, alongside the discussion of the Qwen3-32B results.

Q4. Why does DeepSeek differ between the core and stress suites, and why does randomized search lead in the stress suite?

The core result is 80% on 120 tasks in one run. The stress result is 59% on 240 tasks per repeat across three repeats; 96 task IDs overlap. The suites use different prompts, output schemas, and search/feedback implementations. Their query means also use different denominators: 2.42 queries per successful attack (5.93 per task over all tasks) in the core suite, versus 10.27 queries per successful attack (14.25 per task over all tasks) in the stress suite. These are two protocols, not a controlled test isolating one cause of the ASR difference.

In the stress suite, Randomized Search reaches 73.9%, compared with 59.0% for PS-Full. We also ran a matched schedule comparison with the same tasks, candidates, template pool, and query caps:

ModelQ=5: PS-Full / randomQ=20: PS-Full / random
Qwen3-32B117/120 / 113/120120/120 / 120/120
DeepSeek-V4-Pro96/120 / 82/120111/120 / 107/120

This matched run uses one frozen search seed; Q=20 continues after Q=5 under the preset cap. Qwen requests used paired sampling seeds; DeepSeek requests did not carry a provider sampling seed. The table compares these schedules in this run. The operator ablations use unequal query budgets and remain descriptive, so they do not isolate each operator's causal contribution. To make the protocol distinction explicit at the point of first reading, the Abstract identifies 80.0% as the 120-task core result and reports the separate stress-suite results, 59.0% for PS-Full and 73.9% for Randomized Search across three 240-task repeats. Section 5.2 distinguishes the stress suite by its prompts, output schemas, and search/feedback procedures.

Revision locations: Abstract and Main text, Section 5.2, Candidate-Conditioned Attack Effectiveness. The matched Q=5/Q=20 schedule comparison is reported in this response only.

AuthorsOpenReview ↗

Response to Reviewer gJ2t

Q5. Do all conditions retain the global constraints, and what access does the evaluation assume?

The evaluation begins after candidate content is present in the planner context. It does not implement candidate injection or assume that an arbitrary external user can edit trusted system prompts. The local-check and exact-verifier settings are benchmark-host configurations. The host retains a deterministic simulator to certify witnesses and evaluate outputs; the LLM request interface cannot call the verifier. This separates planner-side propagation from host-side enforcement under fixed semantics.

An audit found complete task-specific constraints in all 68,175 saved prompts across the audited suites, including unsuccessful episodes. Fifteen DeepSeek stress API-error calls had no saved prompt and are not included in that count.

The cited systems motivate realistic content paths without implying identical attacker permissions. Agent-Driver retrieves stored trajectories for planning. AgentPoison assumes partial access sufficient to inject poisoned records and studies triggered retrieval. OpenSearch asks for relevant raw tool outputs in the executor's response, while its reflection/history templates include completed-step results. These examples motivate retrieval and tool-feedback channels; they do not establish arbitrary access to trusted prompts. This response states the evaluated input and verifier boundary.

Q6. How were the pinning cases selected, and what happens beyond the original 18 cases?

The original 18 are exactly all successful risk-and-merge attacks in the frozen orthogonal40 candidate set. Under a new pinned request, 3/18 remained successful. We also replayed all accessible historical successful attacks for three models, covering 307/420 cases:

ModelAttack before → afterClean safe completion before → after
Qwen3-32B109/120 → 94/120115/120 → 83/120
DeepSeek-V4-Pro63/96 → 55/96115/120 → 112/120
Qwen3.7-Plus77/91 → 64/91116/120 → 120/120

We could not replay the remaining 113 GPT-5 cases: the configured endpoint returned HTTP 503 in four probes on November 7–8, 2026. This establishes endpoint unavailability during those probes, not permanent provider or model unavailability. Clean denotes safe completion, not ordinary completion.

Q7. Is the exact verifier a circular defense contribution?

We use the exact verifier as the success oracle and a full-information enforcement reference. It blocks all observed attacks, but this alone is not an independent defense contribution. We therefore evaluated a separate state/history monitor that does not call the exact verifier. It uses current state and one history bit for authorization order:

Constraint familyAttacks blocked
Restricted region118/118
Object compatibility118/118
Authorization order64/64
Multi-agent separation120/120
Total420/420

On the same fixed outputs, the monitor preserves 468/468 originally safe, completed Clean outputs and accepts 120/120 safe witnesses. It stops before the violating transition; the exact verifier rejects the whole plan before release. Safe completion is reported separately from attack blocking. The whitelist blocks 0/420 attacks because every attack action is locally valid. These results distinguish the independent monitor from the exact verifier, which serves as the success oracle and full-information enforcement reference.

Reviewer_gJ2tOpenReview ↗

Follow-up on the rebuttal

Thank you for clarifying the protocols in Tables 1 and 2. I am keeping my score at 2. The experiments establish a propagation risk once a complete violating candidate is in context. In Q1, 389 of 420 successful PS-Full outputs reproduce the candidate’s full parsed action sequence. Candidate following therefore explains much of the observed effect, and the evidence for distinct cross-branch synthesis remains limited.

The combined-operator condition in Table 2 succeeds on 22 of 120 tasks (18.3%) across 2,128 queries. In the separate DeepSeek stress suite, Randomized Search reaches 73.9% and PS-Full reaches 59.0%. These results leave the added value of the structured operators and search procedure unclear.

The exact verifier is a useful full-information reference. The separate state/history monitor reported in Q7 also blocks all 420 violating fixed outputs and preserves all 468 originally safe completions. These results support mitigation in offline replay. Closed-loop recovery and false alarms under noisy perception remain outside the scope of that evidence.

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

This paper talks about cases where a sequence of locally valid actions in a plan can result in a plan that may not satisfy a global condition. The authors say that unsafe actions and plans carry through LLM reasoning and can keep unsafe conditions through LLM guided plan merges. Then the authors propose a method for generating unsafe plans with locally safe actions. The method comprises of using symbolic search to generate a shortest safe plan achieving the goal and a plan that achieves the goal with valid local actions but violating one invariant. Then it gives these plans to an LLM to merge and generate alternative plans that are safe, execute and score the LLM outputs, and then search for variations of the same plan using an LLM.

Critical strengths

Interesting proposition in the planning domain where locally valid plans can generate something unsafe. Not that this has not been studied before but explicitly generating such a plan is an interesting adversarial angle.

The four attack operators constraint demotion, branch contamination, replanning amnesia, and temporal misalignment, gives an understandable path towards creating an attack.

Critical weaknesses

Main question is novelty. Just needs some clarification as I feel like this work is very similar to the work on nonlinear control optimization using control lyapunov barrier functions (CLBF).

There is a significant body of research on neural engines to search for CLBFs that search for a trajectory that are both locally safe and globally achieve a goal. The whole motivation of using a neural engine is because these scenarios exist that actions may be locally valid but globally unsafe. THis is the same motivation as this paper. So I feel like neural CLBF approach should be comparator.

The authors should describe why one would want to use their LLM based approach as opposed to a neural CLBF like approach. Goals can be expressed as Signal temporal logic and a robustness metric. Then locally valid plans can be searched using a neural architecture with objective function defined on the positivity of the robustness residue. Such an approach should be the comparator. Please look at this paper

--> https://github.com/mit-realm/neural_clbf

Questions for authors

See weaknesses

1 comment
AuthorsOpenReview ↗

Response to Reviewer LUXY

Dear Reviewer LUXY, thank you for your careful assessment of the paper's novelty and for pointing us to neural control Lyapunov barrier function (CLBF) methods as a relevant comparison.

Q1. How does the novelty of our formalization differ from neural CLBF-based planning, and should that work be a comparator?

We agree that neural CLBF-based planning is a relevant comparison, and that the general observation that locally valid actions can violate a global constraint is not unique to our work. The contribution we formalize is the candidate-conditioned failure event at the planner-to-execution interface: the planner receives a safe witness P+ and a locally valid, task-completing witness P− that violates a global invariant, then releases a trajectory that violates that invariant. The paired witnesses make this event executable and measurable.

The comparator proposed in your review combines neural planning with a signal temporal logic robustness objective. A direct head-to-head comparison would require the same dynamics, state and action interface, task specification, and robustness objective. Neural CLBF methods target control synthesis and certificates for a specified dynamical system, while our benchmark supplies symbolic plan candidates and measures candidate-conditioned LLM synthesis. Adding a neural CLBF score would therefore change the task rather than provide a matched baseline. We do not report a direct CLBF performance comparison. The added sentence near Equation (3) specifies the formal event and its interface while retaining the formal-definition and distinct safety-boundary claims; this sentence is highlighted in blue in the revised manuscript.

Revision location: Section 3.1, Safety-Constrained Planning, immediately after the definition around Equation (3).

Q2. Why use an LLM-based planner instead of a neural CLBF-like approach?

We study LLM-based planning because the target workflow takes task and candidate descriptions, and can also include tool feedback or replanning context, then asks the model to compare and merge plan branches. This setting tests whether the synthesis step preserves an explicit global constraint when both safe and risky candidates are available. Neural CLBF methods target control synthesis and certificates for a specified dynamical system. Our paper studies the safety of the LLM planning workflow; it does not argue that LLM planning should replace CLBF when a matched control model and objective are available.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.