acceptodds
Under review as a conference paper at ICLR 2027

PACT: What Agents See Must Not Decide What Their Tools Do

Abstract

External content may inform the tool call an agent proposes, but it must not grant permission to execute that call. Before a call runs, the Provenance-Aware Contract for Tools (PACT) checks its operation, destination, arguments, sources, evidence, and approval against a task contract, an executable list of what the trusted request permits. With complete contracts supplied by the task, recorded sources, interception of every registered call that changes or discloses application state (a protected call), and permitted alternatives, PACT blocks all 1,500 controlled attacks and completes all 2,000 tasks without human intervention. On the same 100 adapted ARPIbench cases, the attack success rate (ASR) in executed protected calls falls from 2%–85% to 0 for each of eight models. On all 7,560 cases with DeepSeek V4 Flash, ASR falls from 58.4% to zero while permitted tool calls still run. On AgentDojo, PACT ties the best task success under attack and the best safe success, and no protected call requested by an attack executes. Building complete contracts is harder. A 72B model that generates contracts from the request finds 70/72 write tools but correctly constrains only 20/223 argument fields, and PACT enforces such incomplete permissions exactly as written.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
tool-using agents, prompt injection, provenance, runtime authorization, agent safety

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_4X3EOpenReview ↗
Rating
3(+1)
Confidence
1(−1)
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes PACT, a provenance-aware permission framework for defending LLM agents against indirect prompt injection. PACT checks tool calls against task-specific contracts covering operations, arguments, destinations, data sources, and approval requirements. When a proposed action is rejected, the framework attempts recovery through a permitted alternative subject to the same checks. The paper evaluates PACT across controlled attacks, multiple models, and public agent benchmarks, and investigates the challenges of automatically constructing task contracts.

Critical strengths
  • A clear and principled execution-time defense framework. PACT separates tool-call authorization from the agent's proposed actions. Combining task contracts, provenance tracking, and checked recovery provides a well-motivated approach to prompt injection defense.

  • Extensive evaluation and valuable open-source artifacts. The paper covers multiple models, attack settings, and public benchmarks, while also acknowledging the limitations of automatically generated contracts. The released implementation, experimental records, and validation scripts are particularly valuable for reproducibility and independent examination.

Critical weaknesses
  • Dependence on High-Quality Task Contracts. PACT's strongest results rely on complete task contracts and permitted alternatives supplied in advance. When contracts are generated automatically, many argument constraints are missing or incorrectly specified, and the resulting security improvements are modest. Although the authors acknowledge this challenge, the practical effectiveness of PACT remains dependent on obtaining sufficiently accurate task contracts.

  • Further Clarification on Recovery Enforcement. Algorithm 1 requires replacement actions to pass the same safety checks before execution. However, an examination of the released code and traces suggests that some recovered actions may be recorded as successful despite failing the final persisted_state_safety check. While this does not necessarily indicate unauthorized data disclosure, it raises questions about whether the experimental recovery procedure fully implements the stated safety requirements.

Questions for authors
  • Practical Contract Construction. Could the authors elaborate on how accurate task contracts and permitted alternatives could be obtained in realistic deployments without access to reference tool calls? This would help clarify the applicability of PACT beyond the supplied-contract setting.

  • Recovery Safety Checks. Could the authors clarify why recovered actions with failed final persisted_state_safety checks can still be recorded as successful? How does the implementation ensure that replacement actions satisfy all required checks before execution?

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

This paper proposes PACT, a defense against indirect prompt injection in tool-using LLM agents. PACT separates the model’s proposed actions from the permission to execute them. It checks each protected tool call against a task contract covering operations, arguments, destinations, data sources, and approval requirements. Rejected calls can be replaced with alternatives that pass the same checks. The evaluation includes controlled tests, multiple models, and public benchmarks. Results are strong when complete contracts are supplied, while experiments with automatically generated contracts expose substantial problems with argument constraints and task completion.

Critical strengths
  1. The design clearly separates action proposals from execution permissions and checks tools, arguments, destinations, and data use.
  2. Replacement calls pass the same checks, allowing safe recovery when a valid alternative exists.
  3. The evaluation covers multiple models and benchmarks. The paper also clearly reports failures caused by incomplete contracts.
Critical weaknesses
  1. The best results assume that complete task permissions are available in advance. The generated-contract experiments show that obtaining these permissions remains difficult and can reduce task success. This leaves a substantial gap between the controlled setting and practical deployment.
  2. Some controls represent prompt reminders and input delimiters through preset rejection rules based on episode seeds. These results provide limited evidence about how PACT compares with actual implementations of those defenses.
  3. Simpler permission checking already matches PACT’s controlled results, while full provenance tracking is mainly evaluated in synthetic settings. The paper needs stronger evidence that this mechanism improves protection beyond existing permission checks.
  4. The controlled experiments supply valid replacement actions in advance. In practice, agents must find these alternatives themselves, and the live results show frequent failures after a call is blocked. This weakens the evidence that PACT consistently preserves task completion.
  5. Progent already checks tool calls and arguments against explicit policies before execution. PACT emphasizes provenance tracking and checked recovery, but the paper does not clearly establish what additional security or utility these mechanisms provide over Progent. A direct comparison under equivalent permissions and recovery settings is needed to clarify the technical contribution.
Questions for authors

See weaknesses.

1 comment

Thank you for the detailed response and additional experiments. However, they largely confirm my main concerns: generated contracts still yield non-significant gains on the full evaluation (p = 0.0703), recovery without supplied alternatives remains weak, and under matched conditions PACT and Progent have identical decisions, safety, and utility. The contribution beyond existing permission checks therefore remains unclear, and I will keep my score.

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

This paper introduces PACT (Provenance-Aware Contract for Tools), a security framework for LLM agents designed to defend against indirect prompt injection attacks. The core idea is simple but powerful: What an agent reads should not determine what it is allowed to do. Instead of trusting the LLM's decision about tool usage, PACT separates proposal from permission. The model may propose a tool call, but PACT independently verifies whether that call is authorized according to a predefined task contract before execution.

Critical strengths

Strength 1: Strong empirical demonstration that authorization-based enforcement can eliminate tool-level prompt-injection attacks

The paper provides unusually comprehensive evidence that authorization-based runtime enforcement can prevent unauthorized tool execution across a wide range of settings. With supplied contracts, PACT achieves 0% attack success rates across controlled benchmarks, ARPIbench model evaluations, and public agent benchmarks while still allowing large numbers of permitted tool calls to execute. The evaluation spans multiple models, attack types, input channels, and benchmark environments.

Strength 2: Elegant provenance-aware contract framework

PACT combines task contracts, provenance tracking, runtime verification, and recovery into a unified security architecture. The framework explicitly reasons about operations, destinations, arguments, information sources, and approval requirements, while ensuring that both original actions and recovery actions are subject to the same authorization checks.

Critical weaknesses

Weakness 1: The strongest results rely on benchmark-derived contracts, and contract generation remains largely unsolved

The paper's strongest results assume supplied contracts constructed from benchmark task specifications, and in AgentDojo the permissions are derived from reference calls and arguments. By contrast, the paper's own contract-generation experiments reveal that while write tools can be recovered with high recall (70/72), only 20 of 223 expected argument constraints are correctly identified by the best generator. The resulting safety improvements are not statistically significant and utility decreases.

This weakness is critical because the practical effectiveness of PACT depends critically on obtaining accurate contracts. The paper convincingly demonstrates enforcement given high-quality permissions, but provides much weaker evidence that such permissions can be obtained in realistic deployments from natural-language user requests.

Weakness 2: Limited conceptual novelty relative to prior authorization and runtime-enforcement approaches

The paper's central principle of separating action authorization from model reasoning is closely related to established security concepts such as reference monitors, policy enforcement mechanisms, capability control, privilege restriction, and existing agent-security systems that perform runtime verification of actions, dependencies, privileges, or provenance. Indeed, the paper's own related-work section cites numerous contemporaneous systems operating in a similar space.

This weakness is consequential because a substantial portion of the paper's motivation rests on this authorization-centric framing. As a result, the primary novelty appears to reside in the specific contract-and-provenance formulation and its empirical validation rather than in a fundamentally new security principle.

Questions for authors

Q1: The strongest results use supplied contracts derived from benchmark task specifications, and for AgentDojo from reference calls and arguments. Have the authors evaluated any intermediate setting in which contracts are manually written from task descriptions alone, without access to reference actions or argument values? If so, how does performance compare with the supplied-contract and generated-contract settings?

Q2: The guarantee explicitly assumes complete interception of every registered state-changing call and correct provenance recording. In realistic deployments, how should practitioners assess whether coverage is sufficiently complete, and what security guarantees remain when some tools, side effects, or call paths are not instrumented?

Q3: The paper notes that final text outputs are protected only when routed through a registered tool, and reports AgentDojo attack successes that arise from manipulated final responses rather than unauthorized tool execution. How do the authors envision extending the framework to address this class of attacks, and how should readers interpret these cases within the intended threat model?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.