acceptodds
Under review as a conference paper at ICLR 2027

Binding User Approval to Individual Actions in Tool-Using Agents

Abstract

Tool-using agents often ask users to approve an action before executing it. However, when an identical action is proposed again, matching the tool, target, and arguments does not establish which proposal was approved. We introduce EpochSelect, a runtime contract and reference adapter that bind approval to a specific action instance: the tool's preview path must create the instance before approval, approval can only select exactly one existing live instance, and execution rechecks its live state and final arguments. Under explicit synchronous-execution and trust assumptions, the contract prevents approval and execution evidence from being combined across different instances. In 480 matched in-process restoration tests, full instance binding accepts all 120 exact restorations and rejects all 360 nonexact rebindings, avoiding the valid restorations blocked by the object-identity baseline and the invalid substitutions admitted by the value-matching baseline. Language-level evaluation reveals a complementary limitation: on 128 proxy turns from benchmark training data with real tool handlers and preselected proposals, a repaired approval rule rejects all 64 negative cases but accepts only 25 of 64 positive cases (39.1%), each executed exactly once. These results support instance-level approval binding in the tested setting, while leaving natural-language target resolution and end-to-end task effectiveness unestablished.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Tool-Using Agents, User Approval, Action Authorization, Runtime Verification, Stateful Tool Execution

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

This paper studies how to bind a user’s approval to one specific action. Two actions may use the same tool, target, and arguments but belong to different attempts, so approval for one should not authorize the other. The authors propose EpochSelect, which requires an action instance to be created and shown before approval. Approval can only select an existing, valid instance, and the system checks its identity, current state, and final arguments before execution. Controlled tests show that this approach accepts valid restorations and rejects incorrect bindings under the stated trust and execution assumptions.

Critical strengths
  1. A meaningful safety contribution. The paper explains why identical action details do not imply the same action instance. Creating the instance before approval and checking it before execution provides a clear way to prevent approval reuse.
  2. Useful experimental evidence. Full binding accepts all 120 valid restorations and rejects all 360 incorrect bindings. In comparison, strict object identity rejects valid restorations, while matching only business values accepts incorrect bindings. This result shows that the proposed design can preserve valid approvals while rejecting substitutions.
Critical weaknesses
  1. The evaluation does not establish usefulness in realistic conversations. In Study E, the intended action is selected by looking at a later confirmed action in the recorded conversation. The system therefore does not have to identify the correct action from the conversation itself. Even in this simplified setting, the repaired approval rule accepts only 25 of 64 positive examples (39.1%). These results leave both action selection and approval coverage unresolved.

  2. The last page of the main text leaves unused space, while helpful explanations and comparison tables remain in the appendix. For example, the authors could move examples of accepted and rejected approvals and the key baseline comparisons into the main text. This would help readers understand how the method works and what the results actually show. The current organization makes readers repeatedly consult the appendix to assess important parts of the paper, weakening its clarity.

Questions for authors

Can you test the system on full conversations without choosing the intended action for it in advance?

2 comments

Thank you for recognizing the value of instance-level approval binding. Your question about full conversations focuses attention on the central issue: how an agent can preserve the meaning of a user’s approval as the interaction continues.

Consider a travel agent that presents a cancellation proposal and receives approval. The session is saved and later restored. The user expects that approval to remain attached to the proposal they saw. A cancellation proposed on a later occasion belongs to a different event, even when its tool, reservation, and arguments are identical. A faithful continuation must preserve that distinction through the agent’s internal state changes.

EpochSelect gives this expectation an explicit runtime meaning. The native preview path establishes the proposal instance before approval; approval selects that existing live instance; execution rechecks its sources and arguments. Proposition 1 explains the ambiguity of value-only selection, and Contract C specifies the binding maintained under the stated trust and synchronous-execution assumptions. The controlled restoration study makes the consequence observable: valid restorations retain approval, while the tested nonexact rebindings are rejected. The added source-aware capability comparator matches this behavior in the post-approval, in-process comparison.

Following your request, we ran an additional full-prefix development experiment on 12 multi-preview user turns from exposed STATE-Bench training trajectories. The selector received the conversation through the current user utterance and every earlier native write preview. Later assistant actions were excluded from target construction. We then examined the original-utterance guarded path and a separate model-selected persisted-preview capability path against actual native tool effects.

With multi-pending admission explicitly relaxed, the guarded path selected no instance from the original utterances. The separate model-plus-capability path produced 10 state-changing native calls. This experiment follows the input condition you requested and makes the handoff from conversational interpretation to executable approval visible. Its reported outcomes are selections and native effects on recorded training prefixes; the benchmark’s final-state goals describe task completion at the task level.

The example and comparison above express the paper’s contribution in concrete terms: preserving user control requires an executable connection between a past interaction event and a present environmental effect. The contract, reference adapter, and additional dialogue experiment give agent research a correctness criterion and a way to examine that connection in actual tool execution.

Thank you for running the full-prefix experiment without using later assistant actions to preselect the target. Across the 12 training-set turns, the guarded path made no selections, and the separate model-plus-capability path produced 10 state-changing calls. It remains unclear how many of those calls matched the specific preview the user approved, or how many valid approvals the guarded path missed. My concern about approval handling in realistic conversations therefore remains.

My comment about placing representative approval examples and key baseline comparisons in the main text also remains unaddressed.

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

The paper handles vulnerability in stateful, tool-using LLM agents: the problem of authority-to-execution instantiation. Specifically, when an agent proposes a tool action, the user approves it, but the authorization code or agent constructs or repeats the action after approval, simple value-matching (tool, target, arguments) is insufficient. It fails to prove that the approved action instance existed prior to or precisely at the moment of consent.

To solve this, the authors introduce EPOCHSELECT, a runtime contract and reference adapter where:

  • The native handler must create an explicit, immutable proposal occurrence before user authority can be solicited.
  • Authority can only select one live, pre-opened occurrence (it cannot mint new ones).
  • Final dispatch re-verifies the live source state, generation metadata, and typed arguments immediately before invocation.

The evaluation spans a mix of deterministic analytic censuses (Studies A-C, testing conformance, baselines, and in-process restore bounds), natural-language dialogue act diagnostics (Study D on SGD), trajectory composition tests (Study E on STATE-Bench), and full-history input compatibility censuses (Study F on ToolTalk).

Critical strengths

The problem to solve is clearly motivated. The confused deputy / replay / late-binding problem in tool-using agents is an urgent security blind spot that current agent frameworks largely ignore. The authors try to make the paper self-contained by defining its transition invariants (Contract C), threat models, and explicit separation of evidence types. The formal derivations (Invariants 1–4, Lemmas 1–3) are precise.

Critical weaknesses

The paper is not easy to follow. The paper reads much more like a systems and security paper given its heavy focus on transition contracts, formal invariants, and stateful verification. I'm not sure if ICLR is a good venue for this work

Questions for authors

Study E showed that while the repaired gate (CONSENT2) caught all hard negatives, it only accepted 39.1% of positive proxies, failing your 90% coverage threshold. Furthermore, this relied on a future-action preselection oracle rather than resolving targets from a full multi-preview history. If a real agent environment presents multiple valid previews (which occurred in nearly half of your evaluated trajectories), how do you envision scaling reference resolution beyond preselected oracles without introducing catastrophic false positives or accidental execution of stale tool calls?

1 comment

Thank you for highlighting the problem’s motivation and the precision of its formal treatment. The connection to language-model agents begins with an ordinary exchange: an agent presents several alternatives, and the user replies, “Go ahead.”

For that reply to authorize a faithful action, it needs a referent in the interaction history. The agent may repeat an action description, reconstruct a proposal, or resume a saved session. The user’s decision concerns a proposal they encountered, while the tool receives arguments and runtime objects. The scientific question is what must connect those representations so that execution carries the authority expressed in the conversation.

Proposition 1 formalizes the ambiguity of retaining action values alone. Contract C locates the distinguishing information in the native preview path: the instance exists before approval, approval selects an existing live instance, and dispatch rechecks its sources and arguments. Under the stated trust and synchronous-execution assumptions, this gives both learned and rule-based interfaces a precise target. A resolver identifies an entry in the native proposal catalog; an ambiguous reference calls for clarification before selection; execution checks the continuing validity of that selected instance. The evaluated contract selects one instance per approval turn.

To examine your multi-preview question, we ran an additional development experiment using full observed prefixes for 12 multi-preview turns from exposed STATE-Bench training trajectories. Each input contained the current user utterance and earlier native previews, with later assistant actions excluded from target construction. This replaces Study E’s externally preselected target at the input-construction stage with selection from the observed conversational history.

The added experiment traces the handoff to real effects. With multi-pending admission explicitly relaxed, the guarded path selected no instance from the original utterances, while the separate model-plus-persisted-preview capability path produced native writes. A further multi-action diagnostic used separate exact approvals on synthetic later turns: the first effect executed, and subsequent selections stopped at the live first-preview epoch check, leaving the remaining task goals unmet. These observations distinguish reference interpretation, approval acceptance, and continuation after a state change. We report selections and native effects, with task-final goals retaining their task-level meaning.

This is directly relevant to research on language-model agents because human control must survive the transition from conversational meaning to environmental action. The paper contributes a formal relation to preserve, a reference adapter that checks it, and experiments examining how language and execution meet at that boundary. It makes the meaning of an approved action a concrete subject for agent design and evaluation.

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

The paper names a failure it calls authority-to-execution instantiation: approval gates match an action by (tool, target, arguments), so a value-identical later proposal can inherit an earlier approval, and authorization-dependent code can construct the occurrence it then validates (Definition 1, p.3). The proposal is a contract in which only the native preview handler may open an occurrence, authority may only select one already-open occurrence, and a guarded dispatch replays the ledger and rechecks live sources and typed arguments before the effect (C1–C5, p.3). A reference adapter, EPOCHSELECT, is evaluated in six studies.

Critical strengths

The problem framing is the contribution. Proposition 1 (p.3) argues correctly that no deterministic selector over (tool, target, arguments) can distinguish two value-identical occurrences, and Figure 1 turns this into the right question: who may create the occurrence? The paper reports results that hurt it: 25/64 positive acceptance (Table 1, p.8), zero recall on the 96 official SGD affirmations (§D.2, p.18), zero overlap between parsed and structurally ready events (Table 14, p.22). Negative evidence of this kind is scarce. Provenance discipline (Appendix H) makes the counts auditable even where they are not experiments.

Critical weaknesses

The delta over existing capability mechanisms is not established. The construction is a handler-minted, single-use, revalidated token carrying a unique identifier and a generation counter; the paper concedes no novelty "for capabilities, nonces, epochs, logs, idempotency, or final validation individually" (p.27). It cites Miller et al. (2007) and Stripe's PaymentIntent, but not work that already binds authorization to an object instance rather than a value: attenuable bearer credentials, token binding, and the confused-deputy literature. Table 21 (p.28) surveys six 2026 systems in prose, none with a reported implementation; its only production row is Stripe's PaymentIntent, which is a domain state machine rather than a mechanism.

The separating experiment uses the weakest capability baseline, though their own table shows a tie. In Table 5 (p.16) P4a "server-held object capability" neutralizes all 216 substitutions with zero escapes, tying full binding. Separation appears only in Study C (Table 9, p.17), whose baseline is "strict ephemeral object identity" and over-blocks 120 valid restores. Yet a serialized capability with the same nine-field bundle is exactly the occurrence p of Eq. 1 (p.4), and "exhaustive persistent-capability comparison [is] unmeasured" (p.8, p.17). Study C may measure serialization fidelity rather than a security property.

There is no attack. Section 4.1 (p.7) reports 4,320 of 4,464 rows as "deterministic analytic projections"; Appendix H (p.25) calls them "not external attack execution". No adversary supplies a proposal, no injection attack is run, C4 excludes concurrency and TOCTOU by assumption (p.3), and C1/C3 assume complete mediation. Invariants 1–4 (p.6) then follow from the transition preconditions, with refinement resting on a 40/40 audit of two entry roots (p.6; App. A.1, p.13). The necessity study is likewise circular: Table 6 (p.16) shows each omitted field admits exactly the matching 24-case slice, but those cases were built by substituting the same nine fields.

Nothing is shown end to end, and the gate is the weak link. Study B's shapes "share one final verifier" (p.17) and are template-generated (p.26); Study E preselects the occurrence from the future confirmed call (p.5); Study F yields no executable comparison. On the language gate, §4.6 (p.8) reports balanced accuracy 0.9844 for the fixed model against 0.9635 for a train-only TF-IDF baseline, a difference of +0.0208 that fails significance (p = 0.34): the gate needs no language model to reach its best score. With positive acceptance at 0.391 (Table 1), the binding is correct on paper but rarely reachable in dialogue.

Questions for authors

See Weakness

1 comment

Thank you for identifying the instance-versus-value formulation as the central contribution. Your request for a stronger capability comparison led us to test the implementation relationship directly.

Consider a proposal reconstructed after the user has approved an earlier interaction. Its tool, target, arguments, identifier, and generation fields can form a consistent record. The question is how that record acquires the authority of the native proposal that existed when the user acted. The user’s decision belongs to the interaction history, and the executable object must carry that history forward.

Proposition 1 identifies the ambiguity of value-only selection. Contract C specifies the corresponding ownership and ordering: the native preview path establishes the occurrence before approval, authority selects an already-open live occurrence, and dispatch returns to its live sources and final arguments. Under the stated trust and synchronous-execution assumptions, the invariants describe the relation between the historical approval and the eventual effect. The contribution sits at this agent-integration boundary, where an identifier must represent the proposal to which the user gave authority.

Following your suggestion, we implemented and ran a server-held persistent-capability comparator carrying the same selected post-approval source and generation projection. On the 480 exposed matched restoration cases, it made exactly the same decisions as EpochSelect: accepting the exact restorations and rejecting the nonexact rebindings. The tested boundary is canonical serialization into a fresh store within the same OS process. P4a also matches full binding on the controlled substitutions. The added experiment makes the relationship concrete: a source-aware capability realizes the tested restoration semantics, while the contract specifies the provenance and lifecycle obligations attached to the instance it carries.

This connects the contribution to the confused-deputy, Macaroons, and Token Binding literature through the binding of delegated authority. The agent-specific object of analysis is the native proposal that precedes and receives the user’s approval. The controlled studies examine that object through finite conformance designs, deliberate field substitutions, and in-process restoration. The additional dialogue experiment examines its conversational entry point: with multi-pending admission explicitly relaxed, the guarded path selected no instance from original utterances, while the separate model-plus-capability path produced native effects. Study D reports a nonsignificant model–TF-IDF difference; Study E measures positive-proxy acceptance under target preselection. The empirical endpoints remain distinct: gate acceptance, instance binding, and native effects.

The paper turns an intuitive expectation about user control into a precise relation that can be implemented and examined. The contract, reference adapter, and added capability comparison give agent researchers a concrete way to ask whether an executed action still carries the authority of the proposal the user approved.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.