- Rating
- 1
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
The paper discusses how task completion is difference than "compliance", ie if an agent followed the correct procedure to get to its final answer or not. The authors propose a specification language based on first order LTL to encode compliance constraints. Given a task and its compliance constraints, the authors define a compliance score of an agent's tool call trace on this task as the fraction of satisfied constraints. The constraints are created with an autoformalization pipeline, beginning from the natural language task description, then an LLM creates a procedural graph, and from this the constraints are deterministically compiled. The authors then use this for two purposes. First, online harnessing of an agent trying to complete a task, with a guard blocking tool calls that would violate constraints. Second, the compliance score is used as a finetuning signal. The authors conduct experiments on their own specialized benchmark and a few others, and show that compliance differs from accuracy, their harnessing can improve compliance with small accuracy loss, and finetuning can transfer across benchmarks.
Critical strengths
-
The authors' specialized benchmark is generated programmatically (task descriptions, procedural graphs, constraints, correct solutions) with no LLM involved. This gives a good finetuning training setting, and the authors show that it can improve accuracy on other benchmarks.
-
The differentiation between compliance and accuracy is clear.
-
The constraint language is expressive and can capture temporal and provenance dependencies, while also being deterministically compilable from a graph.
-
The authors experiment with different finetuning rewards and harnessing enforcement settings, which is nice.
Critical weaknesses
-
The procedural graph is task specific, meaning that for each new task (ie benchmark question) one has to autoformalize a new one. This can be costly and impractical especially for online harnessing, since the autoformalization approach uses a multi-stage LLM pipeline. There is no latency or cost analysis for the autoformalization step. It would be important to report the time and cost (in tokens and LLM calls) of the method, and also of the compared baseline.
-
The compliance score is based on the same constraints that the online harness is enforcing, which may confound the results especially in the benchmarks where the constraints are LLM generated. As the authors mention, there is no guarantee that they are correct, but the paper does not analyse the robustness of the produced specifications. This is especially important when the task is not well specified ie if the natural language is a bit ambiguous or vague. I can think of several ways to improve this part of the paper. First, you could try multiple independent iterations of your autoformalization pipeline per task, to see how much the constraints vary per iteration. Second, you only tried one LLM for this, you should try at least one more LLM to see how much the results are translator-dependent. Third, try using the constraints of one autoformalization instance for the harness and the constraints from a different autoformalization instance for the evaluation.
-
The comparison with related work is not clear enough, mainly regarding runtime guards and NL-to-LTL, and the experiments lack meaningful baselines. The paper claims their novelty related to runtime guards is that "AgentLTL instead scores completed traces..." but it is also used for harnessing, so the authors should include a more detailed comparison with the other runtime guards they cite, especially Agent-C and AgentSpec, and potentially also [1,2]. The paper is not limited to harnessing but it is one of the main contributions so it should be properly differentiated. Further, while the authors cite some runtime guards, they only compare empirically with a single constraint-free guard and none of the more related ones. It would add to the paper to compare with more baselines in their experiments or explain why they are not applicable. Regarding NL-to-LTL, it would help to compare what types of constraints or tasks can be expressed by prior work and what does your language additionally cover or how it differs, otherwise why not use existing translation techniques? Finally, there is a recent benchmark for testing trace-level compliance using LLM-generated constraint-based rules that might be relevant to you on revision [3].
-
The compliance score being the fraction of satisfied constraints does not seem to be a very discriminative metric, or the choice of tasks are very easy for the models evaluated. The base models are very good to begin with (0.8+), and there is not much separation between different models and harnesses. The tables report no statistical uncertainty so it is unclear whether these differences are due to sampling noise. I suggest (i) reporting standard error in every table, (ii) do not average different models and benchmarks together in the main paper, just pick a few if there are space constraints, (iii) consider a binary compliance score where success means all constraints were satisfied, this makes more sense for evaluation, but keep your fine-grained fraction score for finetuning. I also suggest trying either weaker models or creating more difficult ProcFlow tasks.
[1] Hoover et al. "Dynaguard: A dynamic guardian model with user-defined policies", ICLR 2026
[2] Shi et al. "Progent: Securing AI Agents with Privilege Control", arXiv 2025
[3] Anand et al. "MANTRA: Synthesizing SMT-Validated Compliance Benchmarks for Tool-Using LLM Agents", arXiv 2026
Questions for authors
-
See weaknesses: cost analysis, autoformalization robustness, related work comparison, statistical uncertainty.
-
You say that sometimes the benchmark graders disagree with your specifications. How do you know if the graders are incorrect, and not your autoformalization was incorrect? Did you check? Can you include specific examples in the paper?
-
Can you report compliance scores on the other benchmarks after finetuning? Currently you only report accuracy. It would help to add compliance to substantiate claims of transferability.
-
how do you create the "finite domain of constants" mentioned in line 200? In the appendix you mention a domain extractor but can you explain how it works? Does it use an LLM?
-
How did you translate tau bench tasks into specifications? Since it includes user interactions, how do you use these user messages and any info that they give?
-
Is the FO-LTL language more expressive than the DAG? If yes, what kind of procedures or constraints cannot be expressed by your DAG? Could you give some insight on the limitations of its expressivity?
-
Several citations are incomplete (lacking venues or years). Please fix. For example tau^2 bench, GinSign, the LTLf citation.
-
You say compliance has limited effect on accuracy, but each of the enforcement settings reduces accuracy in some cases. Do you have any thoughts on how to choose between enforcement settings in new domains?
-
What is the difference between "at_call" and "on evidence"? Is there a particular benefit to separating these, since both are enforceable?
-
minor: you claim in 240 to have step-wise reward, but in your explanations the reward is only given at the end, not during the trace after each step, so please reword.
-
minor: define intervention-to-failure ratio in the main (line 372)
3 comments
(continued)
Q5: τ-bench. Each τ-bench task has a hidden instruction that the simulated user follows, for example: user id mia_li_3668, direct flight New York to Seattle on May 20, after 11am, cheapest, economy, 3 bags, no insurance. Induction reads this instruction, the domain policy (the agent's system prompt) and the tool schemas. It does not see the conversation, the gold actions or the reward; a test in our repository fails if it does. Using the instruction is allowed because the user states these goals to the agent during the conversation. The agent, however, learns them progressively, whereas the specification holds them from the start.
The model splits the instruction into steps, for example "search direct flights from NY to Seattle" and "book in economy with 3 bags." Code then builds the graph and the constraints: orderings (look up the user before booking), stated values (cabin, bags; checked to appear in the instruction), provenance (the booked flight id came from a search), and counts (book once). Compliance is computed on the agent's tool calls only; user messages are never scored. The simulated user is the same model as the agent.
Two limitations. Steps like "tell the user X" have no tool call, so they produce no constraints; 15 of 165 tasks have no constraints at all. These are excluded from the harness experiments, which is why the harness uses 150 τ-bench tasks and finetuning uses 165. Also, policy rules such as "confirm before booking" are mostly not yet turned into constraints. We will state both in the paper.
Q6: DAG vs. FO-LTLf. Yes, the language is more expressive than what we compile. The compiler emits presence, argument values, call counts, ordering, prohibition and provenance. The language can also express bounded response (WithinSteps), pairing obligations (every opened file is eventually closed), and conditions scoped by Until. Since the graph is acyclic, loops are captured only through call counts, so a rule like "repeat until the total reaches the target" is approximated, not enforced exactly. We will add this to the limitations.
Q7: Citations. We will fix them.
Q8: Choosing an enforcement mode. Each constraint has its own severity: log, warn or block (Section 3.4). The right mode depends on the task's constraints. Constraints on values stated in the prompt or fixed by the schema can block; constraints based on inferred dependencies should only warn. If one mode must be used for everything with induced specifications, we recommend block-and-warn, since it allows overrides. Per-constraint modes are supported but not evaluated in the paper, and we will say so.
Q9: at_call vs. on_evidence. An at_call constraint can be checked from the proposed call and earlier calls, for example a fixed argument value or a call-count limit. An on_evidence constraint needs an earlier result, for example "tool_c's argument must come from tool_a_list's output." The harness only checks it once that result exists, so it never blocks on something it cannot yet decide. We will clarify this in Section 3.4.
Q10–Q11. Agreed. We will write "per-constraint partial credit" instead of "step-wise reward," and define the intervention-to-failure ratio in the main text.
Thank you for your detailed response that addressed some of my questions. I will wait for the robustness results, the uncertainty estimates and compliance scores of finetuned models. However, I still have remaining concerns that I believe require non trivial effort to address, which I describe below.
The cost measurements and clarifications are helpful, but I suggest adding uncertainty estimates to the costs instead of only reporting averages or medians. Also, report the cost/latency of the reviewed baseline on all the benchmarks instead of just BFCL. I do agree that for offline evaluation, there is clear benefit to reusing the specification, but for online harnessing, each new task would require generating the specification and the cost/latency/performance is similar to the reviewed baseline in BFCL. It should be mentioned in the limitations that the amortization benefit of your method depends on reusing the same task and this limits its cost advantage in deployment. Further, you clarified that on tau-bench the specification generation uses the simulated user’s full hidden instruction, which is impossible in deployment. I appreciate your commitment to acknowledge this limitation, but I do find it important and think that the exact scope of the online harnessing setting should be made more clear in the paper.
Regarding specification correctness and interpretation of compliance on the benchmarks, I understand that it is not an issue on ProcFlow, but its tasks are abstract and do not represent realistic usecases. In the external benchmarks the issue remains and you acknowledge that disagreements could reflect either grader errors or specification errors. The planned robustness study is a useful first step and I will wait for its results, and for future versions consider evaluating compliance using independently constructed checks such as cross-model experiments or the MANTRA benchmark. Further, while releasing the specifications is helpful for transparency, the paper should include an assessment of their correctness rather than leave this to reviewers. Even a small audit of a representative sample would give some insight.
Regarding novelty and related work, you claim as your contribution that you use a specification for offline scoring, online gating and training. In this case, I believe it is important to compare against methods using alternative specification languages, since it is part of your contribution. AgentC, AgentSpec, Progent and DynaGuard all seem very relevant methods, and I strongly disagree that a comparison that depends on the quality of different specifications would be uninformative. Additionally, my question about how your specification language and translation pipeline differ qualitatively from prior NL-to-LTL approaches remains. Could existing specification languages also support offline/online scoring and training with minor adaptations? And does your translation express constraints that existing NL-to-LTL approaches cannot?
Thank you for a thorough review and concrete suggestions.
W1: Cost. We measured cost with Qwen3.6-27B on 30 tasks per benchmark.
Induction of the procedure graph runs once per task, offline, and the result is reused across all models and settings:
Enforcement makes no LLM calls beyond the agent's own retries after a block. One check takes 0.1–0.15 ms on BFCL and MedAgentBench, and 3.8 ms on average on τ-bench.
The Reviewed setting makes 3–9 LLM calls per episode. On BFCL, this is about 18k prompt tokens and 28 s per episode. This is similar to the cost of inducing one BFCL specification, but the Reviewed setting incurs this cost again for every episode, model and run, while induction is paid once per task.
W2: Robustness and circularity. Please see the general response. We will add a robustness study across repeated runs and different LLMs. Note that accuracy is always measured by each benchmark's own grader, which never sees the specification. Circularity therefore affects the external compliance numbers, not accuracy.
W3: Related work and baselines. We will expand Section 2. Agent-C defines temporal constraints in a DSL, checks them with SMT, and uses constrained decoding to replace a non-compliant tool call with a compliant one. AgentSpec enforces rules made of triggers, predicates and enforcement actions, written by hand or generated by an LLM. Progent restricts which tool calls an agent may make, using JSON-based privilege policies. DynaGuard is a guardian model that judges whether a conversation complies with user-defined policies. MANTRA generates trace-level compliance checks from procedural manuals and validates them against an independently generated world model using SMT; it is a benchmark-generation method, not an enforcement or training method.
The prefix-gating algorithm itself is standard and close to these runtime systems. Our claim concerns one specification shared across offline scoring, online gating and training. This includes constraints that cannot be enforced before execution, such as required calls, which we score offline and use as a reward. To our knowledge, none of the cited systems uses its specification as a training signal for the agent. The procedure graph is a supporting component: its role is to keep the LLM out of formula generation when we obtain specifications for existing benchmarks. We will also fix the sentence "instead scores completed traces," which is inaccurate given our own harness.
We did not run Agent-C or AgentSpec as baselines because each requires specifications written in its own language. A comparison would therefore measure the specifications as much as the mechanisms. We will state this in Section 4.2.
W4: Metric and uncertainty. We agree with all three suggestions. We will report binary full-compliance rates, standard errors over the three ProcFlow trials, and bootstrap confidence intervals on the external benchmarks. We will show per-model results in the main text instead of averages. The fraction score is compressed because easy constraints, such as literals stated in the prompt, make up much of the count; the binary metric addresses this.
Two existing results show that the signal discriminates when the specification is reliable. ProcFlow already separates models widely: accuracy ranges from 14.2% (Qwen3-4B) to 99.2% (DeepSeek), and compliance from .839 to .995 (Tables 11–12). On ProcFlow, a constraint is 9.5× more likely to be violated on a wrong episode than on a correct one, and only 1.26% of constraints are violated on correct episodes (Table 13). One family is an exception:
sourceis violated only on correct episodes (3.69%) and never blocks; we will discuss it in the appendix.Q2: Grader vs. induction errors. We did not verify this, and our text overstates it. Please see the general response. We will include examples in the appendix.
Q3: Compliance after finetuning. We will rescore the finetuned models' traces and report compliance alongside accuracy.
Q4: Domain of constants. The domain is extracted deterministically from the trace (tool names, arguments and returned values seen during execution), the constants of the specification and, where needed, the tool schemas. Quantification can be restricted with extractor functions, for example to the outputs of one tool. These extractors are written by hand. No LLM is involved. We will make this explicit in Section 3.2 and Appendix A.
(to be continued)