Users often let an agent take the arguments of an action from what it reads: "set up the meeting in Quinn's email", "message everyone in #general", "refund whoever paid me for the deposit". Defenses against indirect prompt injection either forbid untrusted content from choosing such arguments, which blocks these tasks, or judge whether an action looks legitimate. We instead read the request as a statement of delegated authority: it says, often implicitly, which records and lookups may supply which arguments. DelegationScope parses this delegation from the request alone, admits a sensitive value only if a record the user authorized contains it, and asks a verifier that sees only authorized records to settle values that other content also mentions. We describe attacks that defeat record-level provenance checks, and DelegationBench, 216 tasks whose delegation is known. In preregistered held-out evaluations, DelegationScope stops all 96 attacks that plant the attacker's value in the named record, 42 of which pass a provenance baseline, and on AgentDyn it lowers attack success from 138 to 81 of 560 while completing more tasks than that baseline, though fewer than no defense. Across five executors on AgentDojo, it cuts attack success by 29–52% where injections succeed and costs at most three of 97 clean tasks where they do not. DelegationBench shows where reading delegation fails; the revised DelegationScope+ lowers attack success to 9 of 194 on AgentDojo, from 31 without defense and with no loss of clean tasks, and to 62 on AgentDyn. CaMeL and Progent, run in the same setting, block more attacks with a 9B executor but complete 6 to 69 fewer of the 97 tasks, mostly ones whose arguments the user delegated. Injections inside the record the user named remain beyond any provenance rule.
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.Reviewer_wkjkOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary
This paper addresses how to prevent prompt injections from tampering with retrieved values when a user instructs an agent to extract recipients or account numbers from emails or files. The authors first determine the allowable source records for each parameter based on the user's request. Any value outside this scope is rejected, and ambiguous cases are sent to a secondary model limited to authorized content for verification.
Critical strengths
Figure 1 clearly illustrates the entire workflow.
Critical weaknesses
The novelty is pretty limited. The core idea is basically just restricting which sources key parameters can come from.
The experimental gains are pretty marginal too. As shown in Figure 3, in settings like gpt-oss-20b, Clean Utility and Safe Completion of Tool Filter actually go up, while ASR drops, which means it is better than the proposed method.
Questions for authors
I think there are issues with the experimental setup. For Gemini 3.8 Flash and DeepSeek V4.1 Flash, the ASR for all methods is zero, which suggests the chosen attack methods are too weak. Also, frontier models like GPT or Claude are not tested.
A lot of details are missing. The paper doesn't provide a full token usage across different methods and settings, making the actual token overhead questionable.
The paper addresses the issue that tool-using agents are susceptible to prompt injections in the content they read, notably the injection of malicious values for arguments to tool-use calls.
This paper tackles the problem of determining the admissibility of argument values based on their provenance, specifically in the context of argument delegation where a user refers to external sources/records from which values should be retrieved.
Existing methods like PACT and CaMeL already use the provenance of argument values to determine and enforce their admissibility.
However, these do not explicitly account for “argument delegation”, where provenance admissibility is specific to a user’s query and the “delegated authority” it defines.
The contributions are:
Formalizing “delegated authority” where the admissibility of argument values is determined by their provenance or record-level admissibility (“grant”), which is in turn jointly determined by the argument, query, and record type.
Operationalizing “delegated authority” into “DelegationScope” a 3-stage pipeline where queries are parsed into grants, argument value extractions from record reads are monitored and logged, and tool/argument calls are verified based on grants and other heuristics for admissibility before execution. This method generally improves utility/safety trade-offs compared to models without defenses and overly-strict defense baselines that refuse delegated arguments.
Evaluating prompt injection mitigation under argument delegation with “DelegationBench”, a new benchmark based on AgentDojo with finer grained record-contact logging that surfaces and characterizes delegation misreading as a key failure mode.
Proposing an improved “DelegationScope(+)” which mitigates this failure mode and others with various patches and heuristics.
Experiments are conducted across various models, benchmarks and baselines, as well as ablations of the proposed method.
Critical strengths
The main problem of argument delegation tackled by the paper, and the resulting opportunity for improving utility/safety trade-offs, is compelling and meaningful.
While there is concurrent work which formalizes and addresses the same fundamental problem (https://arxiv.org/abs/2608.27496), I see this as concurrent work which does not necessarily undermine the significance and impact of this paper. Moreover, this paper focuses on argument delegation specifically which is more concrete and well-specified problem than the general problem of “delegation” addressed by the concurrent work.
I also find the proposed DelegationBench benchmark to be the most significant contribution of the paper, especially as it addresses a real gap in existing benchmarks by disentangling and fine-graining argument delegation in a way that is monitorable and seemingly enables more novel and generalizable insights into models’ failure modes (notably re: misreading delegations).
Critical weaknesses
While the proposed DelegationScope(+) methods are not particularly strong contributions (largely involving the engineering of scaffolds based on brittle heuristics that are much less well-developed than e.g. PACT or CaMeL and unlikely to generalize beyond the benchmark settings around which they were designed), I found the demonstration of developing a naive approach, evaluating it to find failure modes, and improving the approach (while keeping the same high-level 3-stage approach) to be much more compelling as a demonstration of the DelegationScope’s potential not as a specific method but as a general and flexible approach that can be extended or ablated for different goals such as mitigating known failures (but also for e.g. generalizing to new domains, or modulating the utility/safety trade-off, which was not done but would go a long way to substantiating this potential strength). Moreover, DelegationScope makes much more sense to me as an extension of PACT or CaMeL which already admit provenance-based admissibility in addition to much more comprehensive features not covered by DelegationScope. With the current results and methodology, the significance and soundness of the results is difficult to gauge as the method seems very likely overfit to benchmarks with brittle heuristics. The paper would be much stronger if it focused on the fine-grained evaluation and characterization of prompt injection under argument delegation, with DelegationScope as a high-level approach which flexibly admits simple heuristics to address this problem in a way that generalizes across domains, rather than a specific method defined by these questionable heuristics that are unlikely to generalize.
Beyond this fundamental weakness in claimed contribution and soundness, the presentation of the paper itself also undermines my readiness to accept it. The claimed contribution of a “soundness result” and “proof” is overstated and occupies space that would be much better used defining and contrasting the method to existing methods instead. Currently, Section 3.4 ambiguously conflates the PACT baseline used in the results and the failures of DelegationScope that lead to DelegationScope+. More generally, understanding what sets DelegationScope aside from existing methods was not clear from the paper and required a lot of back and forth with references. As far as I can tell, the claim that PACT and CaMeL “are secure, but they cannot complete tasks whose arguments the user delegated to data” is not accurate and reflects more the choice of using stricter delegation-agnostic admissibility constraints even though these methods would admit delegation-aware constraints. Terminology is also used inconsistently throughout the paper in a way that makes it difficult to follow and unambiguously understand the concrete implementation of the method.
Asking an agent to extract action parameters from external content does not hand every document the agent reads the authority to decide those parameters. "Schedule the meeting Quinn mentioned in their email" authorizes the invitee list to come from that email, not from a file the agent later searches up — and an attacker need not induce a new action, only swap the recipient inside an otherwise legitimate calendar call. DelegationScope represents this as grants (ρ,s,ref): a parameter role such as recipient, account, channel or URL may take its value from a source class — named record, referenced record, query result, directory. A parser that reads only the user request extracts the grants; a monitor checks that sensitive parameters appear in the request, in approved lookup metadata, or in approved record bodies, excluding values the agent itself wrote and read back; and when the value also appears in unauthorized text, or an authorized record holds several candidates, a validator in a clean context chooses using only the authorized material, with rejections fed back to the executor. DelegationScope+ adds exact identifier matching, record-uniqueness constraints, address and link checks in free text, and more aggressive validator invocation.
The contribution is best read as a delegation-aware provenance mechanism plus an evaluation framework for diagnosing delegation errors; the components themselves — clean context, provenance checking, string matching, a second-model check — are not individually new, and the propositions mainly delimit scope rather than establishing deep new theory.
Results with the primary executor (Qwen3.5-9B) do not generalize into "safer and more usable":
Benchmark
Condition
Clean
Safe completion
Attack success / contact
AgentDojo
none / DS / DS+
90 / 87 / 90 of 97
142 / 148 / 155 of 194
31 / 22 / 9 of 194
AgentDyn
none / DS / DS+
33 / 17 / 18 of 60
240 / 132 / 127 of 560
138 / 81 / 62 of 560
DelegationBench
none / DS / DS+
214 / 154 / 172 of 216
713 / 656 / 762 of 1200
—
AgentDojo is a strong end-to-end result: attack success falls 31 to 9, about 71%, with clean utility held at 90. AgentDyn is a risk-utility trade, not an improvement: attack success falls 138 to 62 while clean utility falls from 55% to 30% and safe completion from 42.9% to 22.7%. On DelegationBench, DelegationScope+ reaches the most safe completions of any condition but still loses 42 clean tasks against no defense, on the benchmark built for delegation. These differences belong in the paper's conclusions, not only in the experiments section.
Critical strengths
1. The problem formulation is right, the architecture divides trust cleanly, and the attacks written against simple provenance show the idea has teeth. Legitimate tasks and attacks both require the agent to take values from external content, so neither forbidding external influence nor relying on the executor to judge whether an action "looks reasonable" is viable; asking which source is authorized for which parameter role is a better question than asking whether a whole tool call is topically related to the task. The division is structural rather than prompt-based: the parser never touches tool output, the validator sees only material judged authorized, and the monitor enforces source constraints by rule, so a poisoned executor proposing a malicious parameter does not by itself produce an executed call. On the adaptive set this pays off measurably — the provenance baseline is attacked successfully 42 times against 0 for the full method, with safe completion under attack rising from 54/96 to 95/96 and control tasks still completing. Figure 4's case is the clearest illustration: an attacker address sits as a historical aside inside a legitimate email while other material induces the agent to adopt it, and because the validator reads only the legitimate email it can separate "an address that was mentioned" from "the address the user wants invited". Checking only whether the attacker's address appears somewhere in the designated record is genuinely not enough, and isolated semantic adjudication adds something real.
2. DelegationBench is a diagnostic instrument, not a leaderboard, and the disclosure standard is high. Tasks carry a known authorization structure and distinguish named records, referenced records, queries and directories, and the paper reports failure sources — wrong record selection, missed referenced grants, a web fetch misread as a query — rather than one aggregate. The oracle-parser experiment separating parser error from monitor error is good design. Taken with the AgentDojo result — attack success 31 to 9 at unchanged clean utility, out of sample for the uniqueness rule — and the adaptive-set result, this is enough demonstrated substance that the weaknesses below read to me as a revision agenda rather than as grounds for rejection. The paper also reports a preregistered prediction that failed, attacks that never fired, invalid episodes, an output-length change, and settings where its own method loses substantial utility; it states plainly that injections inside an authorized record, wrong choices among legitimate metadata candidates, and uncovered actions are outside what source rules can resolve. I take that as a strength and not as evidence of sloppiness — but it does mean several of the limitations below are consequences the authors have already seen, which makes the question whether the claims were narrowed to match.
Critical weaknesses
1. On the benchmark built for this method, the validator — the component carrying the novelty — makes every headline metric worse, and the simple baseline it is meant to beat already contains injections better. Table 4, Qwen3.5-9B on DelegationBench, 216 clean and 1,200 attacked episodes:
Condition
Clean /216
Safe /1200
Named record /336
Other records /672
Metadata /192
No defense
214
713
233
212
2
Provenance baseline
143
588
202
2
0
DelegationScope
154
656
178
26
2
Without validator
176
672
192
2
2
DelegationScope+
172
762
152
6
4
Removing the validator improves clean utility by 22, safe completion by 16, and other-record attacker contact by a factor of thirteen. The authors explain the mechanism, and it is the right explanation: a misnamed old email enters the validator's context, the validator selects the attacker's address from it, and the rejection feedback then recommends that address to the executor as an authorized candidate. Proposition 2 says the validator cannot enlarge the allowed set for a fixed candidate call; it does not say the validator reduces attack success in a closed loop with retries, feedback and changed behavior, and the paper's own ablation shows the latter is false here. The adaptive set shows the validator has real value, so the finding is not that the component is worthless — it is that its effect in a feedback loop is unresolved, and the paper argues safety from a local set-inclusion property while its main delegation benchmark contradicts it. The authors have already located the mechanism, so the remedy is identified and cheap: ablate the feedback channel separately from the validator, and either gate that channel or stop returning candidate values in rejection messages.
The same table undercuts the comparison that motivates the method. The provenance baseline reaches 2 of 672 other-record contacts — equal to the no-validator ablation and thirteen times better than the full method. Section 4.4 reports "DelegationScope cuts contact through unnamed records from 246 to 107 and from 291 to 72" for Mistral and gpt-oss, but those comparisons are against no defense; the provenance baselines in Table 9 are 23 and 21, far better than DelegationScope's 107 and 72. Read across Table 9, DelegationScope is beaten by the simple baseline on all three metrics with Mistral (101/359/23 against 88/306/107), and DelegationScope+ is worse than DelegationScope on all three with gpt-oss (156/577/72 against 153/571/75). What the full method does demonstrably buy is paraphrase robustness — under paraphrase the baseline drops to 92 clean and 386 safe while DelegationScope holds 183 and 705 — and that, rather than injection containment, is the benefit the evidence supports. The paper should say so.
2. The propositions constrain the authorization the algorithm infers, not the authorization the user gave, and the text repeatedly elides the two. Write G⋆(q) for what the user actually delegated and G(q) for what the parser and matching rules infer. Proposition 1 guarantees that a value appearing only in a record that is neither named nor referenced fails the provenance check. It does not guarantee that a record the user never authorized will not be classified as named or referenced — and once that misclassification happens the proposition's premise fails, so it can no longer explain the system's safety. The paper's own REPLY failure is exactly this: an old email is treated as an authorized record and the validator then reads the injection inside it. The introduction's claim that the validator never sees content the user did not authorize must therefore be narrowed to content that the current parsing and matching mechanism judged unauthorized, and the gap between those is the paper's central unsolved difficulty rather than a detail.
The parser is not close to carrying the stronger reading. Agreement with silver labels on AgentDojo is 0.62 on the four-way classification with 0.59 named-record recall, and stronger models do not change this decisively; on DelegationBench not one original REVIEWER request and not one WEBSITE request is parsed fully correctly. That is systematic failure on delegation types, not a few edge cases. And the oracle-parser experiment shows part of the reported security was never authorization enforcement at all: with gold grants, clean completion rises 154 to 190 for DelegationScope and 172 to 197 for DelegationScope+, while attacker contact in referenced files and pages rises from 1/96 to 45/96 and from 4/96 to 34/96. The authors call this under-granting an accidental protection, which is the honest description. So the question "did the system correctly block an over-reach, or did it merely fail to let the task proceed as the user intended, so the attack had no opportunity" is unresolved for a material share of the gains — and the two must not be reported as one kind of safety. Table 16 shows why the metric itself needs restating: outside-named-record contact rising 10 to 39 under gold grants is mostly the authorized referenced records (4 to 34), leaving 6 to 5 once those are removed. Outside the named record is not outside the delegated authority, and the main tables should classify by in-scope versus out-of-scope under gold delegation.
Three specification problems compound this in a paper whose contribution includes soundness claims. (i) A grant binds a role to a source, but Algorithm 1's named-record branch checks only that the record is named and the value appears, with no explicit check that the record is authorized for the role ρ in question; the metadata branch likewise does not visibly carry the query or directory grant. So if the user authorizes meeting participants from email A and the payment account from invoice B, it is unclear whether an account number that happens to sit in email A is admitted as the payment account. Pseudocode cannot establish a code defect, but the role-to-source binding rule must be stated. (ii) Line 9 reads, in effect, "if the record is referenced and a referenced grant exists, or v is the unique value of its type in the record, mark the source" — the and/or grouping is ambiguous under normal precedence, so the second clause may bypass the referenced condition, and the grant branch does not explicitly require v to occur in the record body. (iii) The first rule admits any value appearing as a complete token in the user request, which is too permissive as authorization semantics: "Send the report to Alice, not to Bob" contains Bob's address. What the method implements is a source-appearance constraint, not natural-language authorization.
Questions for authors
What is the validator's net effect, and is the rejection-feedback channel safe? On DelegationBench, removing it improves clean utility (176 against 154), safe completion (672 against 656) and other-record contact (2 against 26). Please report the validator's false-acceptance and false-rejection rates under correct and incorrect grant sets, and ablate the feedback message that returns candidate values to the executor separately from the validator itself — the described failure runs through that channel. Given that Proposition 2 covers only a fixed candidate call, what is claimed about the closed loop?
Please align the grant definition, Algorithm 1, the released code and the propositions on role binding. Does the named-record branch verify that the record is authorized for the specific role, or are named records pooled into one global allowed-source set? Concretely: with participants granted from email A and the payment account from invoice B, is an account number occurring in email A admitted as the payment account? Please also disambiguate line 9's and/or grouping and state whether the grant branch requires the value to occur in the record body.
Please restate the security claims in terms of inferred rather than actual authorization, and classify the main tables by in-scope versus out-of-scope under gold delegation rather than by named versus outside-named. With gold grants, outside-named contact rises 10 to 39 while authorized referenced records account for 4 to 34 of that, so the headline metric currently mixes legitimate referenced delegation, parser shortfall and genuine over-reach.
How much of the reported security is under-granting? Oracle grants raise clean completion 154 to 190 and 172 to 197 while raising referenced-record contact 1/96 to 45/96 and 4/96 to 34/96. Please report security conditioned on correctly parsed grants, so that protection from correct enforcement is separated from protection from refusing legitimate delegation.
Does the method still help once the simple baseline is compared on its own terms? The provenance baseline reaches 2/672 other-record contacts against DelegationScope's 26, beats DelegationScope on all three metrics with Mistral, and Section 4.4's "246 to 107" comparisons are against no defense rather than against that baseline. If the method's demonstrated advantage is paraphrase robustness (183/705 against 92/386), would you make that the claim?
Why does AgentDyn lose so much utility — clean 33 to 18 of 60 and safe completion 240 to 127 of 560 — and does any configuration recover utility there? Relatedly, since DelegationScope+ is worse than DelegationScope on all three gpt-oss metrics and the baseline beats DelegationScope with Mistral, could the conclusions be stated conditionally on executor and task structure rather than generalized from the primary executor? Note that DeepSeek and Gemini have no successful attacks even undefended, so those arms show only the defense's utility cost.
On query and directory delegation: metadata integrity establishes that a value is real in the system, not that the user asked for it this time. In QUIETEST, 35 of 48 in-channel attacks make Mistral post to the attacker's channel with no improvement under DelegationScope, because the channel legitimately exists. How should "may take a value from this candidate set" be separated from "correctly executed the user's selection rule" (quietest, latest, cheapest)? And since Proposition 4's premise requires two matches to have been seen, what happens when pagination, truncated search or reordering means the second match arrives after the action — please add read-order and retrieval-completeness tests.
Three evaluation-coverage items. (a) The agent-writes exclusion was never actually exercised: the original write-then-read attack was stopped by the validator, and in the follow-up the executor never performed the write, which the paper states — could a controlled write-reread-use trajectory be constructed? (b) AgentDojo uses one official attack template and the two lowest-numbered injection tasks per suite; a system whose contribution is a security boundary needs attack search aimed at its specific mechanisms (query scope, record matching, conditional facts, feedback candidates, cross-role values), and one conditional attack still succeeds 10/24. (c) DelegationBench is nine families of 24 generated mainly by substituting names, addresses and identifiers, with all identifiers preserved verbatim under paraphrase, so 216 tasks are not 216 independent structures; and the main table reports end-to-end paraphrase results only for the first paraphrase, with DelegationScope+'s paraphrase columns empty.
Statistical and reproducibility items. Episode-level exact sign tests treat highly correlated attacks on the same task as separate evidence while the intervals use task-level cluster bootstrap — could a task-level paired analysis, or a clustered permutation test, be used throughout with the multiple-testing treatment stated? Two totals do not close against the reported paired counts: oracle-parser clean completion differs by 36 (190 against 154) with paired wins 33:0, and DelegationScope against CaMeL differs by 61 (87 against 26) with 50:2 for a net of 48. If paired tests exclude invalid episodes that the totals count as failures, please state the inclusion criterion and the number of valid pairs. Invalid episodes also need a conditional report, since an errored episode that produces no countable attack can lower the observed attack rate, which matters most for gpt-oss on AgentDyn. Finally, Appendix A marks the parser prompt verbatim but elides five examples with placeholders, and the older validator ran under a 512-token cap that DelegationScope+ did not — please supply the examples and either truncation statistics or a budget-matched control.
On baseline attribution: the provenance baseline is your reimplementation of PACT's core rules rather than PACT, which supports "the attack defeats a record-level provenance rule" but not "the attack defeats PACT". For CaMeL, 36 clean tasks without policy against 26 with policy against your 87 means only 10 of the 61 gap is the policy, with the remainder in CaMeL's program generation on these executors — could the comparison separate base-architecture capability, policy cost and delegation-task cost? And against Progent (attack success 5 against DelegationScope+'s 9, with your paired test finding no significant difference), is the right claim a different trade-off rather than dominance, distinguishing what a prior system cannot express from what its default policy did not allow?
Thanks for you response and I appreciate for author's explanation. However, I think most of concerns are not resolved.
The proposed method can not work on the frontier model. Like the authors said, on the frontier model e.g. sonnet, the original ASR is relative low proposed method can not decrease ASR.
The proposed method is even lower than simple tool-filter on gpt-oss-120b.
No token usage is shown. The author only show qwen 3.5 9B. So it is hard for me to identify the trade-off between performance and efficiency.
will keep my score.
From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.
Thanks for you response and I appreciate for author's explanation. However, I think most of concerns are not resolved.
will keep my score.