acceptodds
Under review as a conference paper at ICLR 2027

Right Tool, Wrong Parameters: Defending LLM Agents Against Parameter Poisoning

Abstract

Indirect Prompt Injection (IPI) poses a critical threat to LLM agents. Existing defenses largely focus on whether an injection induces a new tool invocation or unintended action. In this paper, we study a different attack surface, parameter poisoning, where the attacker preserves the intended action but manipulates one or more tool arguments, such as a recipient or other task-critical value. Such attacks are difficult to detect because no new action is introduced, while parameter changes themselves are often legitimate parts of the user’s request. Our key insight is that the legitimacy of a parameter change should be determined by the trust of the information flow that produces it under the user query. The query induces a task-specific trust hierarchy over available information fields: some are trusted to determine particular parameters, while others should have little or no influence. Based on this insight, we propose AuthorityFlow, a three-stage parameter-level defense. First, it interprets the user query to construct a task-specific trust hierarchy over the information fields available to the agent. Second, for each tool argument, it traces the information flow that produces its current value and attributes the value to its supporting field. Finally, it accepts the value only when that field is trusted to determine the parameter under the current task, allowing high-trust changes while flagging low-trust influence as potential parameter poisoning. We further introduce FactAuthBench for evaluating parameter poisoning in LLM agents. Without defense, the attack success rate reaches 93.06%. AuthorityFlow reduces it to 9.03%, while retaining 82.64% benign task utility compared with 90.28% without defense. Our results show that effective IPI defense requires reasoning not only about what action an agent takes, but also about which information is trusted to determine its parameters.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Indirect Prompt Injection, Agent Safety, Parameter Poisoning

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

This paper studies parameter poisoning in indirect prompt injection. Here, the attacker does not trick the agent into taking a new action. Instead, the attacker changes key parameters in the correct tool call, such as the recipient, the amount, or the address. The proposed method first uses the user task to build a fixed rule set that says which information source is allowed to decide which parameter. Before a tool call runs, it traces where each parameter came from. It then checks two things: whether the evidence supports the value, and whether the source is allowed to decide it. If either check fails, the call is blocked. The paper also builds FactAuthBench, which has 144 paired cases, and runs experiments with several models and baselines.

Critical strengths
  1. The paper is clearly written. It moves smoothly from the research problem to the method.
  2. The paper compares against several defenses, and it reports the core verification module separately from the repair (purification) module.
Critical weaknesses
  1. The benchmark and the defense follow the same set of rules, so the results may be circular. In FactAuthBench, every case marks an attacker-controlled region, and every attack works the same way: the attacker puts a replacement value in free text that they control. The defense rules match this exactly: externally controlled fields cannot get HIGH authority, and low-authority free text can only be used to select a record, not to decide a parameter value. Also, the defense seems to decide which fields are attacker-controlledwith the same source labels that the benchmark uses. Does the defender know in advance which fields the attacker can change? If so, this is a very strong assumption.

  2. The contribution over existing data-flow defenses is not well established, and the difference from camel and similar work is not clear. CAMEL already handles parameter manipulation and source tracking directly. DRIFT already includes constraints on parameter dependencies. The authors should show which cases can only be solved by the new use-level authorization. They should also explain why giving existing systems equally fine-grained policies would not reach similar results.

  3. The traced sources may not be the real ones. The auxiliary model rebuilds the evidence from the candidate value and the context. This does not guarantee that it recovers the real dependency that produced the value. Also, citing a legitimate source does not mean that no malicious influence was missed.

Questions for authors
  1. In the defense, how do you decide which fields are attacker-controlled and get LOW authority? Do you use the same information as the FactAuthBench labels? What happens if the defender only gets the public descriptions of the tools?
  2. Can you report BU, UA, and ASR on all user tasks and injection tasks in the original Aentdojo? In particular, for tasks where external content should legitimately decide a parameter value, does AuthorityFlow block them by mistake?
  3. On Qwen3.6-27B, 13 cases still succeed. What kind of failures are these? Is the authorization boundary wrong, is the tracing wrong, or is the verifier LLM misled by the attack content?
4 comments

We greatly appreciate your expert feedback and insightful concerns. Our responses follow:

We have revised the manuscript accordingly. The changes are highlighted in blue in the revised PDF.

Weakness 1 & Question 1: (1) In the defense, how do you decide which fields are attacker-controlled and get LOW authority? (2) Do you use the same information as the FactAuthBench labels? (3) What happens if the defender only gets the public descriptions of the tools?

(1) Assigning LOW authority.

Before observing runtime data, the planner decides which fields are externally editable and receive LOW authority based on their schema properties (Section 3.2, Algorithm 1, Appendix B.4). Specifically, it assigns HIGH authority to system-maintained structured fields (e.g., transaction IDs, official addresses) and LOW authority to external free-form text fields (e.g., email bodies, reviews, notes), without knowing which runtime field is modified.

(2) Whether FactAuthBench label information is used.

No, we do not use the same information as the FactAuthBench labels. In AuthorityFlow, base-authority construction is independent of FactAuthBench's ground-truth labels, and the defense module does not use benchmark attack annotations. Ground-truth labels are used by the post-execution script to compute ASR (Sections 2.1, 2.2, Appendix A.4).

(3) Providing only the public descriptions of the tools.

If the defender only gets the public descriptions of the tools, behavior and results remain identical to our reported experiments because this is our standard evaluation setting. During base-authority inference, the defender receives the public tool specification C\mathcal{C} (tool descriptions, return structures, and field definitions), the same metadata provided to the agent and all baselines. Furthermore, the defense rules and benchmark are not circular. SELECTOR_INPUT is the default for external text without explicit delegation. When the user explicitly delegates value extraction or an update record is bound to a verified entity identity, the compiler prioritizes task-level authorization to grant the designated fact VALUE_INPUT permission (Algorithm 1). We have clarified this in Section 3.2 and Appendices B.2 and B.4 of the revised manuscript.

Weakness 2: The contribution over existing data-flow defenses is not well established, and the difference from camel and similar work is not clear. CAMEL already handles parameter manipulation and source tracking directly. DRIFT already includes constraints on parameter dependencies. The authors should show which cases can only be solved by the new use-level authorization. They should also explain why giving existing systems equally fine-grained policies would not reach similar results.

We have discussed CaMeL and DRIFT in Section 5.2 and compared both methods in Table 1, Figure 3, and Table 10. Here, we compare in detail the authority dimensions constrained by AuthorityFlow, CaMeL, and DRIFT. While CaMeL enforces data-readability taint tracking and DRIFT constrains tool-level preconditions, AuthorityFlow constrains the functional role a field may serve for a target parameter. The table below compares two representative cases, Case #26 (postponing an Insurance payment by two days) and Case #38 (finding the channel where Alice asked about a coffee mug and replying there):

CaseAuthorityFlowDRIFTCaMeL
#26 Date ShiftSucceeds on Clean & AttackSucceeds on Clean, Fails on AttackBlocks both Clean & Attack
#38 Channel ReplySucceeds on Clean & AttackSucceeds on Clean, Fails on AttackBlocks both Clean & Attack

In Case #26, the agent must use subject to locate the Insurance record and add two days to its structured date, whereas the attacker injects 07-10 into subject to induce 07-12. AuthorityFlow authorizes subject as SELECTOR_INPUT for record selection but rejects it as VALUE_INPUT for arithmetic derivation. DRIFT only checks whether parameters come from the preceding query tool without distinguishing fields or roles, executing 07-12. In Case #38, AuthorityFlow allows the LOW-authority message body to locate the inquiry while permitting only the HIGH-authority recipient field to supply the channel random, whereas CaMeL blocks both the clean task and the attack whenever state-changing calls depend on untrusted external content.

Equally fine-grained field-level policies cannot achieve similar results in existing systems. When a LOW-authority field like subject or body is required to locate the target record, a static field policy without use-level role distinction faces a fundamental dilemma: forbidding dependency on that field blocks legitimate record selection and reduces BU to 59.72% in our w/o Task-use Authorization ablation in Table 2, whereas permitting dependency on that field allows injected text to overwrite the parameter value.

Question 2: Can you report BU, UA, and ASR on all user tasks and injection tasks in the original AgentDojo? In particular, for tasks where external content should legitimately decide a parameter value, does AuthorityFlow block them by mistake?

We evaluated the undefended baseline, AuthorityFlow, and its combination with an action-level defense on the original AgentDojo benchmark:

MethodBU ↑UA ↑ASR ↓
No Defense79.17%55.27%24.80%
AuthorityFlow68.75%57.74%7.53%
AttriGuard + AuthorityFlow65.63%45.12%1.29%

Overall, AuthorityFlow and its combination with AttriGuard exhibit different security–utility trade-offs on the evaluated cases.

The 10 benign task rejections (from 76/96 to 66/96) stem from two causes: certificate formatting mismatches and uncovered VALUE_INPUT authorization for external fields. The tasks you highlighted, in which external content legitimately determines a parameter value, fall into the latter category. In the original AgentDojo, these tasks rely on underspecified prompts that lack clear boundaries on low-authority source usage. Action-level defenses typically ignore such parameter-level nuances, whereas existing data-flow defenses uniformly block them.

We treat safely permitting external parameter values as a finer-grained authorization problem governed by explicit task delegation or entity-bound provenance. While AuthorityFlow defaults to restricting LOW-authority fields to SELECTOR_INPUT, our compiler overrides this baseline and grants VALUE_INPUT permission whenever the user prompt explicitly delegates value extraction or the low-authority message is bound to the verified identity of the authoritative record under modification. To directly test this on stale official records, we evaluated [25 Clean + 25 Attack] paired cases across all four domains (3 runs each, 150 evaluations), where both legitimate updates and malicious replacements reside in the exact same LOW-authority fields. AuthorityFlow achieves 96.0% BU (4.0% FRR) on legitimate updates while restricting ASR to 0.0%, confirming that with explicit delegation or entity-binding signals, it accurately permits legitimate external values without compromising security.

Weakness 3 & Question 3: The traced sources may not be the real ones. The auxiliary model rebuilds the evidence from the candidate value and the context. This does not guarantee that it recovers the real dependency that produced the value. Also, citing a legitimate source does not mean that no malicious influence was missed. On Qwen3.6-27B, 13 cases still succeed. What kind of failures are these? Is the authorization boundary wrong, is the tracing wrong, or is the verifier LLM misled by the attack content?

While rebuilding evidence from context without accessing the agent's internal reasoning states does not theoretically guarantee recovering the exact internal dependency, AuthorityFlow does not rely on citing a legitimate source alone to approve a call. To guard against missed malicious influence when a legitimate source is cited, we pair tracing with an independent downstream Verifier (Section 3.4) as a safeguard to check whether the frozen authorized evidence is semantically sufficient on its own to derive the candidate parameter. Under this design, even if the tracer cites a legitimate source while omitting a malicious influence, the Verifier is designed to block the call as UNSUPPORTED when the manipulated value cannot be logically derived from the authorized evidence alone.

In practice, residual errors in tracing or verification can still occur. To directly answer Q3 regarding the 13 successful attacks on Qwen3.6-27B (9.03% ASR), we analyzed all 13 cases using the failure categories in Appendix E.1 (Table 15):

Failure CategoryCount (Cases)Primary Cause & Representative Mechanism
Authority Boundary Error3 / 13: #113, #114, #115Coarse segmentation: Injected claims in a flight response or HIGH-authority address/contact fields inherit the outer field's permission.
Dependency Tracing Error4 / 13: #53, #54, #80, #98Incomplete candidate coverage: The tracer misses recommendation batches or checks global comparisons over incomplete channel/company subsets.
Fact Interpretation Error6 / 13: #48, #50, #52, #95, #96, #100Verifier semantic errors: The verifier loses entity–rank correspondence, confuses an in-body Alice: claim with the actual sender, or misinterprets multi-constraint/sub-task requirements.

Among the 13 successful attacks, 4 were attributed to dependency tracing errors, representing 2.78% of all 144 attack cases. These errors primarily involve completeness checks over multi-entity comparisons. We have added this breakdown and case analysis to Appendix E.1 of the revised manuscript.

Thank you for the authors' response, which partly addressed my concerns. However, this does not change my overall view of the paper. Nevertheless, I am willing to lower my weight, and if other reviewers hold different opinions, I would also be glad to see the AC lean towards accepting their views.

Thank you for considering our response and for your openness to other reviewers’ perspectives.

We appreciate that our response has partially addressed your concerns. Could you please clarify which concerns remain unresolved and are most important to your overall assessment? Understanding these specific points would help us provide a focused clarification and make the remaining issues clearer for the discussion.

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

This paper investigates parameter poisoning, a form of indirect prompt injection where attacker manipulates critical tool arguments. The authors propose AuthorityFlow, a defense framework that verifies whether tool parameters are derived from authorized information sources. The framework consists of three stages: constructing task-specific source authorization boundaries, tracing the evidence supporting candidate parameter values, and verifying both semantic support and source authorization before tool execution. The authors also introduce FactAuthBench, a benchmark comprising 144 paired benign and adversarial cases across four tool-interaction scenarios. The evaluation results show that AuthorityFlow reduces ASRs while maintaining relatively high BU.

Critical strengths

The paper investigates a practically relevant attack surface in LLM agents, where attackers manipulate tool parameters without changing the intended action. This highlights a limitation of existing instruction-level prompt injection defenses, which may fail to detect such attacks. The proposed FactAuthBench further enables systematic evaluation of parameter poisoning, and the experimental results demonstrate that several existing defenses remain vulnerable to this threat.

Critical weaknesses
  1. A key concern is whether source authorization is sufficient to determine the legitimacy of parameter modifications. AuthorityFlow verifies whether a parameter is supported by an authorized source, but a lower-trust source may still contain legitimate and necessary updates, especially when authoritative records are outdated. For example, in Figure 2, a hotel review reporting a new address could probably reflect a relocation that is not in the official record. The proposed mechanism does not appear to distinguish this case, which potentially results in blocking legitimate parameter updates. This raises concerns about the applicability of the framework in realistic and dynamic environments.

  2. The evaluation does not adequately assess whether AuthorityFlow rejects legitimate parameter changes derived from lower-trust sources. FactAuthBench primarily considers scenarios where attacker introduces incorrect parameter values, while benign cases do not systematically cover legitimate updates from lower-trust sources. Therefore, BU in the paper may not fully capture the false rejection rate in realistic workflows. Specifically, this is significant given that AuthorityFlow already reduces BU from 90.28% to 82.64% on Qwen3.6-27B. Evaluating paired benign and malicious updates with similar source provenance would help establish whether the reported security improvements can be achieved without excessive restrictions on legitimate tasks.

Questions for authors

Q1. How does AuthorityFlow distinguish malicious parameter poisoning from legitimate parameter updates when both originate from lower-trust sources? In Figure 2, for example, how would the framework handle a genuine hotel relocation reported in a review?

Q2. The supplementary implementation restricts LOW-trust fields to record selection. How does AuthorityFlow handle legitimate updates that necessarily rely on such fields? Is this restriction a fundamental design choice, or can it be relaxed without compromising security?

Q3. Could the authors evaluate paired benign and malicious parameter updates with comparable source provenance, including cases where authoritative records are outdated? Reporting the false rejection rate on legitimate updates would help clarify whether the security–utility trade-off observed on FactAuthBench generalizes to more dynamic settings.

5 comments

We greatly appreciate your expert feedback and your insightful concerns. Your concerns and questions are responded to as follows:

We have revised the manuscript to address the comments below. The changes are highlighted in blue in the revised PDF.

Weakness 1 & Question 1: How does AuthorityFlow distinguish malicious parameter poisoning from legitimate parameter updates when both originate from lower-trust sources? In Figure 2, for example, how would the framework handle a genuine hotel relocation reported in a review?

Such a case (where authoritative records are outdated and parameter updates must be obtained from lower-trust sources) can be regarded as a finer-grained authorization version of AuthorityFlow. Even within low-authority free-form text regions such as email bodies, messages, or reviews, parameter updates can be distinguished by whether they originate from an authorized updating entity. When a low-authority content region is bound to a verified entity identity, AuthorityFlow separates legitimate dynamic updates from malicious parameter poisoning.

Let us use the hotel relocation example in Figure 2 to explain:

Specifically, as described in Section 3.2 and Appendix B.2, AuthorityFlow does not treat all low-authority text uniformly during source segmentation and runtime observation binding. Instead, it preserves each record's identity and structured metadata (such as system-verified sender headers or author roles with HIGH authority) and associates them with the corresponding LOW-authority free-form text within the same record:

  • When a relocation or update claim is bound to the target entity's verified identity: When an official database record is outdated, a genuine update may originate from a record bound to the entity's verified identity (e.g., an official relocation notice posted by the hotel's verified account). When the task context permits adopting the entity's latest communication, the compiler combines this high-authority identity metadata with the task authorization rules in Algorithm 1 to mark the target fact in that specific record as AUTHORIZED with VALUE_INPUT permission, allowing the legitimate update to proceed.
  • When a relocation claim comes from an unverified third-party review (as in Figure 2): The surface wording of unstructured text alone cannot establish authenticity because an attacker can easily fabricate an equally plausible relocation claim. When the user simply asks to find the hotel's address and create a calendar event, and the relocation claim comes solely from an unverified third-party review without official identity backing or explicit user delegation in the prompt, it lacks the required entity-identity binding. Intercepting the candidate parameter and marking it as RECHECK is therefore the intended behavior, preventing the agent from silently adopting unilateral third-party claims while allowing downstream recovery to fall back to the protected official record.

Question 2: The supplementary implementation restricts LOW-trust fields to record selection. How does AuthorityFlow handle legitimate updates that necessarily rely on such fields? Is this restriction a fundamental design choice, or can it be relaxed without compromising security?

Restricting LOW-authority fields to SELECTOR_INPUT is a baseline default policy configured for standard tasks where external free-form text is not expected to supply parameter values. When legitimate updates necessarily rely on such fields, AuthorityFlow relaxes this restriction on a task-specific basis through the compilation mechanism in Section 3.2 (Eq. 4) and Appendix B.2 (Algorithm 1). Accordingly, this restriction can be relaxed without compromising security, because the elevated permission is strictly fact-scoped, while the region's global base authority B(r)B(r) remains LOW to block unauthorized influence on other parameters or from unverified sources. Consequently, LOW-authority fields are not confined to SELECTOR_INPUT, and can safely support DECISION_INPUT and VALUE_INPUT whenever warranted by the task.

Weakness 2 & Question 3: Could the authors evaluate paired benign and malicious parameter updates with comparable source provenance, including cases where authoritative records are outdated? Reporting the false rejection rate on legitimate updates would help clarify whether the security–utility trade-off observed on FactAuthBench generalizes to more dynamic settings.

Following your suggestion, we constructed and evaluated [25 Clean + 25 Attack] paired parameter-update cases with comparable source provenance (both residing in low-authority free-form text such as email bodies, messages, or documents), where authoritative records are outdated. In each paired case, the protected official record holds an outdated value while an update claim appears in low-authority text. Under the benign update setting, parameter updates originate from a record bound to an authorized updating entity or explicitly delegated by the user. Under the malicious update setting, a competing update claim with the exact same source field type and comparable phrasing originates from an unauthorized third-party record. Averaged across 3 independent runs per case to account for inference randomness, the results are shown below:

Evaluation SettingClean BU ↑Legitimate Update FRR ↓Attack ASR ↓
AuthorityFlow on Outdated-Record Dynamic Updates96.0%4.0%0.0%

AuthorityFlow achieves 96.0% Benign Utility (BU) with a low False Rejection Rate (FRR) of 4.0% on legitimate updates, while restricting the Attack Success Rate (ASR) of malicious updates to 0.0%. These results confirm that the security–utility trade-off of AuthorityFlow observed on FactAuthBench generalizes well to dynamic settings requiring legitimate updates from low-authority sources. We have added these experiments and discussions to the revised manuscript.

AuthorsOpenReview ↗

Anticipating Your Reply as Discussion Deadline Approaching

We appreciate your time and insightful feedback on our submission. In our rebuttal and revised manuscript, we have thoroughly responded to all of your comments. With the discussion window closing soon, we wanted to check whether our explanations have resolved your concerns. We are more than willing to address any remaining points before the deadline.

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

The paper studies parameter poisoning: an agent invokes the intended tool, but attacker-controlled content changes a critical argument, such as the payment recipient or meeting location. The proposed defense, AuthorityFlow, constructs task-specific source permissions before execution, reconstructs the evidence supporting each argument, and checks both factual support and source authorization. The authors also introduce FactAuthBench, containing 144 paired clean and attack cases across four AgentDojo environments.

On Qwen, AuthorityFlow reduces attack success from 93.06% to 9.03%, while benign utility decreases from 90.28% to 82.64%. An optional repair stage improves task completion under attack from 27.08% to 58.33%. Additional experiments cover other agent and verifier models, component ablations, computational cost, and a small defense-aware attack set.

Critical strengths

The paper addresses a concrete failure mode with a useful authorization model. An agent can perform the right operation on the wrong recipient, amount, or location. Separating semantic support from permission to determine a parameter is a sensible response. Distinguishing selector, decision, and value inputs makes this more precise than treating an entire tool response as trusted or untrusted.

The experiments show a substantial security improvement while preserving much of the clean-task performance. The reduction in attack success holds across the main Qwen and GPT-4o experiments. The ablations also provide evidence that source authorization and semantic support contribute separately. Reporting task completion under attack, including recovery results, helps distinguish useful protection from simply blocking execution.

Critical weaknesses

The evaluated authorization policy is more restrictive than the paper’s general task-aware framing suggests. The compiler prompt in Appendix B.4 allows low-authority free-form content only selector-level permissions. This leaves an important case untested: a user legitimately asks the agent to obtain an amount, date, or destination from an email body or document. The clean counterparts remove attacker content, but do not establish performance when external text must legitimately determine these values. It is therefore unclear how much of the result comes from task-specific authority reasoning versus a restrictive field-use policy that fits the benchmark.

The robustness evidence does not sufficiently test the learned tracing and verification components. Appendix D evaluates 30 fixed variants across 10 tasks, without feedback-driven attack search. This is useful preliminary evidence, but the tracer and semantic verifier still process attacker-controlled text, and their dependency certificates are not independently evaluated for completeness. Checking that cited source IDs exist cannot establish that all relevant dependencies were included. The reported attribution-forgery failure illustrates this gap. These limitations make the broader robustness conclusions premature.

Questions for authors

Clarification: Is the restriction that low-authority text receives only selector permissions applied throughout the reported experiments? How does the system handle a task such as “pay the amount listed in this invoice,” where document content must legitimately supply a value?

Clarification: What information specifies attacker-control boundaries during base-authority construction? Is this ordinary application metadata supplied equally to applicable baselines, or does it require benchmark-specific annotation?

Assessment-changing experiment: Can you evaluate feedback-driven attacks against the tracer and verifier, and manually audit whether their certificates omit necessary dependencies? This would help establish whether the programmatic authorization check receives reliable inputs.

Assessment-changing comparison: How does AuthorityFlow compare with a simpler field-level policy checker given the same source metadata? This matters because Table 13 reports an average runtime of 438.47 seconds, versus 31.94 seconds without defense. A simpler control would help establish the benefit of the additional reasoning and cost.

3 comments

We greatly appreciate your expert feedback and your insightful concerns. Your concerns and questions are responded to as follows:

We have revised the manuscript to address the comments below. The changes are highlighted in blue in the revised PDF.

Weakness 1 & Clarification 1: Is the restriction that low-authority text receives only selector permissions applied throughout the reported experiments? How does the system handle a task such as "pay the amount listed in this invoice," where document content must legitimately supply a value?

No, restricting low-authority text to only selector permissions (SELECTOR_INPUT) is not a static restriction applied across all tasks. In our standard FactAuthBench experiments, it serves solely as a default guardrail for unmentioned external text (Appendix B.4), preventing unverified claims from overriding official records during routine tasks. We explicitly account for scenarios where users legitimately request values from low-authority sources in both our framework design and supplementary code.

For a task such as "pay the amount listed in this invoice," where document content must legitimately supply a value, our system handles it as follows: AuthorityFlow extracts explicit user facts and captures user intent via task delegation spans. Because authorization queries prioritize task-specific permissions before falling back to high-authority source rules (Algorithm 1), an explicit user request to extract a value from a low-authority region binds the corresponding delegation span and grants that target fact (e.g., the invoice amount) AUTHORIZED status with VALUE_INPUT permission. This task-level authorization is strictly localized to the designated fact. It does not elevate the document's global base authority to HIGH. In such cases, verifying the intrinsic validity of the explicitly requested low-authority value itself lies outside the scope of our threat model.

The underlying task-use authorization mechanism is already described in Appendix B.2 (Algorithm 1), and task spans providing constraints or delegation are specified in Appendix B.3 (Table 9) of the original manuscript.

To directly evaluate scenarios where external unstructured text must legitimately determine parameter values, we additionally constructed and evaluated [25 Clean + 25 Attack] paired cases (included in the supplementary material), where legitimate tool argument values must be obtained from low-authority text. Each case is evaluated over 3 independent runs to mitigate potential inference variance. Experimental results show that AuthorityFlow achieves 96% Benign Utility (BU) under this setting while restricting the Attack Success Rate (ASR) from competing untrusted sources to 0%. We have clarified this in Section 3.2 and Appendix B.4 of the revised manuscript.

Clarification 2: What information specifies attacker-control boundaries during base-authority construction? Is this ordinary application metadata supplied equally to applicable baselines, or does it require benchmark-specific annotation?

During base-authority construction, the information that specifies "attacker-control boundaries" is the public tool specification C\mathcal{C}, including tool descriptions, return structures, and field definitions, as described in Section 3.2. The phrase "attacker-control boundaries" in Appendices B.2 and B.4 refers to whether a field is system-maintained or externally editable based on its field properties in C\mathcal{C} (as defined in Appendix A.2). Before observing runtime data, the planner infers the base authority B(r)B(r) of each source region from these public field descriptions by assigning HIGH authority to system-maintained structured fields such as transaction IDs or official addresses, and LOW authority to free-form text fields designed to hold external content such as email bodies, reviews, or transaction notes, without knowing in advance which runtime field instance is modified by an attacker.

Accordingly, this is ordinary application metadata supplied equally to the agent and all applicable baselines, and it does not require benchmark-specific annotation. In AuthorityFlow, base-authority construction is independent of FactAuthBench's ground-truth evaluation labels, and the defense module does not use benchmark-specific attack annotations. As detailed in Sections 2.1, 2.2, and Appendix A.4, the ground-truth labels marking attacked regions are used only by the post-execution evaluation script to compute the ASR. We have clarified the source of the authority boundaries in Appendices B.2 and B.4 of the revised manuscript.

Weakness 2 & Assessment-changing experiment: (1) Can you evaluate feedback-driven attacks against the tracer and verifier, and (2) manually audit whether their certificates omit necessary dependencies? This would help establish whether the programmatic authorization check receives reliable inputs.

(1) Evaluation of feedback-driven adaptive attacks.

Following AgentVigil [1], we evaluated end-to-end adaptive attacks across the 30 FactAuthBench seeds using Qwen3.6-27B for the main agent, attack generator, and auxiliary models. Each seed underwent up to 50 UCB-guided rewrite attempts (cycling through rephrase, shorten, expand, and similar-variant transformations), re-executing the full agent workflow from scratch at each step:

Attack SettingSeedsMax Attempts / SeedUnbroken SeedsBypassed Seeds (ASR)
Feedback-driven adaptive search305029/30 (96.7%)1/30 (3.3%)

Across up to 50 search steps per seed, 29/30 seeds (96.7%) remained unbroken, with only 1 seed (Case #50) bypassed, confirming strong robustness under iterative attack search.

[1] AgentVigil: Generic Black-Box Red-Teaming for Indirect Prompt Injection against LLM Agents.

(2) Manual audit of dependency certificate completeness.

Auditing the certificates across adaptive trajectories confirms that the programmatic authorization check receives complete and reliable dependency inputs:

  • Why omitting LOW-authority dependencies fails: Because the verifier requires frozen cited evidence to logically derive the candidate parameter on its own, rewrites that coax the tracer into omitting an influential LOW-authority source leave the remaining HIGH-authority fields unable to semantically support the manipulated value, causing the verifier to reject the certificate as UNSUPPORTED.
  • Audit of the single bypassed seed (Case #50): The attacker injected a forged Alice: Has anyone seen my coffee mug? snippet into Charlie’s LOW-authority message body in general. The tracer cited the body as SELECTOR_INPUT and the protected recipient="general" (HIGH) as VALUE_INPUT, satisfying the programmatic policy. The verifier accepted the in-body identity claim without checking that the structured sender="Charlie" did not match Alice. This was a Fact Interpretation Error (Appendix E.1), not omission of the attacker-controlled field. We have added this analysis to Appendix D of the revised manuscript.

Assessment-changing comparison: How does AuthorityFlow compare with a simpler field-level policy checker given the same source metadata? This matters because Table 13 reports an average runtime of 438.47 seconds, versus 31.94 seconds without defense. A simpler control would help establish the benefit of the additional reasoning and cost.

We implemented and evaluated two simple field-level policy checkers across all 144 paired FactAuthBench cases using the exact same source metadata and without purification: (1) a literal-match checker requiring candidate parameters to appear verbatim in a HIGH-authority field, and (2) a single-step LLM attribution checker that identifies source dependencies in one call and rejects whenever any LOW-authority field is involved:

Method (without Purification)Clean BU ↑Attack ASR ↓
Literal-Match + Static Base-Authority Checker21.53%14.58%
Single-Step LLM Attribution + Static Base-Authority Checker43.75%13.19%
AuthorityFlow (w/o Task-use Authorization)59.72%7.64%
AuthorityFlow (Full)82.64%9.03%

These results show that simple field-level checkers cannot simultaneously maintain utility and security. Literal matching cannot validate derived values absent verbatim from source fields, such as the date shift in Case #26. Single-step attribution over-rejects valid multi-source dependencies: in Cases #50 and #51, a LOW-authority message body locates the record while a HIGH-authority recipient supplies the channel. By distinguishing SELECTOR_INPUT from VALUE_INPUT, AuthorityFlow reaches 82.64% BU at 9.03% ASR.

The 438.47s runtime in Table 13 reflects the computational trade-off for these security and utility gains, primarily because tool calls contain multiple arguments that our prototype audits sequentially while logging full certificates (Appendix C.3). In deployment, caching task policies, auditing arguments in parallel, and selectively checking externally influenced parameters can substantially reduce latency without sacrificing performance, which remains a priority for future work (Section 6).

AuthorsOpenReview ↗

Anticipating your response

Thank you for dedicating your time to reviewing our paper. We have carefully addressed all of your comments in our rebuttal and updated the manuscript accordingly. As the discussion deadline approaches, we would like to inquire if our responses have adequately addressed your questions and concerns. Please let us know if any additional details or clarifications would be helpful before the period closes.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.