- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
The paper proposes VEPA, a technique to evolve formal policy at runtime, based on feedback about failures. VEPA also determines the appropriate time to activate or deactivate a newly proposed formal policy rule, based on runtime evidence.
Critical strengths
The paper aims to tackle an interesting problem involving LLM agents and automatically evolving formal policies for agents. It also distinguishes between accepting newly generated formal policy rules and allowing them to take effect at runtime.
Critical weaknesses
The name of the technique (and the paper as a whole) claims that the evolution of formal policy is "verified", but Sec. 3 describes an approach to ensure that the LLM-proposed patch for the policy is checked to be "structurally valid, conflict-free, and performs well on the observed evidence". The proposed technique does not offer a guarantee of correctness with respect to the intended safety policy. Using the term "verification" to describe such an approach gives an impression of a rigorous proof of correctness that VEPA does not offer, especially in the context of formal policy enforcement and guardrails.
The paper refers to a set of failures as "examples that are handled incorrectly", but does not provide a clear definition of what it means to handle something incorrectly. Does a failure refer to only incorrect ALLOW verdicts? Does it include incorrect REFUSE verdicts? Or does it also include policies that abstained when an intervention was necessary? The paper does not adequately discuss the differences between the above kinds of errors and whether each of them need different fixing strategies, which makes it difficult to understand the problem being targeted.
It is not clear what guarantee the LLM-proposed patches are associated with (e.g., an LLM-proposed patch could fit the limited collected evidence perfectly well, while rewriting the policy into something significantly different from the true policy that must be enforced.) The expressivity of the DSL seems restricted; The rules seem to support only conjunctions of predicates and the operators "in" and "not_in". What if the failure is not expressible in the DSL? Does the framework repeatedly try to incorporate failures or recognize that something is not expressible after a few tries? A justification for the choice of DSL constructs would shed more light on the appropriate usage scenarios for VEPA.
VEPA takes in a labeled sequence of events to be given as input to propose candidate patches, but the paper does not discuss how realistic this prerequisite is, let alone suggest a technique for obtaining them. The paper presents evidence for sparse labelling settings, but it does not discuss how one should go about obtaining authoritative labels in any case.
The evaluation uses recorded pre-determined agent trajectories, which does not accurately match a realistic deployment, where a guardrail's actions would affect the trajectory of an agent. This evaluation setting, while useful, does not provide insight into VEPA's performance as a runtime technique. The authors mention that to maintain uniformity across different experimental settings, they make this choice. An alternative way to handle this would have been to use the guardrails at runtime, and repeat the experiments for statistical confidence measures.
The evaluation does not sufficiently justify the claims made earlier in the paper, e.g., long horizon. To evaluate the effectiveness of VEPA in a long horizon setting, one would use it on a long horizon task as a runtime guardrail, and learn new rules as the agent performs hundreds if not thousands of tool calls, and repeat experiments for statistical significance. But in the evaluation, the paper presents a larger version of the 10 deployment round experiment by scaling it up to 30 deployment rounds.
Questions for authors
-
How were the DSL constructs chosen? What class of failures can it capture (or not capture)?
-
What kinds of errors might the LLM-driven parser make (the parser that populates the trace with action information)? How often might such errors be observed in realistic deployments?
-
What would be the performance of VEPA in a runtime enforcement setting, where it is actively modifying the trajectory of an agent?
5 comments
Response to Reviewer XpgG [Part 2/3]
[Q2] Evaluation of the LLM parser
We add two analyses to evaluate the reliability of the LLM parser and the impact on downstream guardrail performance. These experiments with more detailed settings are presented in the new Section 5.3 of the updated PDF.
Parsing Accuracy. First, we evaluate structured event extraction using three stronger LLMs as independent reference judges: Gemini-3.1-Pro, Gemini-3.8-Flash, and Claude-Opus-5. Each judge receives the original agent trajectories and the same DSL schema as VEPA's parser (Gemini-3.1-Flash-Lite), and independently extracts structured events.
We report three metrics: Field Agreement, which measures agreement across all schema fields; Critical-Field Agreement, which measures agreement on fields whose values can affect formal-policy decisions; and Decision Agreement, which measures whether the parser and reference judge produce identical formal-policy decisions. We additionally construct a three-judge consensus through field-level majority voting.
| LLM Judge | Field Agree. (%) ↑ | Critical Agree. (%) ↑ | Decision Agree. (%) ↑ |
|---|---|---|---|
| Gemini-3.1-Pro | 94.2 | 94.6 | 97.8 |
| Gemini-3.8-Flash | 92.8 | 93.9 | 96.5 |
| Claude-Opus-5 | 93.7 | 92.5 | 97.6 |
| 3-Judge Consensus | 93.9 | 93.4 | 97.6 |
The table above shows that VEPA's lightweight parser achieves 92.8-94.2% field agreement and 92.5-94.6% critical-field agreement across the three independent judges. Moreover, decision agreement is 96.5-97.8%, showing that most field-level disagreements do not alter downstream formal-policy decisions. Agreement with the three-judge consensus is similarly high. The consistently high agreement across different reference models suggests that the lightweight parser provides a consistent and reliable structured representation for downstream formal-policy enforcement.
Robustness to Parsing Errors. Second, we study how parsing errors affect VEPA's end-to-end performance. We introduce controlled errors into structured events at rates of . For each nonzero error rate, we randomly select the corresponding fraction of events and replace one randomly selected policy-relevant field with a different valid value from its DSL vocabulary. This simulates incorrect attribute extraction while preserving the structural validity of event representations. We rerun the online deployment protocol with corrupted events with the same experimental settings.
| Parsing Error Rate | F1 ↑ |
|---|---|
| 0% | 0.86 ± 0.02 |
| 5% | 0.86 ± 0.04 |
| 10% | 0.85 ± 0.03 |
| 20% | 0.82 ± 0.04 |
Under moderate corruption (5%-10%), VEPA maintains comparable performance. Together with the high parser agreement in our experiment above, where field-level disagreement with independent LLM judges is below 8%, these results suggest that VEPA is relatively insensitive to moderate extraction errors. Even at a 20% corruption rate, performance decreases by only 0.04 F1.
Overall, these experiments show that (1) VEPA's lightweight parser achieves consistently high agreement with independent stronger LLM judges, particularly in downstream formal-policy decisions, and (2) VEPA's end-to-end performance remains stable under moderate upstream extraction errors.
Response to Reviewer XpgG [Part 3/3]
[W5 + Q3] VEPA in runtime enforcement setting
First, we note that our existing evaluation on recorded agent trajectories provides a controlled setting for studying guardrail adaptation. By evaluating different methods on the same agent events and ground-truth labels, we can directly compare their ability to learn from deployment feedback. Benchmarks such as ASSEBench and ATBench are also used in other guardrail works [8, 9].
To further strengthen the evaluation, following your suggestion, we conduct an additional runtime enforcement experiment on AgentDojo [10] under benign conditions and prompt-injection attacks. We use Gemini-3.8-Flash as the agent and follow the same guardrail configurations and adaptation protocol as our main experiments. Specifically, each guardrail checks every proposed tool call before execution. Allowed actions execute normally, while rejected actions are blocked and replaced with a tool-error message, after which the agent resumes with its existing history and can revise its actions or select alternative tools. We allow at most 10 execution-loop iterations per episode and repeat the evaluation across five runs, and reset the environment between executions. We compare our method with two strongest baselines (AGrail and LiSA).
We report three metrics: Benign Utility, which measures legitimate task completion without attacks; Utility under Attack, which measures legitimate task completion in attacked episodes; and Attack Success Rate (ASR), which measures the fraction of attacks that successfully achieve their objectives.
| Method | Benign Utility ↑ | Utility under Attack ↑ | ASR ↓ |
|---|---|---|---|
| AGrail | 90.8 ± 4.4 | 68.7 ± 5.3 | 12.5 ± 3.9 |
| LiSA | 87.1 ± 2.8 | 72.9 ± 4.1 | 3.2 ± 1.4 |
| VEPA (Ours) | 89.2 ± 3.2 | 78.4 ± 4.6 | 2.6 ± 1.2 |
The table above shows that VEPA achieves the highest utility under attack (78.4%), outperforming LiSA and AGrail by 5.5% and 9.7% respectively, while maintaining comparable benign utility. VEPA also achieves the lowest ASR of 2.6%, compared with 3.2% for LiSA and 12.5% for AGrail. These results show that VEPA remains effective when actively enforcing policies and modifying agent trajectories, preventing successful attacks while allowing agents to recover from blocked actions and continue legitimate tasks.
We present these experiments with more detailed settings in the new Section C.10 of the updated PDF.
[W6] Long-horizon setting
We would like to clarify that the long-horizon setting in our paper refers to longer deployment horizons, and not long-horizon agent tasks. We have made this explicit throughout the paper, including the introduction and experimental sections by using the term "longer deployment horizons". Studying longer deployment horizons is important because guardrails must maintain safety throughout deployment of agents while adapting to new risks that may emerge over time. This is a central motivation of VEPA and the primary focus of our long-horizon evaluation.
For long-horizon agent tasks involving hundreds or thousands of tool calls, VEPA can be applied at each action, since formal-policy enforcement operates on individual structured events. Therefore, the VEPA enforcement mechanism is not limited by the number of actions or tool calls in an agent task.
We hope our responses and additional experiments have addressed your comments and clarified the strengths of our approach.
References
[1] Miculicich, Lesly, et al. "Veriguard: Enhancing llm agent safety via verified code generation." arXiv preprint arXiv:2510.05156 (2025).
[2] Shi, Tianneng, et al. "Progent: Securing AI agents with privilege control." arXiv preprint arXiv:2504.11703 (2025).
[3] Bagdasarian, Eugene, et al. "Open and Emergent Problems in Agentic Privacy and Security: A Contextual Angle." (2026).
[4] Kim, Minbeom, et al. "LiSA: Lifelong Safety Adaptation via Conservative Policy Induction." NeurIPS 2026.
[5] Luo, Weidi, et al. "Agrail: A lifelong agent guardrail with effective and adaptive safety detection." ACL 2025.
[6] Pan, Melissa Z., et al. "Measuring agents in production." ICML 2026.
[7] Fanconi, Claudio, and Mihaela van der Schaar. "Cascaded language models for cost-effective human–ai decision-making." NeurIPS 2025.
[8] Zheng, Zhijie, et al. "StepGuard: Learning Step-Level Guardrails with Scalable Supervision and Safety–Utility Balancing." EMNLP 2026.
[9] Gu, Siyi, et al. "StepSafe: Learning Timely Intervention with Context-Aware Safety Reasoning." arXiv preprint arXiv:2610.20960 (2026).
[10] Debenedetti, Edoardo, et al. "Agentdojo: A dynamic environment to evaluate prompt injection attacks and defenses for llm agents." NeurIPS 2024.
Response to Reviewer XpgG [Part 1/3]
We thank the reviewer for the constructive and detailed review of our work. We are glad that you found the problem of automatically evolving formal policies for LLM agents interesting and recognized the importance of separating the acceptance of generated rules from their deployment authority. We provide the responses to your comments below.
We would like to clarify the meaning and importance of verification in VEPA. First, our use of "verified" follows the standard definition in formal methods, where verification involves mechanically checking whether an artifact satisfies explicitly specified properties. Specifically, VEPA formally verifies two properties: well-formedness under the DSL and conflict-freedom. We also note that previous work on formal agent guardrails uses verification in a similar sense [1, 2].
Second, we emphasize that resolving inconsistencies and conflicts in policy is especially an important problem for agentic security, as highlighted by recent work [3]. In our settings, this verification is also particularly important for evolving agent guardrails, where continually incorporating new rules based on deployment feedback can introduce policy conflicts and inconsistencies over time, potentially leading to policy regressions (we provide an analysis in Appendix C.2). Unlike natural-language policy approaches, which rely on LLM to make decisions and provide no effective ways for guaranteeing conflict-freedom, VEPA provides deterministic, mechanically checkable guarantees that these structural properties are preserved throughout policy evolution.
The failure set includes all three cases: (1) incorrect ALLOW (false negative), where the policy allows an unsafe action, (2) incorrect REFUSE (false positive), where the policy blocks a legitimate action, and (3) abstention, where the policy fails to provide a formal decision, including cases where an intervention is necessary. Specifically, in VEPA, an example is considered correctly handled only when the formal policy produces the ground-truth ALLOW or REFUSE decision. Otherwise, it is included in the failure set.
Our policy evolution framework aims to address all these failure types. The failure-repair objective encourages policy updates that correct wrong decisions and expand coverage, while the regression-avoidance objective preserves previously correct behavior. Different failures may require different policy revisions, such as adding rules to cover abstentions or refining existing rules to correct incorrect ALLOW/REFUSE decisions. We describe different operators in lines 229-233 of our manuscript.
Yes, your observation that “an LLM-proposed patch could fit the limited collected evidence perfectly well, while rewriting the policy into something significantly different from the true policy that must be enforced” is correct. This is why we formulate policy evolution as a constrained bi-objective optimization problem, balancing the repair of newly observed failures against regressions on previously correct examples. VEPA searches for policy updates that correct failures while preserving established behavior. Moreover, our evidence-aware authority mechanism only accepts rules with sufficient evidence that must be enforced.
Regarding your question on DSL, we construct our DSL based on contextual attributes relevant to agent safety and security, motivated by the contextual integrity framework and common properties of agent environments, including properties such as actions, data, and tools. Our DSL supports conjunctions of predicates, while multiple rules can express disjunctions, which allows it to capture safety and security requirements such as unauthorized access, data leakage, and unsafe tool use. In our paper, we focus on evolving formal policies within specified environments with the fixed event schema. Therefore, failures requiring new environment properties or previously unsupported tools may not be expressible within the current DSL. We acknowledge this limitation in Section F of our manuscript. We view extending VEPA to dynamically evolve the event schema and policy language as a potential direction for future work, and complementary to the policy-evolution problem studied in this paper.
We follow the deployment-feedback setting studied in prior adaptive guardrails, particularly LiSA [4], where users provide corrective feedback on guardrail decisions. Learning from corrective feedback is also studied in related work, such as AGrail [5], which studies adapting agent policies or safety checks from experience. Moreover, we believe that collecting user feedback and corrections is a common practice for deployed AI systems [6, 7].