acceptodds
Under review as a conference paper at ICLR 2027

ACORN: Compliant and Efficient LLM Agents via Contract-Based Symbolic Control

Abstract

Large language model (LLM) agents augmented by tools are increasingly deployed to execute standard operating procedures (SOPs), acting on external systems through tool calls. However, prompt-based guidance leaves compliance to the model, while blocking guardrails may lead to repeatedly rejected actions without advancing the task. In addition, when the SOP rules are sufficient to already determine the next call, querying the model only adds error and cost. We present ACORN (Agentic COntract-based Runtime coNtrol), an agent framework that leverages contract-based symbolic control to address these challenges. The required behaviors are formalized as assume-guarantee (A/G) contracts in linear temporal logic on finite traces (LTLf) over the agent's tool-call trace, i.e., the sequence of tool calls and returns. The contracts are compiled to deterministic finite automata (DFAs). Given the fixed tool set of an agent session, the framework uses the DFAs before each tool call to select the subset of tools that the contracts currently permit and exposes it to the model. When the subset leaves only one possible call, the call is executed without consulting the model. Any tool call that would violate a contract or leave some contract impossible to satisfy is blocked. Each selected subset of tools is cached and reused in later sessions, whenever they reach the same DFA states and recorded values. On ten SOP-Bench domains, ACORN commits no procedural violation, improves macro task success by 23.1 percentage points, and reduces estimated cost by 62%. On two τ²-bench domains, it improves pass^4 by 15.0 points on average.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
LLM Agents, Assume-Guarantee Contracts, Procedural Compliance, Neuro-Symbolic AI, Symbolic Control

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_hg4iOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents ACORN, a contract-based runtime control framework for LLM agents executing standard operating procedures (SOPs) through tool calls. To address the limitations of prompt-based guidance and passive guardrails, ACORN formalizes procedural requirements as contracts in finite-trace temporal logic (LTLf) and compiles them into deterministic finite automata (DFAs). Based on the resulting control states, ACORN introduces three mechanisms: dynamic tool masking, which restricts the tools exposed to the LLM; contract-based fast-forward, which executes tool calls without invoking the LLM when the tool and its arguments are determined; and runtime verification, which blocks actions that violate contracts or make future contract satisfaction impossible. Experiments demonstrate improvements in task success and efficiency.

Critical strengths

A key strength of this paper is its integration of formal contract enforcement with proactive agent execution control. ACORN leverages temporal contract library to dynamically restrict tool availability and directly execute contract-determined tool calls without invoking the LLM. This provides a mechanism for reducing unnecessary model decisions while retaining the flexibility of LLM-based reasoning when the next action is not fully determined.

Critical weaknesses

A major concern is whether the use of LLM agents is sufficiently justified in the framework. ACORN formalizes SOPs into symbolic contracts and directly executes tool calls when the next action and its arguments can be determined by these contracts. This raises a fundamental question: if procedural rules already determine much of the execution, why is an LLM agent needed instead of a rule-based engine? For example, Figure 3 shows that eight of nine steps can bypass the LLM, while Table 1 reports that 89% of tool calls in the Know Your Business domain are executed without LLM involvement. In these cases a rule-based engine may be used to process these requests instead of an LLM agent. Therefore, it remains unclear what additional value the LLM agent provides.

Another concern is that the τ^2-bench comparison about baseline parity and attribution. The authors’ empty-library shell already increases pass4 from 31.6% (official LLM Agent) to 37.7% and reduces the reported violation rate from 37.3% to 0%, despite having no policy contracts. ACORN then improves pass4 only marginally over this shell (39.5% vs 37.7%). This suggests that differences in the agent wrapper, tool handling, or evaluation interface may account for a substantial portion of the reported gains. The authors are encouraged to investigate this discrepancy, provide implementation-level comparisons, and emphasize shell-relative improvements with statistical uncertainty when assessing the contribution of contract-based control.

Questions for authors

Q1. Figure 3 shows that ACORN executes eight of nine tool calls without the LLM, and Table 1 reports an 89% fast-forward rate for Know Your Business. Could the authors clarify which remaining decisions require capabilities that a purely rule-based workflow engine cannot provide? A comparison against a rule-based controller using the same contracts, or a breakdown of success on tasks requiring LLM reasoning versus fully specified workflows, would help establish the incremental value of the LLM. Q2. In Table 2, the empty-library shell has a 0.0% violation rate on τ²-retail, compared with 37.3% for the official LLMAgent, despite having no policy contracts; the corresponding shell violation rate on τ²-airline is 21.0%. Could the authors explain this discrepancy and confirm that the same policy-grounded audit was applied to all conditions? In particular, does the retail result reflect differences in agent behavior, in the evaluation wrapper, or in how violations are counted? Q3. In Table 2, the empty-library shell already improves pass4 on τ^2-retail from 31.6% to 37.7%, while ACORN achieves 39.5%. Could the authors clarify what accounts for the improvement introduced by the empty-library shell and to what extent the additional gains can be attributed to contract-based control? A more detailed comparison of the implementation differences and shell-relative improvements would help isolate the contribution of the proposed method.

2 comments
AuthorsOpenReview ↗

W1 and Q1: Why the LLM is still needed

Thank you for the careful reading and the precise questions. We have revised the submission PDF, and the changes are marked in blue.

A rule-based engine can execute only the steps whose tool and arguments the contracts determine, and the results in the paper already show that these are a minority. Figure 3 and Know Your Business are the most fast-forwarded cases, and across the ten SOP-Bench domains 31% of tool calls run without the model (Table 1). At every other step several tools are admissible, or an argument must be read from the task text or the dialogue, such as an account ID or an inspection note, and the model chooses the call (Section 1). Know Your Business shows this as well. It has the lowest TSR (55.6%) despite 89% fast-forwarded calls, because its last step is the verdict on the business (approve, escalate, or await information), which the SOP leaves to human experience (Section 4.1). Fast-forward itself is a prediction backed by verification. The predicted call is still verified before execution, and if verification rejects it, the model decides that step (Section 3.4).

The revision adds the comparison you suggest in Q1. We removed the model and kept the same contracts, argument maps and controller (Section 4.1, Table 2). This rule-only controller completes 5 of 1,474 SOP-Bench tasks (0.2%), against 94.5% for ACORN. In nine domains it stops at the first call, whose arguments come from the task text, and in Know Your Business it executes the 8 verification calls and stops at this verdict. Reading a value from free text and making a judgment that the SOP leaves open are the steps a rule engine cannot take, where LLM is still needed.

AuthorsOpenReview ↗

W2, Q2 and Q3: The agent shell on τ²-bench and attributing the gain

We agree that on retail the gain over the official agent comes mostly from the shell, which is our agent loop without any contract, and the contracts account for the gain on airline. The revision reports the numbers relative to the shell (Section 4.2).

Q2. The same policy-grounded audit is applied to all conditions, by replaying the same policy contracts over the saved conversations. The retail difference comes from the agent loop. The shell uses the official prompt, temperature and model, and it differs from the official agent only in that each turn is either a message to the user or a set of tool calls. The official agent's retail violations break a turn-taking rule of the policy, which forbids replying to the user and calling a tool in the same turn, so the shell never breaks it. On airline, rules such as cancellation eligibility depend on the reservation, and the shell cannot check them. It violates a contract in 21.0% of simulations and ACORN in 0.0% (Table 3 in the revision, Table 2 in the submission).

Q3. On retail, the shell and the official agent tie on pass^1 (62.5 vs 63.6), and the shell's higher pass^4 (37.7 vs 31.6) reflects more consistent behavior across trials. Relative to the shell, ACORN adds a small +1.8 points of pass^4, because the retail API already rejects the calls its policy forbids. In the gpt-4.1-mini trajectories released with τ²-bench it rejects 134 such calls, so few violations are left for contracts to block.

The airline cancellation API performs no eligibility check. In the same trajectories, 53 of the 99 failed airline simulations make a database change that the reference solution does not contain, mostly cancellations the policy forbids (Appendix A, Table 4). The contracts block these calls, and under a paired bootstrap over the 50 airline tasks ACORN gains +18.5 points of pass^1 over the shell, [8.0, 29.5], and +20.0 points of pass^4, [6.0, 34.0]. Within this gain, verification alone adds 11.0 points of pass^1 over the shell, and the mask adds 7.5 more, [1.5, 14.0] (Table 3).

More generally, ACORN is designed for agentic workflows in which the agent follows a written procedure, as in SOP-Bench. We include τ²-bench to test whether the control transfers to a third-party conversational benchmark without lowering task success. In such an interactive setting, the next step depends on what the user says, so the contracts determine fewer steps. Fast-forward never fires there (Table 3), and the gain comes from the mask and verification alone. We therefore expect smaller gains in interactive settings than on SOP-Bench, which is what the two benchmarks show.

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

This work introduces ACORN, an agent framework that leverages contract-based symbolic control to help agents follow SOP rules. The required behaviors are formalized as assume-guarantee contracts in linear temporal logic on finite traces over the agent trajectories. The contracts are compiled via DFAs, which are used to select the permitted tools before each tool call. The proposed approach is evaluated on SOP-Bench, and tau2, and show increased policy complinace and task completion.

Critical strengths
  1. The proposed method integrates formal contract verification with proactive tool masking and automatic tool execution, providing a meaningful approach to improving both compliance and efficiency.
  2. The empirical results are promising. The experiments demonstrate substantial improvements in task success and inference cost across multiple models. The ablation studies also help distinguish the contributions of verification, masking, and fast-forward execution.
Critical weaknesses

Several core components of the proposed method have been explored in prior work. ContrAgent already provides A/G contracts, LTL-based runtime verification, and reusable automata for tool-call enforcement. Agent-C goes beyond passive blocking by generating compliant actions under temporal constraints. SOP-Agent and Blueprint First, Model Second explore procedure-guided execution and reducing unnecessary LLM involvement. Although ACORN combines these ideas through contract-derived tool masking and fast-forward execution, the paper does not sufficiently establish the unique advantages of this combination. The experiments primarily compare against internal ablations rather than strong existing approaches under matched conditions, making it difficult to assess the significance of its methodological contribution.

References

[1] Xiao, Y., and Nuzzo, P. (2026). Symbolic Temporal Supervision of LLM Agents Using Contracts (ContrAgent). arXiv:2609.18128. [2] Kamath, A., Zhang, S., Xu, C., Ugare, S., Singh, G., and Misailovic, S. (2025). Enforcing Temporal Constraints for LLM Agents (Agent-C). arXiv:2512.23738. [3] Ye, A., et al. (2025). SOP-Agent: Empower General Purpose AI Agent with Domain-Specific SOPs. arXiv:2501.09316. [4] Qiu, L., et al. (2025). Blueprint First, Model Second: A Framework for Deterministic LLM Workflow. arXiv:2508.02721.

Questions for authors

Can the authors clarify the key differences between ACORN and existing approaches such as Agent-C, SOP-Agent, AgentLTL, and ContrAgent? In particular, can they provide controlled comparisons demonstrating that contract-derived masking and fast-forward execution offer advantages over existing constrained-action generation and deterministic workflow execution methods?

1 comment
AuthorsOpenReview ↗

W and Q: Differences from prior methods and controlled comparisons

Thank you for the review and the references. We have revised the submission PDF, and the changes are marked in blue.

ACORN differs from these methods in when it acts. ContrAgent and AgentLTL block a violating call after the model has proposed it. Agent-C goes beyond blocking, as you note, but in a different way from ACORN. Its constrained generation keeps each tool call well-formed, and the policy is checked by an SMT solver once the call is complete. A violating call is then discarded and generated again. In all three the rules apply after the model has chosen a call from the full tool set. SOP-Agent and Blueprint First fix the order of steps in a graph or program written in advance. ACORN applies the rules before the model proposes. It shows the model only the tools the contracts admit and executes the calls the contracts determine, and any order of steps the contracts allow remains possible. The three mechanisms work as one layer, because they read the same automaton states. The admissible set that the mask computes triggers fast-forward when it holds a single tool, and a fast-forwarded call is verified before execution as well (Section 1). The revision states these differences in Sections 1 and 5 and in a comparison table in Appendix F.

On the experiments, the verification-only condition in Table 1 is this reactive approach under matched conditions. With the same rules and model, it reaches 70.0% macro TSR, adding the mask 77.1%, and adding fast-forward 94.5%. In the submission we compared against this operating point and did not run the existing systems themselves.

We agree that a direct comparison under matched conditions makes the advantage clearer, and the revision adds one on 200 SOP-Bench tasks with the same rules and model (Section 4.1, Table 2). ContrAgent, the released AgentSpec runtime and our reproduction of the resampling of Agent-C, whose code is not released, are all fully clean, but they raise TSR by at most 2.0 points over the unguarded baseline, while ACORN raises it by 17.0 points with about half the model calls. Checking or resampling a call after the model proposes it removes violations, but it does not help the model find the correct next step. The mask and fast-forward do, which is the advantage of combining them. For deterministic workflow execution, executing only the steps that the contracts determine, with no model, completes 0.2% of the tasks (Table 2), and showing the model only the admissible tools, the closest operating point to SOP-Agent, reaches 77.1% against 94.5% for ACORN (Table 1).

Reviewer_crcvOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper explains a way to formalize the procedure agents follow to make tool calling LLM agents adhere to rules. For example, a customer care system that handles refunds has to follow rules such as ensuring it is an actual customer that is requesting a refund. We can provide LLMs with the set of rules, but LLM might not follow the rules every time it handles requests. A conventional software logic can avoid such pitfalls, but LLMs have the advantage of understanding natural language and conversing with users to execute their intent. There are 3 mechanisms discussed in the paper: verification, tool masking, and fast-forwarding. Verification is done through a contract that contains event descriptions, assumptions about the environment, and agent’s guarantees. Then linear temporal logic is used to chain the logic. These contracts are compiled into finite-state machines which track the agent’s progress in satisfying its rule. Every time an action is proposed, ACORN checks whether the action violates any rule and is there any viable path to completion if this action is performed.

Tool masking is carried out to disable certain tools for which conditions are not yet met. Only after satisfying conditions are present, the agent is allowed to call certain tools. For example, until the customer is verified, the issue refund tool will be disabled. Fast forward describes the usage of code rather than calling LLMs whenever the next action can be deterministically found.

Critical strengths

the paper addresses an important problem in agentic control systems which are becoming pervasive. It also handles delicate balance between preventing rule violations and helping agent complete the tasks

ACORN framework improves task success from 71.4% baseline to 94.5% on SOP-Bench which reducing the cost by 62%

Critical weaknesses

The verification is done against the contracts that are encoded. Errors that happen during translation of requirements to contracts can propagate through the system. The audit is also performed against the encoded contracts which makes it harder to find translation errors

Experiments do not fully separate the benefits from fast-forwarding. For fast-forwarding deterministic programs are used which can execute the tasks accurately. Comparing it against fully agentic systems can be unfair.

Questions for authors

I look forward to the justification from the authors.

2 comments
AuthorsOpenReview ↗

W1: Errors in translating requirements into contracts

Thank you for the review. We have revised the submission PDF, and the changes are marked in blue.

Translating the requirements into contracts is out of the scope of this paper. ACORN takes the contract library as given, and both our guarantee and the audit are stated with respect to it (Section 3.1, Section 6). Authoring and validating the library is a separate problem. In our experiments the library is drafted from the SOP, then reviewed by a person and checked for conflicts before use, the same way the SOP itself is reviewed.

AuthorsOpenReview ↗

W2: Separating fast-forward, and fairness of the comparison

Table 1 already separates the benefit of fast-forward. It adds one mechanism at a time with the same model and contract library: verification alone reaches 70.0% macro TSR, adding the mask 77.1%, and adding fast-forward 94.5%, so fast-forward accounts for 17.4 points (Section 4.1).

On fairness, fast-forward is a prediction backed by verification, and the model still decides most of the task. When the contracts admit a single tool, the argument map predicts its arguments from values already recorded in the session. The predicted call is still verified before execution. If verification rejects it, for example because of a predicted argument, the call is not executed and the model decides that step (Section 3.4). Across the ten domains, 31% of tool calls run without the model (Table 1), and at every other step the model chooses the call.

The revision strengthens this point with a rule-only controller that keeps the same contracts and argument maps and removes the model. It completes 0.2% of SOP-Bench tasks, against 94.5% for ACORN (Section 4.1, Table 2), so the deterministic steps cannot do the task alone. On τ²-bench fast-forward never fires (Table 3), and ACORN still improves airline pass^1 by 21.5 points over the official agent.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.