Organizations: MIIT Key Laboratory of Pattern Analysis and Machine Intelligence, College of Computer Science and Technology, Nanjing University of Aeronautics and Astronautics, Nanjing, China · Tsinghua University, Beijing, China · Beihang University, Beijing, China · College of Electronic and Information Engineering, Tongji University, Shanghai, China · School of Computer Science and Technology, Tongji University, Shanghai, China
Tool-using large language model (LLM) agents translate model outputs into consequential actions, turning indirect prompt injection into an execution-security problem. Existing defenses constrain tool calls, trajectories, or information flows, but often leave action semantics, state dependencies, and evidence relations implicit, limiting generalization across heterogeneous tools and complicating safe updates. We present SecureGARD, a dynamic ontology-guided governance framework. SecureGARD grounds heterogeneous calls in a shared semantic representation and combines an executable ontology with episode-level task state to derive deterministic ready, waiting, and forbidden decisions. A waiting decision identifies an unmet but recoverable obligation, enabling bounded replanning without expanding the agent's authorization boundary. SecureGARD evolves its ontology offline from verified training executions. An offline LLM proposes instance-independent action-state axioms, which are accepted only if they address ontology errors exposed by training failures, preserve logical consistency and protected entailments, and pass held-out validation before the ontology is frozen. We evaluate SecureGARD on AgentDojo, ASB, and AgentDyn under benign and indirect prompt-injection settings. SecureGARD achieves a 0% attack success rate (ASR) across all three benchmarks while improving task utility under attack compared with existing baselines. These results show that explicit semantic governance can strengthen execution security without indiscriminate blocking.
Figures & tables
Figure 1. Motivation for SecureGARD . (a) Interface-specific policies fragment equivalent tool actions. (b) Permission and argument checks cannot verify semantic prerequisites, making binary admission unsafe or overly restrictive. (c) SecureGARD grounds heterogeneous calls into shared actions and checks TBox requirements against verified ABox facts, enabling three-way adjudication and bounded recovery. Three vertically arranged panels illustrate the motivation for SecureGARD. The first shows equivalent email tools with different interfaces, preventing interface-specific policies from transferring. The second shows that permission and argument checks may either allow an unsupported action or block a recoverable task. The third shows SecureGARD grounding heterogeneous tools into a shared semantic action, checking TBox requirements against verified ABox facts, and returning ready, waiting, or forbidden decisions.
Figure 2. Overview of SecureGARD . (1) Verified training trajectories generate candidate action–state axioms and reusable TBox rules. (2) Online tool calls are grounded and checked against current ABox facts. (3) Missing but recoverable requirements produce a waiting decision, are recorded in TaskState, and trigger bounded recovery before re-adjudication as ready . (4) Failure traces are filtered so that only ontology-relevant evidence supports subsequent offline evolution.
LLM
Method
AgentDojo
ASB
AgentDyn
CU ↑
AU ↑
ASR ↓
CU ↑
AU ↑
ASR ↓
CU ↑
AU ↑
ASR ↓
GPT-4o-mini
No Defense
67.4
37.3
27.3
51.7
37.7
49.1
46.7
35.7
50.0
Tool Filter
59.5
41.0
9.0
–
–
–
6.7
4.8
6.2
Progent
45.3
33.3
10.3
25.5
28.5
15.8
6.7
3.8
10.3
DRIFT
57.3
50.3
2.3
26.5
28.5
4.7
18.3
20.3
3.1
CaMeL
30.3
33.6
0.7
–
–
–
0.0
0.0
0.0
Table 1. Main results on AgentDojo, ASB, and AgentDyn. All entries are percentages. The best result in each backbone–benchmark setting is shown in bold , and the second best is underlined . Tied best results are all shown in bold . “–” denotes an unavailable result.
Figure 3. Security–utility trade-off and average online inference cost on ASB using Qwen3.8-Flash. The panels report AU versus ASR, average token consumption, and average runtime per attacked episode. Three panels compare SecureGARD with the undefended agent, Progent, and DRIFT. The first panel reports attack utility and attack success rate, the second reports average token consumption per attacked episode, and the third reports average runtime per attacked episode.
Figure 4. Backbone sensitivity of SecureGARD on AgentDojo. Bars report CU and AU, while diamonds report ASR. Each backbone is evaluated on the same complete set of AgentDojo tasks and attack instances. A chart comparing clean utility, attack utility, and attack success rate across five LLM backbones. Clean and attack utility vary across backbones, while the observed attack success rate is zero for every backbone.
Figure 5. Ablation results on AgentDojo using GPT-4o-mini. Bars report CU and AU, while the diamond-marked line reports ASR for the complete SecureGARD framework and each ablated variant. A dual-axis chart comparing the complete SecureGARD framework with four ablated variants. Grouped bars report clean utility and attack utility on the left axis, while a diamond-marked line reports attack success rate on the right axis.
Figure 6. Illustrative defense against a forged verification claim. Action–state axioms guide evidence acquisition, and a verified recipient conflict causes the original call to be blocked before execution. An illustrative comparison between an undefended agent and SecureGARD. The undefended agent accepts an injected verification claim. SecureGARD derives a recipient-specific state obligation, holds the original call, obtains independent contact evidence through a guarded lookup, and rejects the conflicting recipient.
Ontology
New Axioms
Protected Ret. ↑
CU ↑
AU ↑
ASR ↓
Initial ontology O0
0
6/6 (100.0)
36.5
31.8
4.3
Frozen ontology O1
24
6/6 (100.0)
34.8
32.5
0.0
Table 2. Transfer effect of AgentDojo-derived ontology evolution on unseen ASB tasks using GPT-4o-mini. Protected Ret. is reported as count (percentage); CU, AU, and ASR are percentages.
Pipeline Event
Count
Rate (%)
Total attacked executions
477
100.0
Observation modified by evidence processing
421
88.3
Attack-aligned action proposed
38
8.0
Rejected or deferred by adjudication
13
2.7
Attack-aligned action executed
26
5.5
Successful attack
0
0.0
Table 3. Episode-level mitigation events across 477 attacked AgentDojo executions with GPT-4o-mini. Rejected or deferred combines execution-boundary rejection and ontology-based deferral; event rows may overlap.
Artificial intelligence agent security studies attacks and safeguards for tool-using, persistent, and collaborative systems across digital and physical settings.
Large language model (LLM) agents increasingly execute long-horizon workflows through external tools, allowing untrusted outputs to influence subsequent actions and exceed user authorization. Existing defenses isolate injected content or constrain execution with predefined plans and static policies, but these approaches are brittle under dynamic workflows and scale poorly across extensible tool ecosystems. In this work, we present ActGov, a runtime enforcement framework that validates each LLM-proposed tool action before it causes external effects. Built on a unified semantic model of authorization, actions, runtime context, and security constraints, the ActGov-Policy component iteratively constructs a policy set from tool specifications, benign tasks, and observed failure traces, with each update verified through SMT-based counterexample checking. At runtime, ActGov-Runtime abstracts each tool call into finite policy records and permits it only if it remains within the task-scoped authorization boundary and satisfies all applicable policies. This per-action enforcement preserves authorization throughout long-horizon, dynamically branching workflows. We evaluate ActGov on the AgentDojo and AgentDyn benchmarks across multiple models and attack configurations. It shows that ActGov consistently reduces the success rate of indirect prompt-injection attacks while preserving task utility, significantly outperforming existing defenses. These results demonstrate that ActGov can enforce fine-grained authorization over dynamic agent executions without relying on the underlying LLM to correctly identify malicious instructions.
LLM agents increasingly rely on external tools, expanding capability while creating a new security boundary: third-party tools may appear benign at the interface level while embedding unsafe behavior in implementation. Existing defenses rely on weak metadata, collapse characterization and policy judgment into a single decision, or use heuristic/LLM enforcement that lacks deterministic, auditable reasoning over task context and multi-tool composition. This paper presents ToolGuardian, a policy-driven framework for securing agent-tool interactions through pre-admission vetting and task-aware runtime authorization. ToolGuardian uses progressive characterization to convert evidence into structured facts: descriptions capture declared intent, system-call traces expose coarse behavior, mock execution reveals observed effects, and source analysis identifies latent behavior. ToolGuardian's core contribution is an Answer Set Programming (ASP)-based declarative policy layer that reasons explicitly over capabilities, effects, task context, and composition. We compare ASP against heuristic and LLM-based policy realizations using identical inputs and output contracts. We evaluate ToolGuardian on 16 MCP-style tools, including 8 malicious variants derived from real open-source tools, and 20 runtime scenarios. For vetting, ASP reaches a deny-class F1 of 0.86 and 88% accuracy using description, syscall, and observed-effect evidence. For runtime authorization, fully specified realizations classify all scenarios correctly, while ablations show that removing compositional and conformance rules substantially degrades performance.
Arun Ravindran, Saurabh Deochake
Department of Electrical and Computer Engineering University of North Carolina at Charlotte Charlotte, NC · SentinelOne Mountain View, CA
Agentic computing systems, while immensely capable, raise serious security, privacy, and safety concerns. A key issue is that the full set of functionalities offered by these systems, combined with their probabilistic execution flows, is not known beforehand. Given this lack of characterization, it is challenging to validate whether a system has successfully carried out the user's intended task or instead executed irrelevant actions, potentially as a consequence of compromise. We present Agent Sentry, a runtime defense that learns a bound on an agent's benign execution from prior legitimate executions and flags any action that falls outside this bound. Agent Sentry layers three complementary checks: a structural classifier over the sequence of actions and the provenance of each function's arguments; a deterministic allowlist check over sensitive argument values; and an LLM judge, invoked only on the residual of actions where the first two checks cannot safely decide between a legitimate new request and a carefully crafted injection. We demonstrate the effectiveness of Agent Sentry in AgentDojo and AgentDyn by blocking 94.3% of successful injections while allowing 95.1% of benign executions, without modifying the agent, its tools, or the LLM.
Rohan Sequeira, Stavros Damianakis, Umar Iqbal +1
University of Southern California, Los Angeles, California, USA · Washington University in St. Louis, St. Louis, Missouri, USA