- 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
-
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.
-
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
-
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.
-
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.
-
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
-
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?
-
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?
-
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
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:
| Model | Q=5: PS-Full / random | Q=20: PS-Full / random |
|---|---|---|
| Qwen3-32B | 117/120 / 113/120 | 120/120 / 120/120 |
| DeepSeek-V4-Pro | 96/120 / 82/120 | 111/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.
Response to Reviewer EViz
We still appreciate your suggestions, and we will further supplement the main body of the paper based on your comments.
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:
Both preserve 468/468 originally safe, completed
Cleanoutputs 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.