- Rating
- 3
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper is motivated by the observation that existing guardrails cannot express complex relational requirements over the application's database, and proposes a principled way to synthesize those restrictions automatically. It then formulates the maximally permissive shield problem, and propose two synthesis procedures for it. The implementation RelShield runs symbolic synthesis first and falls back to finite synthesis when stabilization is not certified within budget. The evaluation shows that RelShield constructs 78.0% successful synthesis.
Critical strengths
-
The paper is generally well-written.
-
The paper formulates the problem in a theoretical and clear way, and the provided theorems seem correct to me. The fixed-point characterization is a natural generalization of classical safety-game shielding to the relational, data-dependent, nondeterministic-outcome setting.
-
Experimental evaluations show the effectiveness of the proposed method.
Critical weaknesses
A more direct motivation example would be helpful. The motivation would benefit from a concrete case where an existing guardrail would silently fail on a relational requirement rather than merely being inconvenient to write.
The manual effort and the practical deployment are not discussed. The paper does not quantify the manual effort of deploying the proposed solution. To use RelShield, a developer must produce a first-order relational specification of the tool interface, the tool effects, the initial states, and the requirement. This is a substantial modeling effort, and the paper does not quantify it.
The empirical evaluation does not yet exercise the paper's most interesting capability. The fix-point characterization (safety-continuation reasoning beyond one step) is the most interesting capability of the proposed method. However, it is only triggered by the hand-constructed extensions.
The comparison with existing guardrails is indirect. The paper argues that existing guardrails cannot express relational requirements, which is true, but it does not run a concrete guardrail on the same instances to show that they fail, especially considering that the current formulation is restricted to closed first-order sentences over the relational schema.
Questions for authors
-
Can you report the specification effort per environment (lines of specification, number of relations, number of tools)?
-
What fraction of the natural-language policies in the studied benchmark is expressible in your closed first-order fragment? What falls outside?
Response to Reviewer Bcik
Thank you for the positive assessment, and for finding the formulation clear and the paper well written. We have uploaded a revised manuscript with changes marked in blue. Table and appendix numbers below refer to this version.
W1 (Motivating example):
Agreed. In Figure 1, a trace-level guardrail can wrongly allow
resume_line(C1001,L1004)if the agent never read C1001's bills, if a billing service marked bill B7 overdue after the agent read it, or if its supplied state view is incomplete. RelShield avoids these problems by operating directly over the database state. It also blocks the call while B7 is only past due, since the billing service can still mark it overdue (App. D.1). The revised introduction now makes this examples clear.W2 (Manual Effort):
We agree that formalizing accurate tool specifications requires effort. Formal guarantees need such specifications, as in data-aware verification and formal guardrails such as Agent-C and FORGE.
W3 (No empirical evidence for fixed point reasoning):
We respectfully disagree that this is the case. As you correctly observed, the controlled extensions in the empirical evaluation do require shields where S⋆⊊S1. This is also the case for a main-census instance in our new ablation without state-preserving calls (Table 16). Fixed point reasoning is the theoretical backbone that guarantees that the shields that RelShield synthesises are correct and maximally permissive. It is also what establishes whether S⋆=S1, so every instance exercises it.
W4 (Comparison with existing guardrails):
We respectfully disagree that running another one would be informative. Formal guardrails such as Agent-C and FORGE enforce already-supplied operational restrictions. Supplying RelShield’s synthesized guards would test enforcement, not synthesis. But once the guards are supplied, enforcement becomes the check RelShield already does before each call, which is guaranteed to be correct. GuardAgent and other LLM-based guardrails take textual policy descriptions as inputs, so they can fail by misinterpreting the requirements. Our LLM baselines instead receive RelShield’s formal inputs, so the comparison is fairer and tests synthesis alone.
Q1 (Specification effort per environment):
The benchmark models use 3,895 specification lines. The controlled extensions add 122, giving 4,017 in total. The 32 requirements account for 642 lines (about 20 each). Relation/tool ranges cover the different configurations.
Q2 (Benchmark requirements expressible in our fragment):
Only τ2-bench gives the agent written policies. For τ2-bench's Airline and Telecom policies, our fragment expresses 17 of the 57 clauses that the agent's tools can violate (30%). The other 40 depend on the dialogue or on information unavailable through tools, require complex arithmetic, or impose obligations without a deadline. For Banking, we formalised only the clauses governing the modelled tools. For AppWorld and WorkBench, we derive requirements from schemas and code (Section 5.1).