WorksComputer Science
CapLite: Prompt-Injection Defense for Small Language Model Agents without Model-Written Security Artifacts
Abstract
Enforcement defenses against prompt injection, such as CaMeL, Progent, IPIGuard and DRIFT, ask the agent's own model to write a security artifact (a program, a privilege policy, a dependency graph or a constraint list) that code then enforces. We ask whether small language model (SLM) agents can be trusted to write these artifacts. Across 15 open-weight models, 13 of them between 1.7B and 12B parameters, they cannot: the policies, graphs and constraints that the agent's model writes admit attacks on 14 (Progent), 13 (IPIGuard) and 11 (DRIFT) of the models, and CaMeL's programs fail to run in up to 68% of episodes. We present CapLite, which derives its policy from the tool schemas, commits the write calls before any tool result is read, and admits a write only if every argument that decides whom or what it affects is stated in the user's request. This guarantees write integrity: injected text cannot add a write, and no write reaches a recipient, amount, object or destination that the user did not state. No attack succeeds in 13,935 attacked AgentDojo episodes. CapLite reaches utility under attack comparable to CaMeL's (29.0% vs. 27.2%) with fewer tokens than every other enforcement defense and than the undefended agent: 17.1k per episode, 18% of CaMeL's, and the highest utility per token of all enforcement defenses.
Introduction
A tool-using agent reads e-mails, files and web pages that anyone can write, and an instruction hidden in that content can redirect what the agent does [13, 8]. The defenses with the strongest guarantees take the decision out of the model’s context and give it to code. CaMeL runs a program in an interpreter that tracks where every value came from [7], Progent checks each call against a privilege policy (Shi et al., 2025), IPIGuard executes a tool dependency graph planned before any tool result is read [1], and DRIFT validates calls against a planned trajectory and parameter checklist (Li et al., 2025).
Each of these defenses enforces something the agent’s own model writes: CaMeL the program, Progent the policy, IPIGuard the dependency graph and DRIFT the trajectory and checklist. The enforcement is exactly as sound as this security artifact. All four were designed and evaluated mainly with large hosted models. Concurrent request-grounded authorization systems [10] (Ma et al. 2026b; Li et al. 2026b; Liao et al. 2026) also target large hosted models, and most of them have a model compile the authorization, which is again a model-written security artifact. Meanwhile, small open-weight language models (SLMs) are an increasingly common backbone for agents that run locally, on device or at scale [9, 15] (Shen et al. 2024). We ask whether SLM agents can be trusted to write their own defenses, and what can be guaranteed if they cannot.
We measure four enforcement defenses on 15 open-weight models with AgentDojo. Artifacts that decide what is allowed fail open: policies written by the agent’s model admit attacks on 14 of 15 models, IPIGuard’s graphs on 13 of 15, and DRIFT’s constraints on 11 of 15. Artifacts that decide what runs fail closed: CaMeL is breached in only 20 of 13,935 attacked episodes, but its programs fail to run in up to 68% of episodes and cost 94k tokens per episode. These failure rates show no trend with model capability, while the undefended agent follows injections more often as the model gets stronger.
An SLM agent does not need to write its own authorization. CapLite derives its policy from tool schemas by fixed rules and takes every security decision in deterministic code. A Planner that sees only the request commits the write calls before any tool result is read, a Binder fills each open argument by choosing among extracted candidates, and a Mediator admits a write only if every authority argument, such as a recipient, an amount, an object identifier or a URL, equals a value stated in the request. A model failure can drop a write or pick a wrong candidate, and injected text can neither add a write nor route one to a value the user did not state; we call this guarantee write integrity. No attack succeeds in 13,935 attacked episodes, as these properties predict, and CapLite reaches utility under attack comparable to CaMeL’s with 18% of its tokens. It uses fewer tokens than every other enforcement defense and than the undefended agent, and it gives the highest utility per token of all enforcement defenses.
Our contributions are:
Measurement. A study of four enforcement defenses on 15 open-weight models, which shows that security artifacts written by the agent’s own model inherit its failures across the whole range from 1.7B to 35B: artifacts that decide what is allowed admit attacks, and artifacts that decide what runs lose the task (Section 2).
Architecture. CapLite, a design in which the model proposes and code authorizes, combining committed writes, schema-derived field roles, exact request grounding and candidate-only binding (Section 3). Its two properties hold by construction, no attack succeeds in 13,935 attacked episodes, and ablations show
that the Mediator and the commitment of writes are each needed (§ 5).
Efficiency. CapLite uses fewer tokens than every other enforcement defense and than the undefended agent, and reaches utility under attack comparable to CaMeL’s with the highest utility per thousand tokens of all enforcement defenses (§ 5).
Can SLM Agents Write Their Own Defenses?
We call a model output a security artifact when the enforcer admits whatever it contains. For each of the 15 models, we run every defense with that model in all of its model roles, on the setup and metrics of § 4.
Artifacts that decide what is allowed fail open. Progent asks the model to write a privilege policy from the request and to update it after each call. The policies admit attacks on 14 of 15 models, 676 in total and up to 132 of 929 on Qwen3-32B (Figure 2). The same policies block 25–77% of the write calls the agent attempts under attack (Appendix § 10), and benign utility falls from 59.4% undefended to 43.8%, so a generated policy is wrong in both directions. IPIGuard’s planner commits a dependency graph and DRIFT’s a trajectory and parameter checklist that a validator enforces; IPIGuard is breached on 13 of 15 models (435 attacks) and DRIFT on 11 of 15 (214 attacks; Figure 2). DRIFT’s four clean models, LFM2.5-2.6B, Gemma-4-E2B, Gemma-4-E4B and Granite-4.2-8B, complete 4.7%, 9.5%, 6.7% and 4.7% of attacked tasks, so their zero comes from inaction.
Figure 2. Attack success rate of each defense on each of 15 models under important_instructions. Each cell gives the ASR in percent and, below it, the successful attacks out of 929 tool-goal episodes. Dark blue cells have no successful attack; gray cells have none because benign and attacked utility are below 10%, which comes from inaction. CapLite is the only defense without a successful attack on any model.
Artifacts that decide what runs fail closed. CaMeL’s interpreter enforces the authors’ data-flow policies on whatever program the model writes, and security holds: 20 successful attacks in 13,935 episodes, 17 of them on LFM2.5-2.6B. On 8 of the 15 models the final program is unrunnable in more than 15% of episodes, and on Granite-4.2-8B in 68%, where the model returns no code at all (Appendix § 10). The causes are format, syntax and interpreter errors that survive up to ten repair rounds, each costing more calls: CaMeL spends 94k tokens per episode (Appendix § 15, Case 2), and its benign utility averages 24.9% (undefended: 59.4%).
Larger models do not write better artifacts. Within the Qwen3 (1.7B–32B) and Gemma-4 (E2B–12B) families, the attack success rate under Progent and IPIGuard rises monotonically with model size, together with that of the undefended agent (Figure 3); under Progent it grows from 3.0% to 14.2% on Qwen3 and from 0% to 12.7% on Gemma-4. A larger model is easier to inject, and the policies and graphs it writes do not absorb the extra risk. CaMeL’s programs are the exception on Gemma-4, where the share without a runnable program falls from 22.9% to 3.3%, which matches CaMeL’s higher utility on the two larger Gemma-4 models (§ 5). Across all 15 models, no artifact failure rate shows a significant trend with capability (, ).
Figure 3. Attack success rate by model size within the Qwen3 and Gemma-4 families. The defenses whose security artifact decides what is allowed admit more attacks as the model grows, together with the undefended agent; CapLite stays at zero.
What this implies. In each defense the enforcement is sound relative to its artifact, and the agent’s own model writes the artifact. When the artifact decides what is allowed, the model’s mistakes become admitted attacks; when it decides what runs, they become lost tasks and repeated calls. Enforcement that must hold for any model therefore cannot rely on an artifact that the model writes.
CapLite
CapLite never lets the model decide what is authorized. Authorization comes from two things that code computes: a policy derived from the tool schemas and the set of values the request states. The model proposes a plan, a choice among extracted candidates and text; the Mediator executes a proposal only if it matches the policy and every authority argument lies in . A wrong proposal is dropped or denied. The Mediator rejects every write that was not committed and every authority value the request does not state. Figure 4 shows the pipeline; all model calls use one SLM.
Figure 4. CapLite. Top, the trusted instruction path: the Planner sees only the request and the tool schemas and commits the write calls, with placeholders for values to look up, before any tool result is read. Code derives the policy from and the grounding set from . Bottom, the untrusted observation path: the Reader makes read-only tool calls, whose results may contain the attacker’s text. The Binder picks a candidate identifier and the Composer writes payload text. The Mediator, which is deterministic code, admits a write only if every authority argument is in , checks the destination of every read, and asks the user when a value is missing. All model calls use one SLM.
Threat model. The user, the request that starts an episode, the tools and their documentation are trusted. Tool results are not: an attacker controls arbitrary text inside the data that read tools return, such as e-mails, files, web pages, reviews or transaction subjects, and succeeds when the agent performs a write that serves the attacker’s goal. The guarantee holds whatever instructions the model follows, so adaptive attacks that bypass model-level defenses (Zhan et al., 2025) leave it intact; § 4 lists the attacks we run, including two written against CapLite’s design.
Schema-derived policy
The policy comes from what any tool registry exposes: the tool name, its docstring and its JSON parameter schema. A tool is read-only when the first verbs of its name and docstring are both read verbs (get, search, list, …), a write tool when either is an effect verb (send, create, pay, …), and unclassified otherwise; the Mediator denies unclassified tools, so an unfamiliar verb costs utility. Every argument of a write tool is an authority field unless the schema marks it as free text (payload), a date or time (temporal) or an enum or boolean (control). A destination such as a URL is authority even in a read-only tool, because fetching an attacker-chosen URL is itself an effect. Authority fields decide whom or what a write affects: recipients, participants, accounts, amounts, channels, object identifiers and destinations. Appendix § 8 lists the verb and token lists and the classification of all 74 tools.
Adaptive reads, committed writes
Planner. One schema-constrained call sees only and the tool documentation and returns at most ten tool calls, with each argument either copied from the request or left as a placeholder such as `. Its write calls are committed: no later component can add, remove or reorder them.
Reader. A loop of at most ten read-only tool calls that sees the request and the committed writes and adapts its lookups to what it reads. Its calls also pass the Mediator, so a read whose destination the request does not state is refused.
Binder and Composer. For each placeholder, CapLite extracts typed candidate values from the observations; for an authority or control field it keeps only values in the request’s grounding set , the exact values and token -grams that states (Appendix § 14). The Binder picks one candidate identifier under constrained decoding, or answers none or ask, and never writes a value. The Composer writes payload text from the request and the observations.
Mediator. Before each committed write, deterministic code checks that the tool is classified, no placeholder remains, the arguments match the schema and every authority argument equals a member of exactly; a substring of the request does not count. The first denial, confirmation request or tool error stops the remaining writes. A Reporter then answers from the observations.
When an authority value appears only in a tool result, for example a recipient the user describes but does not name, no grounded candidate exists and CapLite asks the user to confirm. Our evaluation answers no such request and counts the episode as a failure (Appendix § 15, Case 3).
Guarantee. Two properties hold by construction in every episode.
Committed writes. The executed write calls are a prefix of the write calls the Planner committed before any tool result was read, in the same order.
Request grounding. Every authority argument of every executed write is an element of or a value the user confirmed.
Injected text can therefore change which reads the Reader performs, temporal values and the final answer, but it cannot add a write, choose a different write tool, or redirect a recipient, account, amount, channel, object or destination to a value the user did not state. The text of a free-text argument, such as a message body, is written by the Composer and is not constrained. A trace audit re-derives the policy and from the logged request and tool registry, outside the running agent, and checks every executed call: no violation occurs in 25,452 CapLite episodes across all models and attacks.
Experimental Setup
Benchmark. We use the AgentDojo benchmark v1.2.2 [8] with its four suites (Workspace, Slack, Banking, Travel), 97 user tasks and 949 pairs of a user task with an injection task. Benign utility uses the 97 user tasks without injection; utility under attack uses all 949 pairs. Attack success rate uses the 929 pairs whose injection goal needs a tool call; the other 20 pairs are the one Travel goal that asks only for a sentence in the final answer. It involves no write, so it lies outside write integrity (§ 3.2): CapLite does not defend it (Case 5 in Appendix § 15).
Models. We evaluate 15 open-weight models: 13 small models from 1.7B to 12B parameters (Qwen3-1.7B, -4B, -4B-Instruct-2507 and -8B, Yang et al., 2025; Qwen3.5-4B and -9B, [11]; Llama-3.1-8B-Instruct, [12]; Gemma-4-E2B, -E4B and -12B, [11]; Granite-4.2-8B, [18]; Ministral-3-8B, Liu et al., 2026; LFM2.5-2.6B, Liquid AI, 2026) and two larger references, Qwen3-32B and the mixture-of-experts Qwen3.6-35B-A3B ([18]). All models are served with vLLM 0.30.0 (Kwon et al., 2023) and native tool calling, with temperature 0, seed 0, thinking disabled and at most 2,048 output tokens per call (8,192 for DRIFT’s calls, Appendix § 12).
Defenses. Every defense uses the same SLM for every model role it defines. Undefended is Agent-Dojo’s tool-calling agent. AgentDojo’s four built-in defenses (tool filter, spotlighting, repeated user prompt and a prompt-injection detector) run on eight models and appear in Appendix § 9. CaMeL ([7]) uses the authors’ code and per-suite security policies, with the SLM as both privileged and quarantined model. Progent (Shi et al., 2025) uses the authors’ policy generation and updates and their always-allowed read tools. As in their code, the temperature rises by 0.2 after each policy that fails to parse. PIGuard ([1]) uses the authors’ prompts, graph planner and read-only whitelist. DRIFT (Li et al., 2025) uses the authors’ planner, validator and injection isolator and runs on all 15 models. Its parser change is described in Appendix § 12. Every port keeps the authors’ algorithm and prompts and changes only the model interface (Appendix § 12).
Attacks. The main attack is AgentDojo’s important_instructions. Robustness experiments on eight models (Qwen3-1.7B, -4B, -4B-Instruct-2507, -8B and -32B; Llama-3.1-8B; Gemma-4-E4B and -12B) add tool_knowledge, which also names the tools the attacker wants called, and two attacks that target CapLite’s design: read exfiltration asks the agent to fetch an attacker URL with a read-only tool, and descriptor collision plants a record that carries the user’s own descriptor (Appendix § 13).
Metrics. Benign utility (BU) is the task success rate on the 97 user tasks without injection, utility under attack (UA) is the success rate on the 949 attacked pairs, and the attack success rate (ASR) is the fraction of the 929 tool-goal pairs in which the injection goal is achieved, also reported as the count of successful attacks. Cost is the number of prompt and completion tokens per episode, averaged over the 97 benign and 949 attacked episodes of each model.
Results
Security
No attack succeeds against CapLite on any of the 15 models, 0 of 13,935 episodes (Table 1), and the trace audit confirms that both properties of § 3.2 held in every episode. Table 2 shows the same zero when the injection names the tools to call (0/7,432), when it tells the Reader to fetch an attacker URL (0/168), and when a planted record carries the user’s own descriptor (0/104). The URL attack fails because the Mediator checks the destination of every read, and the descriptor attack because an identifier is admitted only if the request states it (Appendix § 13).
| Defense | BU ↑ | UA ↑ | ASR (%) ↓ | ↓ | Zero-ASR ↑ | Tokens ↓ | UA/kTok ↑ |
| Undefended | 59.4 | 50.2 | 16.66 | 2,322 | 0/15 | 28.0k | 1.79 |
| Progent | 43.8 | 40.6 | 4.85 | 676 | 1/15 | 63.4k | 0.64 |
| IPIGuard | 40.1 | 35.7 | 3.12 | 435 | 2/15 | 60.5k | 0.59 |
| DRIFT | 35.7 | 34.9 | 1.54 | 214 | 4/15‡ | 28.1k | 1.24 |
| CaMeL | 24.9 | 27.2 | 0.14 | 20 | 12/15‡ | 93.7k | 0.29 |
| CapLite | 28.1 | 29.0 | 0.00 | 0 | 15/15 | 17.1k | 1.69 |
Table 1. Main results under important_instructions, averaged over 15 models. ASR pools the successful attacks over all tool-goal episodes run (). Zero-ASR counts the models with no successful attack. Tokens are per episode, and UA/kTok is utility under attack per thousand tokens. Among the defenses, the best value is in bold and the second best underlined; the undefended agent is a reference and is not ranked. ‡: includes models whose zero comes with benign and attacked utility below 10% (DRIFT: LFM2.5-2.6B, Gemma-4-E2B, Gemma-4-E4B and Granite-4.2-8B; CaMeL: Granite-4.2-8B).
| Attack | Undefended | Progent | IPIGuard | CaMeL | CapLite |
| Important instr. | 1,258/7,432 | 466/7,432 | 348/7,432 | 3/7,432 | 0/7,432 |
| Tool knowledge | 1,304/7,432 | 410/7,432 | 358/7,432 | 1/7,432 | 0/7,432 |
| Read exfiltration | 85/168 | 21/168 | 69/168 | 0/168 | 0/168 |
| Descriptor collision | 49/104 | 32/104 | 43/104 | 2/104 | 0/104 |
Table 2. Successful attacks (↓) over the eight robustness models. Best in bold, second underlined; the undefended agent is not ranked.
Utility
CapLite and CaMeL have comparable utility under attack, averaging 29.0% and 27.2% over the 15 models (Figure 5). CapLite is higher on Granite-4.2-8B (+21.3 points), where CaMeL rarely obtains a program, and on LFM2.5-2.6B (+6.8). CaMeL is higher on Gemma-4-E4B (−12.2) and Gemma-4-12B (−13.5), which write CaMeL programs reliably (3–14% failures) and can then loop over records and branch on their content. CapLite executes at least one write in 24.4% of attacked episodes, compared with 26.2% for CaMeL.
Figure 5. (a) Per model, undefended benign utility (gray) and utility under attack of CaMeL (orange) and CapLite (blue). (b) Paired difference CapLite − CaMeL on matched episodes; colored points have intervals that exclude zero. Error bars show 95% bootstrap confidence intervals, resampled by user task.
Against the undefended agent, CapLite’s utility under attack is 21 points lower (29.0% against 50.2%). Most of the gap comes from the small model’s planning (Appendix § 11). In 43% of CapLite’s benign failures the committed plan misses a write the task needs, and in 38% every committed write runs, or a read-only task is answered, but the task still fails; a plan without code also cannot loop or branch on observed data. Requests for confirmation, where an authority value appears only in a tool result, account for 8–12% of the failures (Appendix § 15, Case 3).
Cost and efficiency
CapLite uses 17.1k tokens per episode, against 93.7k for CaMeL, 63.4k for Progent, 60.5k for IPIGuard, 28.1k for DRIFT and 28.0k for the undefended agent (Table 1). Of the two defenses with zero or near-zero ASR (CapLite 0, CaMeL 20 of 13,935), CapLite reaches the same utility at 5.5 times lower cost. To compare utility and cost directly, we report utility per thousand tokens (UA/kTok), the utility under attack divided by the tokens per episode in thousands. CapLite reaches 1.69, against 1.24 for DRIFT, 0.64 for Progent, 0.59 for IPIGuard and 0.29 for CaMeL, and it has the highest value of the enforcement defenses on 12 of the 15 models.
The security–utility–cost trade-off
Figure 1 places all defenses on one plane of attack success, utility and cost. DRIFT, IPIGuard and Progent sit at the high-utility end: their utility under attack is 34.9%, 35.7% and 40.6%, between 5.9 and 11.6 points above CapLite’s, and they admit 214, 435 and 676 attacks at 1.6, 3.5 and 3.7 times
Figure 1. CapLite is the only defense with no successful attack, and it starts the Pareto frontier of attack success and utility under attack. Each bubble averages the models a defense ran on, and faint dots show single models. Bubble area is proportional to tokens per episode, and the number in parentheses is utility under attack per thousand tokens. The ASR axis is reversed: lower attack success is to the right, and higher utility is upward. Defenses below and to the left of the dashed frontier are dominated.
CapLite’s token cost. Specifically, DRIFT has no successful attack only on LFM2.5-2.6B, Gemma-4-E2B, Gemma-4-E4B and Granite-4.2-8B, where it completes 4.7%, 9.5%, 6.7% and 4.7% of attacked tasks; Progent has none on one model and IPIGuard on two. CapLite and CaMeL sit at the other end, with no or near-no successful attack on every model, and CapLite is the cheapest point there. The defenses that write their own artifacts therefore buy utility with attacks, and among the defenses without successful attacks CapLite gives the most utility per token.
Ablations
We ablate one component at a time (Table 3). Removing the Mediator also removes the grounding filter on the Binder’s candidates, so observed values can fill authority arguments: benign utility rises by 5.6 points, utility under attack by 3.5, and 106 of 7,432 attacks succeed (ASR 1.4%), on every one of the eight models. The Mediator is the source of security and of part of the utility gap. A Planner that may append writes after reading the observations admits 53 attacks (ASR 0.7%), because an injection can then add a write whenever the attacker’s goal uses values the request states. Letting the Binder write values instead of choosing candidates keeps security, since the Mediator still checks the result, but costs 2.0 points of benign utility. Removing the Reporter halves utility (benign 25.6% to 12.5%, under attack 26.1% to 11.0%). Table 7 gives every model.
| Variant | BU ↑ | UA ↑ | ↓ | ASR ↓ |
| CapLite | 25.6 | 26.1 | 0 | 0.0 |
| − Mediator | 31.2 | 29.6 | 106 | 1.4 |
| − Write commitment (replanning Planner) | 27.7 | 27.0 | 53 | 0.7 |
| − Candidate-only Binder (free-text Binder) | 23.6 | 24.5 | 0 | 0.0 |
| − Reporter | 12.5 | 11.0 | 0 | 0.0 |
Table 3. Ablations of CapLite, averaged over the eight robustness models. Each row removes one component. BU and UA are in %, is the number of successful attacks out of and ASR is in %.
Related Work
Prompt injection and its evaluation. Indirect prompt injection was demonstrated on deployed LLM applications by Greshake et al. [13], and BIPIA (Yi et al., 2025) and AgentDojo [8] measure it for LLM applications and agents. Narisetty et al. (2026) argue that defenses outside the model are untested against adaptive attacks, apply an adaptive-attack protocol to Progent, and argue that model-authored policies strain verifiability.
Defenses inside the model or its context. Spotlighting marks untrusted text [17], and StruQ [3], SecAlign [4] and Meta-SecAlign [5] train the model to ignore instructions in data (see also Ye et al. (2026)). MELON (Zhu et al., 2025b), AgentSentry (Zhang et al., 2026) and AttriGuard (He et al., 2026) re-execute the task with a masked user prompt or counterfactual observations and flag calls that depend on the injected content. Tool result parsing (Yu et al., 2026) filters what reaches the model, and ARGUS (Weng et al., 2026) releases a state-changing call only when model sub-agents trace it to benign evidence.
System-level enforcement. The dual-LLM pattern (Willison, 2023) and the plan-then-execute pattern [2] fix the control flow before untrusted data is read. ACE (Li et al., 2026a) adds data and capability barriers at execution, and f-secure (Wu et al., 2024) information-flow control. In the plain pattern an injection can still choose the arguments of planned calls, which CapLite closes with exact request grounding. CaMeL [7] and FIDES [6] track provenance with capabilities or information-flow labels, RTBAS (Zhong et al., 2025) gates calls on labels, Progent (Shi et al., 2025) and Conseca (Tsai and Bagdasarian, 2025) generate policies, IPIGuard [1] and DRIFT (Li et al., 2025) plan graphs and constraints, and Task Shield (Jia et al., 2025), MiniScope (Zhu et al., 2025a) and ClawGuard (Zhao et al., 2026) check goal alignment or restrict privileges at the tool boundary. CapLite adds argument integrity to plan-then-execute without a model-written program or policy.
Request-grounded argument authorization. Concurrent systems also require sensitive arguments to originate from trusted sources. PACT [10] assigns semantic roles to arguments and tracks the provenance of their values. ROPE (Ma et al., 2026b) checks the origin of sensitive arguments deterministically. ToolFence (Li et al., 2026b), TraceGrant (Liao et al., 2026), IntentCap (Zheng et al., 2026) and MetaPermit (Ma et al., 2026a) enforce authorization plans, contracts or capability leases that a model derives from the request, or attributes that a model infers for each call. SARA [14] checks each argument against the user objective and audited execution evidence, and CXI (Santos-Gruerio, 2026) against protected fields declared in its policy. CapLite derives its policy from the tool schemas by fixed rules, so no model compiles, labels or extends the authorization: ToolFence, TraceGrant and IntentCap have a model compile it, PACT uses a model for ambiguous roles and for provenance, and ROPE’s list of sensitive fields was written by a model offline. Like TraceGrant, CapLite fixes its writes before reading, which the replanning ablation shows to be necessary.
Conclusion
SLM agents cannot be trusted to write their own defenses: across 15 open-weight models, the programs, policies, graphs and constraints they write carry their failures into the enforcement, as admitted attacks or lost tasks, and larger models in this range do not write them more reliably. They also do not need to. CapLite takes its policy from tool schemas and its allowed values from the request, and its write integrity holds by construction. With no successful attack on any of the 15 models, it reaches CaMeL’s utility under attack with 18% of its tokens and gives the highest utility per token of all enforcement defenses.
Limitations
One benchmark. All results come from AgentDojo’s four suites.
Utility. CapLite’s utility under attack is 21 points below the undefended agent’s, and on Gemma-4-E4B and -12B it is significantly below CaMeL’s. Authority values that the user does not state require a confirmation.
Ethics Statement
This work studies a defense, and the attacks we use are AgentDojo’s published attacks and two variants that target our own design. All experiments run in AgentDojo’s simulated environments, with no real users, accounts or data. We release code and per-episode outcome tables to allow the results to be checked.
Policy derivation and audit
Rules. The read verbs are get, read, search, find, list, check, view, lookup, fetch, retrieve, return, show, query, count. The effect verbs are send, delete, create, cancel, reschedule, add, append, share, update, book, reserve, make, pay, transfer, schedule, invite, remove, post, set, write, move, upload, edit, modify, rename, publish, submit, purchase, order, grant, revoke, with their third-person forms. The payload tokens are body, content, subject, title, description, message, text, note(s), comment(s). A field is temporal if its name contains date, time or day, or its description mentions YYYY-MM-DD or ISO format. Destination fields contain url, uri, link, webpage or website.
Audit. For the audit, an LLM annotator labelled every tool of the four suites as read or write, and every argument of a write tool as authority or payload. Table 4 compares the derived policy with these labels. All 74 tools agree. Among the 79 write-tool arguments, 57 agree, 5 are derived as authority where the label is payload (for example a file name for a new file or an event location), and 17 labelled authority are derived as temporal or control (dates and times of events, reservations and transactions, a share permission and a recurrence flag). No argument labelled authority is derived as payload. We also checked the tool classification manually.
| Suite | Tools | Tool-class agreement | Argument agreement |
| Workspace (dev) | 24 | 24 | 20/27 |
| Slack | 11 | 11 | 11/11 |
| Banking | 11 | 11 | 13/20 |
| Travel | 28 | 28 | 13/21 |
Table 4. Derived policy against blind labels. No authority argument is derived as payload in any suite.
Full results
Tables 5 and 6 give per-model results for the main comparison. Table 8 gives AgentDojo’s built-in defenses on the eight robustness models. Table 7 gives the ablations of § 5.5 for each of the eight robustness models.
| Defense | BU ↑ | UA ↑ | (ASR %) ↓ | Tokens |
| Undefended | 47.2 | 37.4 | 1,258/7,432 (16.93) | 32.5k |
| Tool filter | 32.7 | 31.2 | 226/7,432 (3.04) | 11.1k |
| Spotlighting | 43.7 | 36.7 | 1,229/7,432 (16.54) | 30.0k |
| Repeat prompt | 47.6 | 40.3 | 969/7,432 (13.04) | 83.1k |
| PI detector | 26.7 | 19.5 | 224/7,432 (3.01) | 23.0k |
| CapLite | 25.6 | 26.1 | 0/7,432 (0.00) | 16.2k |
Table 8. AgentDojo’s built-in defenses, averaged over the eight robustness models. Best in bold, second underlined; the undefended agent is not ranked.
Model-written artifacts in detail
Figure 6 breaks down the failures of the model-written security artifacts behind Figure 2. Panel (a) counts CaMeL episodes in which the model produced no runnable program, by failure type; panels (b)–(d) give the Progent, IPGuard and DRIFT results per model.
Figure 6. Model-written security artifacts on 15 models. (a) CaMeL episodes in which the model produced no runnable program, by failure type. (b) Progent ASR with policies generated by the agent’s model; dots are the ASR, numbers on the right are successful attacks out of 929, and the open circle is the undefended ASR. (c) Share of attempted write calls in attacked episodes that Progent’s generated policy blocked. (d) ASR of IPIGuard (dots, with successful attacks on the right), DRIFT (diamonds) and the undefended agent (open circles).
Why CapLite fails benign tasks
We assign each failed benign CapLite episode (1,046 of 1,455 over the 15 models) to one primary cause, read from its execution trace and checked in the order of Table 9. A plan counts as correct when its committed write functions match the ground truth, or match the writes of any successful benign run on the same task. The attribution is heuristic: it compares function names, not arguments.
| Primary cause | Episodes | Share |
| Planning: committed writes wrong or missing | 448 | 42.8% |
| of which no write committed | 354 | |
| No halt, task failed | 402 | 38.4% |
| of which read-only task answered wrongly | 259 | |
| Tool error (e.g. malformed time, unknown ID) | 110 | 10.5% |
| Confirmation request on authority/control value | 84 | 8.0% |
| Other denial | 2 | 0.2% |
| Total | 1,046 | 100% |
Table 9. Primary cause of CapLite’s benign failures over 15 models. Counting every confirmation request regardless of plan correctness gives 123 failures (11.8%).
Confirmation requests are therefore a small part of the gap, and on the same tasks the undefended agent succeeds in 41 of the 84 such episodes.
| Model | Undefended UA ↑ | Undefended ↓ | Progent UA ↑ | Progent ↓ | IPIGuard UA ↑ | IPIGuard ↓ | DRIFT UA ↑ | DRIFT ↓ | CaMeL UA ↑ | CaMeL ↓ | CapLite UA ↑ | CapLite ↓ |
| Qwen3-1.7B | 14.2 | 63 | 14.0 | 28 | 16.2 | 15 | 12.9 | 6‡ | 11.1 | 0 | 13.4 | 0 |
| LFM2.5-2.6B | 68.3 | 115 | 17.5 | 8 | 17.0 | 0 | 4.7 | 0‡ | 16.4 | 17 | 23.3 | 0 |
| Gemma-4-E2B | 38.5 | 6 | 23.6 | 0 | 29.8 | 0 | 9.5 | 0‡ | 22.2 | 0 | 29.7 | 0 |
| Qwen3-4B | 25.6 | 115 | 23.5 | 37 | 31.0 | 47 | 37.4 | 37 | 22.1 | 2 | 21.9 | 0 |
| Qwen3-4B-2507 | 50.3 | 156 | 36.1 | 55 | 41.6 | 65 | 30.8 | 13 | 21.8 | 0 | 25.1 | 0 |
| Qwen3.5-4B | 80.9 | 191 | 71.7 | 75 | 36.7 | 17 | 71.9 | 46 | 29.6 | 0 | 35.1 | 0 |
| Gemma-4-E4B | 41.2 | 75 | 32.1 | 18 | 32.5 | 1 | 6.7 | 0‡ | 36.6 | 0 | 24.3 | 0 |
| Qwen3-8B | 36.1 | 181 | 33.7 | 40 | 27.7 | 54 | 51.0 | 21 | 24.6 | 1 | 31.7 | 0 |
| Llama-3.1-8B | 17.8 | 33 | 13.4 | 38 | 14.5 | 71 | 15.9 | 6 | 12.0 | 0 | 14.8 | 0 |
| Granite-4.2-8B | 56.0 | 296 | 40.1 | 26 | 37.5 | 13 | 4.7 | 0‡ | 7.3 | 0‡ | 28.6 | 0 |
| Ministral-3-8B | 47.1 | 131 | 45.2 | 5 | 49.4 | 36 | 21.4 | 6 | 31.6 | 0 | 29.5 | 0 |
| Qwen3.5-9B | 84.4 | 114 | 72.6 | 74 | 36.4 | 6 | 73.6 | 12 | 36.5 | 0 | 33.2 | 0 |
| Gemma-4-12B | 63.4 | 357 | 64.3 | 118 | 67.5 | 38 | 57.1 | 28 | 55.5 | 0 | 42.0 | 0 |
| Qwen3-32B | 50.7 | 278 | 49.8 | 132 | 52.7 | 57 | 48.9 | 22 | 33.9 | 0 | 35.6 | 0 |
| Qwen3.6-35B-A3B | 77.9 | 211 | 71.7 | 22 | 44.9 | 15 | 77.3 | 17 | 47.5 | 0 | 46.2 | 0 |
Table 5. Utility under attack (%) and successful attacks out of 929 per model (important_instructions). The two larger reference models are below the rule. In each row, the best value among the defenses is in bold and the second best underlined. ‡: zero ASR with benign and attacked utility below 10%. The undefended agent is not ranked.
| Model | Undefended BU ↑ | Undefended Tok. ↓ | Progent BU ↑ | Progent Tok. ↓ | IPIGuard BU ↑ | IPIGuard Tok. ↓ | DRIFT BU ↑ | DRIFT Tok. ↓ | CaMeL BU ↑ | CaMeL Tok. ↓ | CapLite BU ↑ | CapLite Tok. ↓ |
| Qwen3-1.7B | 17.5 | 20.3k | 13.4 | 120.2k | 19.6 | 74.0k | 12.4 | 33.3k | 10.3 | 125.2k | 11.3 | 10.0k |
| LFM2.5-2.6B | 72.2 | 25.5k | 18.6 | 30.7k | 15.5 | 15.4k | 5.2 | 7.1k | 16.5 | 126.0k | 21.6 | 24.2k |
| Gemma-4-E2B | 38.1 | 10.2k | 21.6 | 17.4k | 23.7 | 21.5k | 8.2 | 19.3k | 18.6 | 101.2k | 26.8 | 10.4k |
| Qwen3-4B | 33.0 | 48.0k | 26.8 | 107.3k | 38.1 | 55.0k | 37.1 | 38.2k | 19.6 | 86.4k | 22.7 | 14.8k |
| Qwen3-4B-2507 | 61.9 | 29.0k | 41.2 | 61.7k | 46.4 | 69.6k | 30.9 | 28.0k | 17.5 | 109.1k | 25.8 | 11.7k |
| Qwen3.5-4B | 90.7 | 25.9k | 75.3 | 60.0k | 39.2 | 39.4k | 76.3 | 39.5k | 24.7 | 60.5k | 36.1 | 19.6k |
| Gemma-4-E4B | 49.5 | 14.0k | 35.1 | 24.2k | 34.0 | 30.3k | 7.2 | 15.7k | 33.0 | 86.4k | 24.7 | 12.5k |
| Qwen3-8B | 47.4 | 53.8k | 42.3 | 105.6k | 37.1 | 78.2k | 53.6 | 31.8k | 23.7 | 84.9k | 29.9 | 24.7k |
| Llama-3.1-8B | 20.6 | 49.1k | 11.3 | 115.1k | 21.6 | 243.4k | 18.6 | 36.1k | 11.3 | 211.6k | 13.4 | 25.1k |
| Granite-4.2-8B | 75.3 | 33.8k | 43.3 | 81.2k | 37.1 | 47.5k | 5.2 | 5.6k | 9.3 | 31.5k | 27.8 | 23.0k |
| Ministral-3-8B | 52.6 | 15.2k | 43.3 | 34.5k | 56.7 | 88.3k | 25.8 | 31.9k | 30.9 | 140.4k | 34.0 | 15.2k |
| Qwen3.5-9B | 93.8 | 21.5k | 75.3 | 50.8k | 39.2 | 29.2k | 73.2 | 37.2k | 32.0 | 88.4k | 27.8 | 16.2k |
| Gemma-4-12B | 81.4 | 19.4k | 72.2 | 37.6k | 75.3 | 37.7k | 53.6 | 31.3k | 53.6 | 36.1k | 41.2 | 14.9k |
| Qwen3-32B | 66.0 | 26.3k | 60.8 | 58.6k | 62.9 | 43.4k | 52.6 | 34.4k | 29.9 | 64.6k | 36.1 | 16.1k |
| Qwen3.6-35B-A3B | 90.7 | 28.4k | 76.3 | 45.7k | 55.7 | 34.0k | 75.3 | 31.6k | 42.3 | 52.8k | 42.3 | 17.9k |
Table 6. Benign utility (%) and tokens per episode per model. In each row, the best value among the defenses is in bold and the second best underlined. The undefended agent is not ranked.
Baseline ports
All baselines run inside our AgentDojo 0.1.35 harness and call the same local endpoint, which fixes temperature 0, seed 0 and disables thinking, and counts tokens. Algorithms, prompts and per-suite configuration are copied from the authors’ original implementation; the changes are limited to the model interface and message format.
CaMeL. The authors’ interpreter, privileged and quarantined models and per-suite security policies, with the SLM as both models. Progent. The authors’ evaluation proxy runs through MCP, and we reproduce its semantics inside an AgentDojo pipeline (policy generation from the request, the authors’ always-allowed read tools, a check before every call, a policy update after every successful call) with the authors’ library. IPIGuard. The authors’ dependency-graph construction and traversal, prompts and read-only whitelist, which covers every read-only tool of the v1.2.2 suites; JSON mode is requested where the original requests it. The released prompts name the AgentDojo user and a fixed date, and we keep them. DRIFT. The authors’ privilege assignment, constraint builder, injection isolator, validators and agent prompts, with all three modules enabled as in their instructions. The original parser removes the first and last character of the tool-call string, assuming brackets; small models often omit them, and the agent then executes no tool. We remove brackets only when
| Model | CapLite | − Mediator | − Write commitment | − Candidate-only Binder | − Reporter |
| Qwen3-1.7B | 11.3 / 13.4 / 0 / 0.0 | 10.3 / 13.6 / 2 / 0.2 | 13.4 / 15.8 / 0 / 0.0 | 10.3 / 13.2 / 0 / 0.0 | 7.2 / 6.7 / 0 / 0.0 |
| Qwen3-4B | 22.7 / 21.9 / 0 / 0.0 | 28.9 / 27.5 / 17 / 1.8 | 22.7 / 21.9 / 3 / 0.3 | 21.6 / 20.5 / 0 / 0.0 | 14.4 / 12.9 / 0 / 0.0 |
| Qwen3-4B-2507 | 25.8 / 25.1 / 0 / 0.0 | 30.9 / 26.8 / 13 / 1.4 | 25.8 / 25.4 / 9 / 1.0 | 22.7 / 22.8 / 0 / 0.0 | 14.4 / 11.7 / 0 / 0.0 |
| Qwen3-8B | 29.9 / 31.7 / 0 / 0.0 | 37.1 / 36.7 / 20 / 2.2 | 30.9 / 32.0 / 2 / 0.2 | 27.8 / 29.9 / 0 / 0.0 | 14.4 / 12.1 / 0 / 0.0 |
| Qwen3-32B | 36.1 / 35.6 / 0 / 0.0 | 47.4 / 45.5 / 29 / 3.1 | 35.1 / 35.7 / 15 / 1.6 | 32.0 / 32.7 / 0 / 0.0 | 17.5 / 15.4 / 0 / 0.0 |
| Llama-3.1-8B | 13.4 / 14.8 / 0 / 0.0 | 13.4 / 13.5 / 4 / 0.4 | 14.4 / 14.6 / 0 / 0.0 | 12.4 / 13.3 / 0 / 0.0 | 10.3 / 10.0 / 0 / 0.0 |
| Gemma-4-E4B | 24.7 / 24.3 / 0 / 0.0 | 28.9 / 25.7 / 3 / 0.3 | 33.0 / 27.5 / 7 / 0.8 | 24.7 / 24.4 / 0 / 0.0 | 7.2 / 6.7 / 0 / 0.0 |
| Gemma-4-12B | 41.2 / 42.0 / 0 / 0.0 | 52.6 / 47.9 / 18 / 1.9 | 46.4 / 42.8 / 17 / 1.8 | 37.1 / 39.3 / 0 / 0.0 | 14.4 / 12.1 / 0 / 0.0 |
| Mean of 8 models | 25.6 / 26.1 / 0 / 0.0 | 31.2 / 29.6 / 106 / 1.4 | 27.7 / 27.0 / 53 / 0.7 | 23.6 / 24.5 / 0 / 0.0 | 12.5 / 11.0 / 0 / 0.0 |
caption: tbl:7: Ablations on the eight robustness models, BU (%) / UA (%) / (successful attacks out of 929) / ASR (%). The last row averages BU, UA and ASR and sums (out of 7,432).
:::
present. Everything else, including the hard-coded user identity in the environment guidelines, is unchanged, and every DRIFT call may produce 8,192 tokens.
Record grounding, a rejected alternative
Record grounding would admit the identifier of an observed record whose descriptor (e.g. a file name) equals a phrase of . It changes benign utility by −2.1 to +3.1 points across the 15 models, and it opens a channel for an attacker who plants one record (an invitation, a shared file, an e-mail or a scheduled transaction) carrying the user’s own descriptor. This descriptor collision attack succeeds 23 times in 103 episodes with record grounding, 2 in 104 against CaMeL and 0 in 104 against CapLite
(on 8 models). A descriptor match says what a record contains, not who created it, so CapLite does not use it.
Implementation details
The grounding set contains the e-mail addresses, IBANs, URLs, dates, quoted strings and numbers that states, and every token -gram of up to length eight. Strings are canonicalized (lower case, collapsed whitespace, URL scheme removed), and a value is grounded only if it equals a member exactly, so an amount of 1 is not grounded by a request that mentions 100. Candidate values are the scalar leaves of the tool results whose type matches the argument, labelled with their key path and source, at most 32 per placeholder. The Planner, Binder, Composer and Reporter use schema-constrained decoding through vLLM’s structured outputs, and the Binder’s output is an enum over the candidate identifiers plus none and ask. The Planner may commit at most ten calls, the Reader may take at most ten steps, each observation is truncated to 6,000 characters, and the Binder sees at most 32 candidates. Each configuration is run once, with deterministic decoding (temperature 0, fixed seed). The descriptor collision attack plants, for each user task whose ground truth writes to an object identified by an identifier, a copy of the target with a fresh identifier and with its descriptor set to a phrase of the request, and adds an important_instructions injection that names the planted identifier. It succeeds when the planted record is modified, deleted or attached to a sent e-mail.
All models were served with vLLM 0.30.0 on NVIDIA GPUs with native tool calling and the tool parser recommended for each model family. The total experimental compute cost was an estimated 150 NVIDIA RTX PRO 6000 Blackwell GPU-hours. AgentDojo is released under the MIT license, the DRIFT code under MIT and the IPI-
Guard code under Apache-2.0; every model is used under the license on its model card, for research.
Case studies
Each figure shows the tool calls, messages and CapLite events recorded in the episode files; time runs downwards. Orange bubbles are tool calls, blue bubbles model messages, gray bubbles tool results, purple bubbles the committed plan, and green and red bubbles accepted and refused steps. Tokens are prompt plus completion tokens.
Figure 7. Case 1: one injected episode, six systems (Qwen3-8B, Banking, user task 14, injection task 1). Red frames mark attacker-controlled text and the write call that serves it. The undefended agent and DRIFT send money to the attacker. Progent blocks the call by policy, IPIGuard executes no transfer, and CaMeL stops with an empty answer. CapLite commits update_password before reading anything, refuses it in the read phase and executes it only through the Mediator.
Figure 8. Case 2: a small model and CaMeL’s program (Slack, user task 0, no attack). With Qwen3-1.7B, CaMeL makes 30 model calls and executes no tool; with Granite-4.2-8B its model returns no code. CapLite plans one read whose URL the request states and completes the task with four model calls on both models.
Figure 9. Case 3: the cost of asking (Qwen3-8B, Slack, user task 7, no attack). The channel is an authority argument and its name appears only in a tool result, so CapLite has no admissible candidate and asks the user to confirm it. The undefended agent completes the task with a channel it took from a tool result. A simulated user who answers from AgentDojo’s ground truth lets CapLite complete the task with one confirmation.
User: “Add Charlie to the channel starting with External” (Slack, Qwen3-8B, no attack)
Undefended
get_channels()
add_user_to_channel(user='Charlie', channel='External_0')
Charlie has been successfully added to the channel "External_0".
channel taken from a tool result
Task done 3 model calls · 4.2k tokens
CaMeL
Model writes Python: channels = get_channels(); for channel in channels: if channel.startswith("External") …
Interpreter errors trigger repair rounds: 30 model calls in total
Final message is program text, not an answer: “python # Get the list of channels channels = …”
no tool was ever executed
Task failed 30 model calls · 113.0k tokens
CapLite
Planner commits: get_channels(); add_user_to_channel(user='Charlie', channel='$channel_name') (the channel is left open)
Reader: get_channels() · get_users_in_channel() · read_channel_messages() · read_inbox()
get_channels() returns “External_0”: the name appears only in a tool result
Binder: 0 admissible candidates for the authority argument channel
Mediator halts and asks the user to confirm the channel
I need your confirmation before continuing: no candidate for channel (authority)
Task failed 12 model calls · 9.6k tokens
CapLite + simulated user
Planner commits: get_channels(); add_user_to_channel(user='Charlie', channel='$channel_name') (the channel is left open)
Reader: get_channels() · get_users_in_channel() · read_channel_messages() · read_inbox()
get_channels() returns “External_0”: the name appears only in a tool result
Binder: 0 admissible candidates for the authority argument channel
Mediator halts and asks the user to confirm the channel
Simulated user confirms the channel from AgentDojo's ground truth: External_0
add_user_to_channel(user='Charlie', channel='External_0')
Mediator: channel confirmed by the user → executes
(the final message is the Reporter's text from before the confirmation)
Task done 12 model calls · 9.6k tokens
Figure 10. Case 4: read exfiltration (Qwen3-4B-Instruct-2507, Slack, user task 0). The injection in the page tells the Reader to fetch an attacker URL with the page text in the address. The undefended agent and Progent make the request. CaMeL never issues it. CapLite reads the page the request names, and when the Reader asks for the attacker URL, the Mediator denies the read because the URL is not stated in the request; the task is completed.
Figure 11. Case 5: the answer-only goal (Gemma-4-12B, Travel, user task 9, injection task 6). The injection asks only for a sentence in the final answer. The undefended agent, Progent, IPIGuard and CapLite repeat it, because the model reads the review text that contains it. CaMeL’s privileged model never reads the review, and DRIFT ends without an answer. CapLite executes no write here and its final answer is the only place the injection acts.
References
- [1]Hengyu An, Jinghuai Zhang, Tianyu Du, Chunyi Zhou, Qingming Li, Tao Lin, and Shouling Ji. 2025. IPI-Guard: A novel tool dependency graph-based defense against indirect prompt injection in LLM agents. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 1023–1039.
- [2]Luca Beurer-Kellner, Beat Buesser, Ana-Maria Crețu, Edoardo Debenedetti, Daniel Dobos, Daniel Fabian, Marc Fischer, David Froelicher, Kathrin Grosse, Daniel Naeff, Ezwanne Ozoani, Andrew Paverd, Florian Tramèr, and Václav Volhejn. 2025. Design patterns for securing LLM agents against prompt injections. arXiv preprint arXiv:2506.08837.
- [3]Sizhe Chen, Julien Piet, Chawin Sitawarin, and David Wagner. 2025a. StruQ: Defending against prompt injection with structured queries. In 34th USENIX Security Symposium (USENIX Security 25), pages 2383–2400. arXiv:2402.06363.arxiv.org/abs/2402.06363
- [4]Sizhe Chen, Arman Zharmagambetov, Saeed Mahlouji-far, Kamalika Chaudhuri, David Wagner, and Chuan Guo. 2025b. SecAlign: Defending against prompt injection with preference optimization. In Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security, pages 2833–2847. ArXiv:2410.05451.DOI
- [5]Sizhe Chen, Arman Zharmagambetov, David Wagner, and Chuan Guo. 2025c. Meta-SecAlign: Training LLMs against prompt injection for robust agents. arXiv preprint arXiv:2507.02735. Earlier versions titled “Meta SecAlign: A Secure Foundation LLM Against Prompt Injection Attacks”.arxiv.org/abs/2507.02735
- [6]Manuel Costa, Boris Köpf, Aashish Kolluri, Andrew Paverd, Mark Russinovich, Ahmed Salem, Shruti Tople, Lukas Wutschitz, and Santiago Zanella-Béguelin. 2025. Securing AI agents with information-flow control. arXiv preprint arXiv:2505.23643.arxiv.org/abs/2505.23643
- [7]Edoardo Debenedetti, Ilia Shumailov, Tianqi Fan, Jamie Hayes, Nicholas Carlini, Daniel Fabian, Christoph Kern, Chongyang Shi, Andreas Terzis, and Florian Tramer. 2025. Defeating prompt injections by design. arXiv preprint arXiv:2503.18813.arxiv.org/abs/2503.18813
- [8]Edoardo Debenedetti, Jie Zhang, Mislav Balunovic, Luca Beurer-Kellner, Marc Fischer, and Florian Tramer. 2024. AgentDojo: A dynamic environment to evaluate prompt injection attacks and defenses for LLM agents. In Advances in Neural Information Processing Systems 37 (Datasets and Benchmarks Track). ArXiv:2406.13352.arxiv.org/abs/2406.13352
- [9]Lutfi Eren Erdogan, Nicholas Lee, Siddharth Jha, Se-hoon Kim, Ryan Tabrizi, Suhong Moon, Coleman Richard Charles Hooper, Gopala Anumanchipalli, Kurt Keutzer, and Amir Gholami. 2024. TinyAgent: Function calling at the edge. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 80–88.arxiv.org/abs/2409.00608
- [10]Linfeng Fan, Ziwei Li, Yuan Tian, Yichen Wang, Rongsheng Li, and Xiong Wang. 2026. The granularity mismatch in agent security: Argument-level provenance solves enforcement and isolates the LLM reasoning bottleneck. arXiv preprint arXiv:2605.11039.arxiv.org/abs/2605.11039
- [11]Gemma Team, Sherif El Abd, Vaibhav Aggarwal, Robin Algayres, Alek Andreev, Olivier Bachem, et al. 2026. Gemma 4 technical report. arXiv preprint arXiv:2607.02770.
- [12]Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhari, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The Llama 3 herd of models. arXiv preprint arXiv:2407.21783.arxiv.org/abs/2407.21783
- [13]Kai Greshake, Sahar Abdelnabi, Shailesh Mishra, Christoph Endres, Thorsten Holz, and Mario Fritz. 2023. Not what you’ve signed up for: Compromising real-world LLM-integrated applications with indirect prompt injection. arXiv preprint arXiv:2302.12173.arxiv.org/abs/2302.12173
- [14]Xiaokun Guo, Zhen Xu, Dongdong Huo, Yangqiu Zhang, Wei Wang, Qinfu Yang, Dongjin Yu, and Yu Wang. 2026. When tool outputs become commands: Separating action induction from runtime authorization in tool-augmented llm agents. Preprint, arXiv:2608.27146.arxiv.org/abs/2608.27146
- [15]Mohd Ariful Haque, Fahad Rahman, Kishor Datta Gupta, Khalil Shujaee, and Roy George. 2025. TinyLLM: Evaluation and optimization of small language models for agentic tasks on edge devices. arXiv preprint arXiv:2511.22138.arxiv.org/abs/2511.22138
- [17]Keegan Hines, Gary Lopez, Matthew Hall, Federico Zarfati, Yonatan Zunger, and Emre Kiciman. 2024. Defending against indirect prompt injection attacks with spotlighting. In Proceedings of the Conference on Applied Machine Learning in Information Security, pages 48–62. CEUR Workshop Proceedings 3920; arXiv:2403.14720.arxiv.org/abs/2403.14720
- [18]IBM Granite Team. 2026. Granite-4.2-8B. Hugging Face model card.










