WorksComputer Science
Agent-ZTA: A chain-Aware Zero Trust Model for Bidirectional Security-State Propagation and Runtime Containment in Multi-Agent Delegation
Abstract
Multi-agent systems increasingly delegate tasks and permissions across chains of autonomous agents that invoke protected tools. Although agent identities and delegated credentials may remain valid throughout a workflow, the security condition of any agent along the chain can deteriorate during runtime execution-either through upstream compromise or downstream ingestion of untrusted inputs. Authorization models based solely on the immediate caller and its static delegated scope fail to account for these mid-execution state changes. This paper develops Agent-ZTA, a chain-aware Zero Trust authorization and containment model that links runtime security-state changes across multi-agent delegation graphs. The model distinguishes an agent's path-specific delegated authority bound from the effective permissions currently exercisable under trusted policy. It defines an architecture featuring independently enforced policy decisions, authenticated delegation provenance, a dynamic chain-state view, and explicit fail-safe handling of missing or stale authorization signals. Furthermore, Agent-ZTA defines bidirectional security state propagation, allowing downstream security events to affect relevant upstream workflow states, and specifies adaptive branch-scoped containment through restricted permissions and a sandbox ("jail") execution mode where an isolation boundary is available. The deterministic decision procedure, five stated security properties, and worked authorization traces show how accepted security-state changes constrain affected operations while preserving original delegation bounds and separating unrelated workflow branches under the defined policies. Finally, the paper states its trust assumptions and the exact scope of its security properties.
Introduction
Autonomous artificial intelligence (AI) agents can plan multi-step tasks, invoke external tools, access application resources, and cooperate with other agents. In a multi-agent workflow, one agent may delegate a subtask to another, which can in turn delegate work to additional agents. This introduces chains of operational authority: individual agents act not only on their own behalf but also under permissions derived from earlier principals. As agentic systems become more capable, their security depends on governing the identities, permissions, and actions of these interacting principals, rather than protecting language-model outputs alone [4, 5, 6].
Zero Trust Architecture (ZTA) provides a useful starting point. Its principles emphasize explicit verification, least-privilege access, and decisions based on available information about the requesting subject, resource, and operating context [1]. Research applying these principles to AI agents has examined agent-specific identities, delegation provenance, capability constraints, runtime authorization, and enforcement at tool boundaries [2], [3], [7], [11]. Other studies investigate risk-adaptive decisions and controls that remain independent of a potentially manipulated language model [9], [12], [13]. Agent-ZTA builds on these mechanisms by connecting delegation dependencies to changing runtime security states, with branch-specific authorization and containment rules.
Consider a user who delegates a task to Agent A, which delegates a limited subtask to Agent B; Agent B subsequently delegates to Agent C, which invokes a protected tool. If Agent A becomes compromised after delegation, Agents B and C may retain valid credentials although the upstream execution state has degraded. The reverse case also matters: Agent C may ingest malicious content or report a security event that changes how Agent B or Agent A should handle the affected workflow. These cases reveal a delegation-chain security-state problem: valid credentials alone do not establish whether the current operation or its dependent execution branch should remain authorized.
Prior research establishes substantial adjacent capabilities. Work on authorization propagation considers transitive delegation and temporal constraints [14]; capability-oriented approaches govern field-level sharing, bounded delegated actions, or externally enforced delegated permissions, respectively [11]–[13]; and risk-adaptive approaches can revise individual access decisions as conditions change [9], [15]. Security studies also show that adversarial content and harmful effects can traverse agent roles and workflow boundaries, underscoring the limitations of exclusively local protections [18]–[20]. Together, these results motivate a model that links security-state events, authenticated delegation dependencies, and operation-specific authorization decisions in both directions along a workflow.
Agent-ZTA addresses a concrete authorization dependency: a security event at one agent changes the state considered for the affected delegation branch, including relevant ancestors and descendants, while trusted policy determines which operations remain exercisable. Branch-scoped restrictions allow affected requests to be denied or confined to reduced-privilege execution while unrelated paths retain their independent authorization context.
This paper develops Agent-ZTA, a chain-aware Zero Trust authorization and containment model for autonomous multi-agent AI systems. The model distinguishes a downstream agent’s maximum legitimately delegated authority, denoted , from the authority it can currently exercise, denoted . The basic safety constraint is
Section IV-B makes the dependence on the delegation path and request context explicit, writing and . Agent-ZTA re-evaluates using security-state information associated with the requesting agent and policy-relevant delegation dependencies. Downstream degradation can also mark a parent’s affected workflow context for reassessment without equating this with compromise of the parent’s entire identity. The model couples these state transitions to deterministic authorization, branch-scoped restriction, and a reduced-privilege jail mode for selected operations. Each effective permission set remains bounded by , and policy decisions are evaluated outside the language model. Sections IV and VI specify the state and authorization rules.
This paper makes the following technical contributions:
Delegation-chain problem formulation. Distinguish the validity of delegated credentials from the current authorization state of an affected branch when an upstream or downstream agent degrades.
Bidirectional state model. Define propagation of security-state effects along authenticated delegation dependencies, with explicit branch relevance and isolation from unrelated workflow paths.
Authorization and containment rules. Define a deterministic request decision procedure and restricted jail-mode permission set, then derive bounded-authority properties and worked authorization traces.
Section II reviews the closest foundations and competing approaches, and Section III defines the threat model. Section IV specifies the security model, Section V presents the reference architecture, and Section VI details the authorization mechanism. Section VII analyzes intended security properties and illustrative scenarios; Section VIII discusses limitations and future evaluation, followed by the conclusion in Section IX.
Related Work
Zero Trust, Agent Identity, and Runtime Enforcement
NIST SP 800-207 frames Zero Trust as a security approach in which trust is not conferred solely by network location and access is evaluated explicitly at relevant boundaries [1].
For autonomous agents, this creates a distinction between establishing who is acting and deciding whether that actor should perform a particular operation now. Agent-specific identity research explores fine-grained credentials, accountable non-human principals, lifecycle controls, and the relationship between identity standards and agent behavior [2, 3, 4]. These approaches can establish the identity or origin of an agent and support traceability; they do not alone imply that a currently valid downstream credential remains safe to exercise after an upstream security incident.
Research on runtime enforcement moves policy decisions outside free-form model generation. ZT-MCP considers Zero Trust controls for MCP-connected tool access [7]; action-centric models emphasize governing tool calls and other agent actions rather than treating successful authentication as sufficient [8]. SwarmGov-ZT examines runtime governance with changing trust information in a multi-agent cybersecurity setting [9]. In transaction authorization, the Intent-Bound Withdrawal Authorization Protocol (IWAP) separates valid workload identity from permission to execute a particular withdrawal by requiring independently checked intent, transaction effects, and current admission state [24]. A framework for AI-assisted vulnerability disclosure likewise binds its actions to current evidence revisions, human approvals, policy, and revocation state rather than treating an earlier approval as indefinitely sufficient [25]. Agent-ZTA adopts independent policy enforcement as an architectural foundation, not as its claimed invention. Its additional concern is the source and interpretation of the security information used in a downstream access decision: relevant state may originate at an upstream delegator rather than the current tool-calling agent.
Delegation Chains, Capability Attenuation, and Revocation
Delegation is necessary when agents act on behalf of users or other agents. Foundational agent-delegation discussions emphasize authenticated delegation and the ability to distinguish the current actor from the principal on whose behalf it acts [10]. CapChain uses field-scoped capability tokens, verifiable provenance, and a capability-aware state reducer to constrain shared-state field access and forwarding between agents [11]. It addresses a different access-control surface from downstream tool-authorization decisions. Work on bounded agents addresses delegation limits and the risks created by compositions of individually permissible actions [12]. Delegation Without Trust studies sender-bound, attenuated credentials and external enforcement in the presence of potentially untrusted agent behavior [13]. These contributions are especially close to Agent-ZTA because they already address multi-hop authority, containment, and the need not to trust a language model with policy decisions.
The critical distinction is between the bound of authority conferred by delegation and the portion of that authority currently exercisable. Capability attenuation can ensure that a child is not granted a broader scope than its parent. Credential expiration or revocation can terminate an authorization grant. Agent-ZTA does not replace these controls. Rather, it considers the policy case in which a downstream agent’s credential has not expired or been revoked, yet the state of a relevant upstream principal has deteriorated. A chain-aware mechanism must specify whether this change should restrict the downstream agent’s effective authority before, or independently of, ordinary credential revocation. Whether a particular existing system already implements such a rule must be assessed from its actual policy semantics, not inferred merely from its use of delegation chains.
Authorization Propagation in Multi-Agent AI Systems examines transitive relationships and changes in authorization validity at a workflow level [14]. Agent-ZTA extends the policy question beyond credential validity and transitive authorization: it binds accepted security events at either end of a delegation dependency to the affected workflow context. Upstream events can constrain downstream requests, while downstream events can trigger reassessment of dependent parent-workflow operations. The impact remains branch-scoped and operation-specific rather than automatically changing every principal’s global security state.
Dynamic, Risk-Adaptive, and Continuous Authorization
Static role or capability checks are not always sufficient during long-running agent workflows. Risk-adaptive mechanisms can incorporate contextual information and changing risk indicators when deciding whether to allow an operation. Bhushan et al. describe risk-adaptive authorization for agentic AI systems, combining delegated access with policy-based decisions [15]. SwarmGov-ZT considers dynamically updated trust and governance information [9]. Related preprint work explores uncertainty-aware decision-making and context-sensitive authorization [16].
These systems establish that continuous or risk-aware authorization alone cannot be claimed as novel. They also introduce an important comparison challenge: a sufficiently expressive generic policy engine could, in principle, consume upstream chain-state attributes if those attributes were supplied. Agent-ZTA’s proposed contribution must therefore lie in an explicit model of which upstream agents are relevant, how changes are associated with delegation dependencies, and how resulting policies constrain effective downstream authority. Simply adding a numerical “chain risk score” to a conventional access request would not, by itself, establish a distinct mechanism.
Cross-Agent Attacks, Workflow Context, and Semantic Integrity
Security of an individual request does not imply security of the larger workflow. A broad examination of multi-agent security challenges identifies risks arising from interactions among otherwise legitimate components [6]. The AgentDojo benchmark provides an environment for evaluating prompt-injection attacks against tool-using agents [17]. Other studies investigate attacks that exploit dependencies and interactions across agent tasks. Agents Under Siege studies optimized prompt attacks against multi-agent systems [18], while Conjunctive Prompt Attacks investigates attacks whose effect depends on combining inputs across an agent system [19]. Research on indirect prompt injection in deployed-style workflows further illustrates how untrusted content can affect agent actions [20].
These studies demonstrate that adversarial influence may cross component or agent boundaries. Their primary research object, however, is often attack success, prompt manipulation, or task integrity rather than the formal status of downstream delegated permissions. Similarly, semantic-state governance research considers situations in which policy checks and tool calls remain locally valid despite corrupted operational meaning [21]. Such work is adjacent to, but distinct from, the question of whether an upstream agent’s degraded security condition should reduce a downstream delegate’s exercisable authority. Agent-ZTA treats security-state information as an input to authorization; it does not propose a new prompt-injection detector or claim to solve semantic integrity generally.
Defense papers also suggest useful design boundaries. Task Shield seeks to enforce task alignment against indirect prompt injection [22], and IPIGuard applies tool-dependency information to constrain agent operations [23]. These mechanisms inform the need for explicit enforcement and workflow context. They should not be conflated with a delegated-authority mechanism unless their policies specifically track upstream principal security conditions and use them to alter downstream authorization.
Research Positioning and Design Focus
Existing research provides identity governance, authenticated multi-hop delegation, capability attenuation, revocation, request-level risk adaptation, and independent enforcement. Agent-ZTA combines these foundations with an explicit relation between delegation-path dependencies and security-state events at any participating agent. It specifies how affected upstream and downstream workflow contexts are re-evaluated and how sensitive operations can enter a restricted containment mode while unrelated branches remain separately authorized. This focus complements the multi-hop and bounded-delegation techniques of [12, 13, 14, 15].
The central technical problem is to convert an accepted security event into a deterministic, operation-specific authorization restriction over the affected delegation branch. Agent-ZTA handles this by binding each request to its authenticated path, evaluating the security states relevant to that path, and intersecting the resulting restriction sets with its original delegated authority. Bidirectional state effects and branch-local containment distinguish this formulation from a purely caller-local authorization rule.
Threat Model
System Setting and Protected Assets
We consider an autonomous multi-agent workflow in which a user or service principal delegates a task to an agent, which may delegate narrower subtasks to further agents. Let a representative delegation path be , where requests an operation from a protected tool or resource. Each delegation conveys a bounded set of permissions. The authorization system can identify the requesting agent and associate its request with the relevant delegation path. A credential may remain valid throughout the scenario; validity alone does not imply that executing the requested operation remains appropriate after the chain’s security condition changes.
The principal asset to protect is the legitimate exercise of delegated authority at tool or resource boundaries. This includes preserving original permission limits; re-evaluating dependent operations when security events originate upstream or downstream; containing affected workflow branches without automatically restricting unrelated branches; and maintaining an auditable basis for authorization decisions. Confidentiality, integrity, and availability of the underlying resources may be affected by improper tool use, but this paper does not claim to provide a comprehensive solution for every such failure.
Adversary Capabilities and Security-State Events
The adversary may influence or compromise an agent or its operating context at any position in a delegation path. Relevant examples include malicious instructions injected through an untrusted tool response, manipulation of retrieved or shared context, or an agent process operating under unauthorized control. These examples generate security-state events for the affected agent and the workflow dependencies associated with that event. The adversary may cause the affected agent to propose unauthorized subtasks, initiate misleading delegation requests, or attempt to induce downstream agents to misuse permissions already issued to them.
One core case has an upstream agent degrade while downstream agents retain valid identities and delegated credentials. A second case has a downstream agent ingest a malicious input, triggering reassessment of the affected upstream workflow context. The adversary need not forge those credentials or obtain new permissions: the potential failure occurs when an authorization system treats the continuing validity of downstream authority as sufficient despite a security-relevant upstream change. We also allow a compromised upstream agent to issue additional requests within the bounds it already holds. Ordinary out-of-scope actions and invalid credentials should be rejected by conventional enforcement and are not the distinguishing cases studied here.
A security-state event is an externally supplied indication that an agent’s security condition has changed, such as a compromise flag, a policy-relevant anomaly, or an integrity-degradation signal. The authorization model consumes accepted events and propagates policy-relevant effects over authenticated delegation dependencies; detection remains a separate function. An event does not automatically imply that every downstream operation is malicious. Its authorization consequence depends on a later-defined deterministic policy and on the delegation relationship.
Trust Boundaries and Assumptions
The model uses the following trust boundaries and assumptions:
Reliable identity and delegation provenance. The system can identify the current requesting agent and retrieve an integrity-protected record of the relevant parent–child delegation relationships and original permission bounds. The paper does not propose a new cryptographic identity or credential format.
Trusted authorization infrastructure. The policy decision and enforcement components, along with the source of authoritative policy and delegation records, are treated as trusted for the purposes of this model. An adversary controlling those components is outside scope.
Mediated resource access. Protected operations pass through an enforcement point that can deny or constrain access according to the current decision. Direct, unmediated access to a tool is outside the guarantees contemplated by the model.
Available security-state inputs. Policy-relevant state information and its association with agent identities can be supplied to the authorization system. The correctness, timeliness, and completeness of these inputs are assumptions or limitations, not established results.
Observable decision boundary. The system can re-evaluate authorization at a controlled request or tool-invocation boundary. The proposal does not assume that previously completed actions can be reversed or that distributed actions can be interrupted instantaneously.
Section VI-C defines the handling of missing, stale, or unverifiable required state inputs. The default is to deny the affected request, rather than infer a normal state from missing data. The policy determines which delegation dependencies and operations are affected; neither an upstream warning nor a downstream event automatically revokes the authority of every connected agent.
Illustrative Threat Scenario
Consider , where is a protected tool. At time , valid delegations authorize to invoke a limited operation on . At a later time , a relevant security-state signal indicates that is compromised or operating under degraded integrity. Neither nor has necessarily changed its local credentials, and ’s original delegated permissions remain valid.
A baseline that checks only ’s identity, its delegated scope, and the current tool request could allow the invocation. That outcome would not mean the baseline is intrinsically insecure: it would indicate that the baseline has not been supplied with or configured to act on the upstream state change. Agent-ZTA evaluates whether is a policy-relevant ancestor of and whether the accepted event changes ’s currently exercisable authority for this operation. The applicable restrictions are defined in Sections IV-D and VI; depending on the branch and requested action, the decision can remain unchanged or become more restrictive.
This scenario isolates the targeted failure mode: valid downstream authorization artifacts coexist with a newly degraded upstream security condition. It differs from a stolen credential, an attempt to exceed the original delegation bound, or an invalidly signed request, all of which can be addressed through existing identity and delegation checks.
Security Objectives and Out-of-Scope Threats
Within these assumptions, the authorization model preserves original delegation bounds, propagates relevant event effects across authenticated upstream and downstream workflow dependencies, selects operation-specific restrictions, confines affected branches to reduced-privilege execution when required, and enforces decisions outside agent-generated text.
Outside scope are creating an intrusion-detection system, guaranteeing correct classification of compromises, repairing a manipulated agent’s reasoning, preventing every prompt-injection attempt, securing resources that bypass the enforcement point, defending against compromise of the trusted policy infrastructure, and reversing operations already completed before a state change is observed. The effects of delayed or inaccurate security signals and the runtime cost of chain-aware decisions remain open questions outside the scope of this paper. These boundaries keep the mechanism focused on authorization and branch-specific containment.
Security Model
This section formalizes delegated authority, time-varying security states, bidirectional event effects, and branch-scoped containment. Sections V and VI connect these definitions to the authorization components and decision procedure.
Delegation Graph and Provenance
Let be a set of principals, including users, services, and agents, and let be a directed delegation graph. An edge records that principal has delegated some authority to principal . Each edge is associated with an authorized scope , where is the universe of protected operations (for example, resource–action pairs). Delegation records are assumed to have verifiable provenance and to satisfy any applicable validity conditions, as established in the threat model.
A request identifies requesting agent , requested operation , relevant request context , decision time , and the authenticated delegation path relied upon for that request. When an agent has multiple delegation paths, identifies the specific path supporting this request; unrelated paths are not silently combined to gain permissions. Which paths may legitimately support a request is determined by the underlying delegation policy, not by the agent’s own assertion. The workflow branch used by the containment rules is determined by and (Section V-C), so it is not a separate request field.
For the chosen path, define the upstream and downstream principals of any on ; in particular, for the requesting agent .
This path-specific definition matters: an incident affecting an agent outside is not automatically an incident affecting ’s authority under .
Delegated Authority and Effective Authority
The delegated authority bound is the maximum set of operations that agent may legitimately perform through path , before applying current security-state restrictions. For a valid path, it is bounded by every edge scope along the path:
In particular, when delegates to , the latter cannot acquire additional authority through that path: , where denotes the corresponding prefix of . These are established attenuation constraints, not the novel component of Agent-ZTA.
The effective authority is the set of operations that agent is authorized to exercise at decision time , under context and path . The central non-escalation invariant is
An apparently valid credential establishes an admissible delegation bound; it does not, by itself, establish that the whole bound is exercisable at every later time.
Security-State Inputs and Chain Relevance
Let denote the security-state information available to the authorization system for principal at time . The state vocabulary records authorization-relevant conditions; the label unavailable is assigned when a required record is absent, unverifiable, or outside its freshness window (Section VI-C) and is never inferred as normal. Each accepted event binds to a principal, affected delegation-path or workflow context, observation time, and provenance. State-event acceptance is distinct from intrusion detection.
Not every observed event affects every operation or delegation path. Define as the upstream principals whose reported states are policy-relevant to operation for agent under path and context . The resulting relevant chain-state input is
The relevance relation is controlled by trusted policy. For the same chain, an ancestor’s degraded condition can restrict a sensitive write while leaving an unrelated read unaffected. Accepted downstream events can additionally mark a specific upstream workflow context for reassessment; this contextual taint does not equate to compromise of the parent principal across all its tasks.
Bidirectional Event Propagation and Branch State
Let an accepted event be , where identifies the affected principal, identifies the authenticated workflow or delegation context, is the reported condition, is the observation time, and is its provenance. For a path and a principal on it, and are its upstream and downstream principals on (see Eq. (2)). Trusted policy selects the event’s affected context and relevant dependencies using
The set represents authorization impact, not an assertion that every included principal is independently compromised. An event at an upstream delegator can restrict descendants relying on that delegation. Conversely, an event at a downstream agent can taint the parent workflow context associated with the affected branch, causing its parent to re-evaluate actions that depend on that branch. An unrelated branch without the affected dependency is not included automatically.
For each authenticated workflow context , define an accepted branch-condition record assembled from relevant accepted events. The PDP reads together with principal states when applying policy. Relevance, event provenance, freshness, and branch association are verified before this record influences an authorization decision. Reaching an ancestor through does not overwrite that ancestor’s identity or security state in unrelated workflow contexts.
Branch-Scoped Containment State
Let be the containment mode of the affected workflow branch, assigned by trusted policy from the accepted branch record:
where maps a branch record to a mode and returns normal when no relevant event has been accepted for . Let be the operations allowed in jail mode; the policy excludes sensitive operations from this set and may choose . Define
where is a configured restricted-mode allowance. Because is determined by , event effects propagated in either direction reach the authorization rule through . The resulting permission set is always intersected with the legitimate delegation bound. A jail mode is therefore an authorization restriction; execution isolation additionally requires an enforcement environment that prevents access outside the restricted boundary. The model does not infer such isolation solely from a change in policy label.
Chain-Aware Authorization Function
Let denote the trusted authorization policy. Formally, computes a set of currently permitted operations from the requesting agent’s own security information, the policy-relevant upstream information, and other applicable context. We define effective authority by intersection, incorporating the branch-mode restriction:
The dot indicates that relevance and the allowed-set calculation may depend on the operation being considered; the branch context is authenticated with the request. Equivalently, a specific request is permitted only if its operation is within the legitimate delegation bound and its current chain-aware policy check passes:
Here is deterministic for a fixed, authoritative input snapshot. Section VI-C specifies how the PDP selects accepted input snapshots and checks required provenance and freshness; no instantaneous global state consistency is assumed.
This formulation exposes the intended distinction from a purely local baseline. The baseline may evaluate a local policy on only, whereas Agent-ZTA additionally binds on , the relevant upstream states, and the branch allowance , which is determined by the accepted branch record . The distinction concerns the decision inputs and the treatment of delegation dependencies, not a claim that existing policy engines lack conditional-access capabilities.
State Changes, Restriction, and Reassessment
Let and suppose an upstream principal has a reported security-state change between those times. If is relevant to a requested operation, the policy can reassess the operation using the new state information even when , ’s identity, and its credentials have not changed. The resulting authority may be unchanged, reduced for some operations, or empty (suspension or denial):
where denotes the set of subsets of the original delegation bound. In particular, represents no currently exercisable operation under that path and context; it need not imply permanent deletion of a credential.
For a fixed policy, delegation path, and other decision inputs, a policy may be designed so that security degradation cannot increase the authority it permits. This optional monotonicity condition can be written as
where means that represents no more trustworthy security conditions than . This is a proposed policy property under stated assumptions, not a claim that all contexts, policies, and state labels admit a total trust ordering. Recovery or a newly authorized context may legitimately change effective permissions, but cannot expand them beyond .
Propagation is evaluated in both directions across authenticated delegation dependencies: upstream events affect policy-relevant descendants, and downstream events taint the associated parent workflow context. Both directions update subsequent mediated decisions and can change ; neither rewrites the original delegated authority.
Worked Authorization Example and Model Boundaries
Consider , with a valid path-specific bound on a protected resource. At , assume the relevant policy allows both operations. At , an externally supplied state signal indicates that is degraded. For an illustrative policy in which is relevant to write authorization but not to read authorization, the model may yield
The credentials and bound remain unchanged. The new decision arises solely from the upstream state input and applicable policy. A stricter policy might instead yield ; a policy that considers irrelevant to the requested operation might leave the decision unchanged. These are worked policy cases derived from the stated predicates, not measurements.
The definitions establish the state, path, and branch-mode constraints used by the decision procedure in Section VI. Event production, trust in input provenance, and state freshness remain separate operational dependencies.
Agent-ZTA Architecture
This section defines the Agent-ZTA authorization and containment architecture. The design integrates authenticated delegation paths, bidirectional branch-state updates, independent policy evaluation, and restricted execution modes. The security model in Section IV supplies its decision inputs and invariants.
Architectural Overview
Figure 1 contrasts two designs for the same workflow. In panel (a), a typical multi-agent delegation workflow, each agent consults a language model to plan and draft tool calls, and a protected tool is reached after only an identity and static-scope check. Panel (b) shows the Agent-ZTA authorization boundary for a protected tool invocation by a downstream agent. Agents plan and delegate tasks, but neither language-model output nor self-reported security status is authoritative for access control. A policy enforcement point (PEP) mediates protected operations; a policy decision point (PDP) evaluates authenticated delegation provenance, applicable permission bounds, accepted principal and branch-state records, and trusted policy. The same decision boundary applies when an accepted event arises upstream or downstream: the event affects only the policy-relevant workflow context and operations. The request path (steps 1a–6 in the figure) follows the decision procedure of Section VI-D, and the separate state-change path (E1–E3) updates the chain-state view. The supporting records are distinct responsibilities, not necessarily separate storage services.
Figure 1. Agent-ZTA architecture for the delegation chain with an unrelated branch through . (a) A typical multi-agent workflow: agents consult an LLM, and the tool is reached after an identity and static-scope check only. (b) Agent-ZTA: the LLM only proposes actions, while a PEP and a deterministic PDP decide using delegation provenance, trusted policy, and the chain-state view. Request flow, mapped to the steps of Section VI-D: 1a–1b authenticate and fetch the PDP intercepts ’s call and sends to the PDP; 2 check the delegated bound ; 3 select relevant upstream principals ; 4 read the decision snapshot ; 5 apply branch containment and restrictions and return Permit or Deny; 6 enforce at the tool boundary (permit, jail mode, or deny). State-change flow: E1 an external monitor reports an event; E2 the chain-state view accepts it after provenance and freshness checks; E3 marks the affected branch (red: an upstream event restricts descendants; pink: a downstream event taints the parent context) and sets (Sections IV-D and IV-E). Dashed connectors link components that are the same, or replaced, across the two panels.
Components and Responsibilities
The architecture separates six principal responsibilities:
Agent workflow and protected tools. Agents execute delegated tasks and request operations on protected resources. Each protected operation must pass through an authorization boundary; the architecture does not assume that agents can be trusted to police their own tool calls.
Policy enforcement point (PEP). The PEP intercepts a tool or resource request, supplies its authenticated request information for evaluation, and executes the operation only when the returned authorization decision permits it. A denial does not depend on an LLM obeying a natural-language warning.
Policy decision point (PDP). The PDP evaluates whether the requested operation lies within the authenticated path-specific bound and satisfies the chain-aware policy of Eq. (10). The PDP also applies the accepted branch condition and selected containment mode.
Delegation and provenance records. Trusted records identify the delegation edges, permitted scopes, and path that legitimately supports the request. They provide the basis for deriving and . A requesting agent must not be allowed to invent or alter its own upstream path to avoid a relevant restriction.
Chain-state view. This component associates accepted principal-state events , branch-state records , delegation contexts, provenance, and freshness metadata. It supports event effects in either direction across the authenticated chain.
Policy repository. Trusted policy defines which ancestors are relevant to which operations, how their reported states influence the decision, and how missing or outdated information is treated. Policy also defines affected-branch selection and restricted or jail-mode allowances, without imposing uniform revocation on unrelated paths.
Identity validation, credential verification, and protected audit records may be provided by existing infrastructure. They are necessary supporting controls, but the paper does not introduce new cryptographic protocols, independent monitoring systems, or a new language-model security classifier.
Authorization and State-Change Paths
At a protected request boundary, the PEP receives an operation , requesting agent , and context . The authorization infrastructure verifies the requester and the delegation path , derives the legitimate bound , and associates the request with its authenticated workflow branch . The PDP reads the accepted security-state snapshot, including the requester’s condition, policy-relevant ancestors, and , which captures accepted bidirectional event effects. It then applies the branch allowance and the authorization rule in Eq. (16). The PEP permits the protected operation only when the resulting decision is PERMIT.
A security event follows a separate state-input path. An upstream event at can constrain a request by when ; a downstream event at can mark the dependent parent-workflow context for reassessment through in Eq. (6). Both cases update the accepted branch view rather than changing existing delegation credentials. Under a selected policy, a degraded branch may retain a read operation while denying a sensitive write, or enter a restricted or jail mode. These are outcomes of the specified policy predicates
for the accepted state, not empirical measurements.
A security-state update affects an authorization decision when the PDP has accepted that update at a mediated request boundary. The snapshot, freshness, and required-input rules are specified in Section VI-C. The model does not assume instantaneous delivery to all dependent branches or cancellation of operations already in progress.
Design Invariants and Trust Boundaries
Four constraints guide the architecture. Delegation-bounded authorization requires independently of security-state changes. Bidirectional dependency relevance binds accepted upstream or downstream events to the affected authenticated workflow context without treating every connected principal as compromised. Branch-scoped containment intersects effective authority with while separately evaluating unrelated branches. Independent enforcement requires a protected operation to be mediated by a trusted PEP acting on a deterministic PDP decision rather than on agent-generated instructions. These constraints are evaluated under the trusted-component assumptions in Section III.
The trusted boundary comprises policy, delegation provenance, the decision and enforcement components, and the integrity of information provided to them. Agent-generated content and external inputs are not authoritative authorization sources. The quality and timing of external security-state signals remain assumptions: Agent-ZTA governs the authorization consequences of accepted events from either direction, rather than detecting those events. Jail mode restricts authorized operations; physical process or network isolation additionally requires an enforcing sandbox boundary.
Scope of the Proposed Architecture
The principal distinction from caller-local authorization is the combined use of an authenticated delegation dependency , operation-relevant upstream state , and accepted branch state when deciding effective authority. The branch record captures relevant event impacts in both directions, while restricts selected operations in normal, restricted, or jail mode. The model reuses existing PEP/PDP and credential mechanisms; its contribution is the decision structure that associates state changes with branch-specific authority.
Section VI specifies the resulting decision semantics and state-handling rules.
Chain-Aware Authorization Mechanism
This section specifies the deterministic authorization and containment decision procedure that applies the security model in Section IV. Each request is bound to a verified delegation path and workflow context, the accepted bidirectional branch-state record, and a policy-selected containment mode.
Decision Inputs and Policy Responsibilities
For each protected request , the PEP forwards authenticated request attributes to the PDP. The PDP obtains: (i) the verified path and path-specific delegated bound from trusted delegation records; (ii) the applicable policy version ; (iii) security-state records for the requesting agent and each upstream principal in ; and (iv) the accepted branch-condition record for the authenticated branch , from which policy derives . A state record includes an asserted condition, principal identifier, and available provenance and observation-time metadata. Signal production and compromise detection are outside Agent-ZTA’s proposed contribution.
The trusted policy identifies operation-relevant ancestors and affected workflow branches and then selects the permissible operations using the accepted security-state records and branch-containment allowance. In particular, an agent cannot select an alternative path merely to evade a restriction, and it cannot supply its own authoritative state or policy. Where multiple legitimate paths exist, each request is evaluated against the particular authenticated path on which the requested authority depends; this paper does not assume that permissions from independent paths can be combined.
Bounded Chain-State Restriction Rule
The policy representation makes the decision rule explicit. Let denote the ordinary local and contextual permission predicate, and let be the set of operations allowed by the requester’s own reported security condition. For each relevant ancestor , let be the set of operations the policy permits downstream of under that reported condition. These functions are policy-defined restrictions, not new credentials or security detectors. Together they expand the generic policy set of Section IV-F: , so (16) is the single-operation form of (10). The accepted branch record enters through via ((7)). For a fixed, accepted input snapshot , define the effective set operation by operation:
The operation-specific relevance set is the one defined in Section IV-C, evaluated under the applicable policy and accepted snapshot. Defining the set operation by operation avoids imposing an ancestor’s restrictions on a different operation for which that ancestor is not relevant.
Intersection makes the non-escalation property immediate: regardless of the state values. In the illustrative policy family used here, a degraded state may remove certain operations from an ancestor’s downstream allowance, while a compromised state may remove more. This is a choice of policy, not a universal ordering of all possible security signals. A report of degradation does not automatically revoke every descendant or every operation.
State Selection, Freshness, and Missing Inputs
The PDP evaluates each request against a decision snapshot: the verified path and delegation scopes, a specific policy version, and the security-state records accepted for that decision. For each required state record, the policy specifies whether its source is acceptable and whether its age is within a defined freshness condition. An absent, unverifiable, or out-of-policy-age required record is classified as unavailable, rather than silently treated as normal. The policy must specify a conservative outcome for unavailable inputs; in the proposed default for a protected operation, a required unavailable input results in denial of that operation until sufficient information is available. This is a formal fail-closed rule, not a claim of immediate revocation or globally synchronized storage.
State records can arrive asynchronously. Consequently, a completed decision reflects only the accepted records visible at its decision boundary. The mechanism does not guarantee that a newly detected compromise is known to all PDPs immediately, that a permit remains safe indefinitely, or that an already executed action can be reversed. Where a new security-state record becomes visible, subsequent affected requests are re-evaluated using the newer accepted snapshot. An implementation may use versions or expiration information to distinguish records, but no particular distributed synchronization protocol is prescribed here.
Per-Request Decision Procedure
The deterministic procedure proceeds as follows:
Authenticate and bind. The PEP intercepts the request and supplies the requesting principal, operation, and context. The PDP verifies the principal and the authenticated delegation path . If identity or path verification fails, return DENY. (Figure 1, steps 1a–1b.)
Check delegated bounds. Derive from trusted, currently valid delegation records. If , return DENY without attempting to enlarge the bound through a security-state policy. (Figure 1, step 2.)
Select relevant upstream principals. Under the applicable trusted policy, obtain . This set is computed from the verified path and request attributes, not from the requester’s claimed security condition. (Figure 1, step 3.)
Read a decision snapshot. Obtain accepted principal records, relevant upstream conditions, and branch-state record , including downstream-to-parent event effects. Reject missing, stale, or unverifiable required inputs. (Figure 1, step 4.)
Apply branch containment and restrictions. Determine and check , , , and every relevant ancestor predicate . Return PERMIT only if every condition holds; otherwise return DENY. (Figure 1, step 5.)
Enforce at the boundary. The trusted PEP executes the requested operation only on a PERMIT decision for that request and snapshot. A later request requires a new decision; a prior permit is not a permanent authorization grant. (Figure 1, step 6.)
For valid and available inputs, the single-operation rule is therefore
The rule is evaluated only after the required identity, path, record-validity, and freshness checks succeed; failure of any required preliminary check yields DENY. The result is deterministic given the same verified inputs and policy version, not necessarily identical across decisions made with different snapshots.
Upstream Changes, Recovery, and Scope of Propagation
Suppose an accepted report changes the state of upstream agent from normal to degraded while ’s credentials and remain unchanged. If , the event does not directly alter the decision for through this mechanism. If , the PDP applies to the new accepted state on the next affected decision. An operation may then be denied, or remain allowed if the policy does not restrict that operation under the new condition. This is reauthorization of descendants through a delegation dependency; it is not credential revocation or an assertion that every descendant must be blocked.
For a fixed path, policy, context, and all other state inputs, a useful security design condition is that an ancestor’s degradation does not increase its downstream allowance: if , then . In this restricted setting, Eq. (15) implies that the resulting effective authority cannot increase. This is an analytical consequence of the specified policy condition, not a proof of end-to-end security under faulty signals or concurrent updates. Recovery may restore some operations after an accepted improvement in the relevant state; any restored authority still remains within . No time-to-recovery or automatic trust-restoration guarantee is assumed.
Reverse Propagation and Restricted Branch Execution
For an accepted downstream event at agent , the PDP determines the authenticated branch on which the affected execution depends and updates its accepted event view. Under in Eq. (6), an upstream delegator is marked for reassessment only for that dependent branch. A parent with an unrelated task or delegation path retains a separate decision context. This approach models reverse propagation as a change in authorization-relevant workflow state, not an unsupported assertion that compromise of a child necessarily compromises its parent process.
Trusted policy sets to restricted or jail when a required event condition is met. The PDP then intersects the request’s allowance with in Eq. (8). For example, a jailed branch may be permitted only to read approved diagnostic material while write, network publication, and new delegation are denied. If an execution sandbox is available and enforced, the branch is routed to that restricted environment; absent such an enforcement boundary, the algorithm guarantees only the stated authorization denial, not process isolation. Operations on unrelated branches are evaluated using their own authenticated branch contexts.
Illustrative Trace and Mechanism Boundaries
Consider the verified path and . Assume the policy makes relevant to a write request but not to a read request, and assume all required records are acceptable unless stated. At , is reported normal and both operations pass the policy. At , an accepted record reports as degraded; under the illustrative , write is excluded while read remains permitted, and neither ’s delegation bound nor its credential changes. At , the record for that is required for write becomes unavailable (absent or stale), and the fail-closed rule denies write. A second case starts with a security event at after ingestion of an untrusted input. Policy marks ’s workflow context on this same branch for reassessment and sets , so the branch loses write authority under while a separate unaffected workflow path remains subject to its own policy inputs. Table I lists these cases together with two boundary cases: an unrelated degraded principal and an operation outside the original scope.
| Situation | Relevant policy inputs | Outcome |
| All accepted states normal () | Valid path; normal | Read and write permitted |
| Upstream degraded () | Accepted record; relevant to write only | Read permitted; write denied |
| Required state unavailable () | Record for missing or stale for write | Write denied (fail-closed) |
| Event at (untrusted input) | Accepted event; | Write denied on branch ; other branches unchanged |
| Unrelated principal degraded | Principal not on the authenticated path | No restriction from that event |
| Write outside original scope | Write denied regardless of state |
Table I. Worked authorization decisions for under the specified policy predicates (not empirical measurements).
The mechanism assumes trusted provenance and policy inputs, mediated tool access, and an accepted decision snapshot. These assumptions delimit when branch restriction and jail-mode permissions are enforceable. Independent signal generation and physical sandbox isolation require corresponding external controls.
Security Properties and Illustrative Scenarios
This section states authorization properties and the assumptions under which they hold, using the state model and decision rule in Sections IV and VI. The arguments assume trusted PEP/PDP components, authenticated delegation provenance, a fixed policy version, and an accepted state snapshot at the decision boundary.
Delegation-Bound Preservation
Property 1 (non-escalation within a path). For any request context, policy, and accepted security-state snapshot, the mechanism’s effective authority cannot contain an operation outside the requesting agent’s valid path-specific delegation bound:
Argument. (15) constructs the effective set by selecting operations that also satisfy local and upstream restrictions. Thus no policy-state input can add an operation not already contained in . This set-theoretic property does not itself establish that the delegation records are authentic; that remains a trust assumption.
Reassessment of Relevant Upstream Changes
Property 2 (conditional downstream restriction). Fix an authenticated path , a requested operation , a request context , and policy . Suppose an accepted security-state record for upstream principal changes, with , while all other accepted decision inputs remain fixed. If the new state causes , the next affected evaluation denies , even if the downstream credential and have not changed.
Argument. The required conjunction in (16) becomes false for principal . The claim therefore follows for a subsequent mediated request evaluated with the updated accepted record. If an ancestor is not relevant to , its state change does not by itself alter this particular decision. This is a policy-scoped propagation property, not blanket revocation of every descendant.
A stronger restriction-ordering property is available only if configured by policy. When and the ancestor allowance is monotone, so that
then, with the same path, relevance relation, context, other states, and policy, degrading only ’s state cannot increase the operations allowed by the mechanism. There is no assertion of monotonicity across changing contexts, different policies, or incomparable state labels.
Mediated Decisions, Unavailable State, and Analytical Limits
Property 3 (request-bound enforcement requirement). Under the assumed non-bypassable PEP, an operation is executed only after the PEP receives a PERMIT for the corresponding request. The mechanism does not authorize a later request merely because an earlier one was permitted. The property depends on correct PEP/PDP integration; it is not established by the set equations alone.
Property 4 (conservative handling of required state). If a required state input fails the configured provenance or freshness conditions, the proposed default denies the affected operation (Section VI-C). This avoids interpreting a missing or stale required signal as evidence of a normal state. It may also reduce availability when state records are delayed or temporarily unreachable.
These statements distinguish decision correctness relative to accepted inputs from security correctness relative to the actual world. A false negative from an external monitor, delayed receipt of an incident, corrupted trusted infrastructure, or a tool call outside PEP mediation can invalidate the intended operational protection. Neither the model nor the examples below provide a bound on detection delay or guarantee containment of actions already in progress.
Bidirectional Branch Containment
Property 5 (branch-local restriction). Fix the policy, authenticated delegation graph, and accepted event view. If an event changes only branch and the policy restricts its containment allowance from to , then the effective authority computed for an affected request on cannot increase. The effective permission set on a distinct branch remains unchanged provided that is outside and all of its accepted decision inputs remain fixed.
Argument. (15) intersects the base permission set with the branch allowance. Replacing that allowance by a subset can only preserve or remove operations. The distinct branch uses a separate authenticated context and accepted input snapshot; no assumption of automatic global compromise is needed. The property concerns authorization sets, while execution-level sandbox separation depends on the enforcing environment.
Illustrative Delegation-Chain Scenarios
Consider the authenticated path , where ’s delegated bound permits on a resource. Assume normal local checks and a policy making ’s state relevant to write but not read. Table I (Section VI-G) summarizes the resulting decisions for successive requests; its rows are policy outcomes derived from the specified predicates, not experimental observations.
The crucial comparison is between two requests by whose identity and delegated bound remain unchanged. A local authorization baseline may permit both because it does not consume ’s changed state, whereas the chain-aware rule denies the affected write after accepting that record. This result follows from the specified policy inputs and does not constitute an empirical attack-success measurement.
What the Formal Analysis Does Not Establish
The stated properties are limited to the defined authorization boundary and assumptions. They do not constitute a proof that Agent-ZTA detects upstream compromise, prevents every malicious action, provides immediate global revocation, guarantees availability, or achieves lower attack success in practice. Such claims would require an explicit implementation model and empirical evidence. The analysis instead provides checkable invariants and cases against which any implementation can be assessed.
Limitations and Future Evaluation
Model Coverage and Evidence Boundaries
Agent-ZTA defines authenticated path bounds, accepted principal and branch-state inputs, bidirectional event impact, a deterministic authorization predicate, and branch-specific restricted modes. The set relationships establish bounded authority under the stated policy and trust assumptions. The worked decision traces demonstrate outcomes of those predicates for selected inputs; they are not empirical measurements of attack containment, latency, or sandbox isolation.
The approach relies on established delegation, policy enforcement, and risk-aware authorization foundations. Its distinctive decision structure associates security events with the authenticated dependency branch and uses that association to constrain later authority in either direction. Whether this structure provides an advantage over a well-configured chain-aware baseline requires direct comparison.
Assumptions and Practical Constraints
The mechanism depends on the correctness and provenance of delegation records, applicable authorization policies, state-to-principal associations, and PEP/PDP enforcement. Agent-ZTA does not produce compromise detections or solve prompt injection by itself: incorrect, incomplete, or delayed external signals can lead to unsafe permits or unnecessary denials. Required-state fail-closed behavior protects against silent optimistic assumptions but can reduce availability. Similarly, reauthorization occurs at mediated decision points; the model does not specify instantaneous state dissemination, cancellation of in-flight tool operations, or recovery of resources affected before a restriction was enforced.
Policy choices remain consequential. Defining which ancestors are relevant to which operations, when a reported condition counts as degraded, and whether recovery restores permissions requires context-specific decisions. Overly broad relevance rules can block legitimate work; overly narrow rules can overlook important upstream dependencies. The present model deliberately does not prescribe a universal risk score, anomaly detector, cryptographic credential format, or distributed coordination protocol.
Empirical Evaluation
An empirical evaluation can instantiate the specified rules in a controlled multi-agent testbed and compare them with a local/per-request authorization baseline. The comparison should examine downstream restriction after upstream events, parent-workflow reassessment after downstream events, branch isolation behavior, and authorization performance. The rule set and worked cases in this paper define what such an evaluation must measure.
A fair comparison should use the same delegated scopes and tool operations for both mechanisms, vary the source and timing of accepted events, and record changes in authorized operations, unaffected-branch continuity, and request decision cost. The chosen scenario set and tested implementation are separate from the mathematical results established in this manuscript.
Conclusion
This paper developed Agent-ZTA, a chain-aware Zero Trust authorization and containment model for multi-agent delegation. The model separates original path-specific delegated authority from current effective permissions and binds authorization decisions to accepted security-state events, authenticated workflow dependencies, and deterministic policy rules. It extends upstream-to-downstream reassessment with downstream-to-parent workflow tainting, while preserving branch specificity so that unrelated delegation paths are not restricted solely by association.
The resulting decision procedure incorporates freshness and provenance checks, a fail-closed rule for missing required state, and restricted or jail-mode allowances for affected execution branches. The security analysis states non-escalation, conditional downstream restriction, request-bound enforcement, conservative fail-closed handling, and branch-local restriction properties under the specified authorization predicates. Practical containment additionally depends on correct event inputs, non-bypassable enforcement, and an isolated execution environment wherever physical sandboxing is required. The model therefore provides a complete, checkable specification of bidirectional chain-state authorization, covering its state model, architecture, decision procedure, and security properties.
References
- [1]S. Rose, O. Borchert, S. Mitchell, and S. Connelly, “Zero Trust Architecture,” NIST Special Publication 800-207, Aug. 2020. doi: 10.6028/NIST.SP.800-207.DOI
- [2]K. Huang et al., “A Novel Zero-Trust Identity Framework for Agentic AI: Decentralized Authentication and Fine-Grained Access Control,” in Proc. AIxDKE, 2026, pp. 98–101. doi: 10.1109/AIxDKE67294.2026.00024.DOI
- [3]M. Nizamuddin and R. Sikder, “From Service Accounts to Agentic Identities: A Zero Trust Governance Framework for Delegated Authority, Runtime Tool Control, and Accountable Non-Human Actors in Enterprise Cybersecurity,” Informatics, vol. 13, art. 146, 2026. doi: 10.3390/informatics13090146.DOI
- [4]T. Otsuka, K. Toyoda, and A. Leung, “AI Identity: Standards, Gaps, and Research Directions for AI Agents,” arXiv:2604.23280, 2026.arxiv.org/abs/2604.23280
- [5]A. Chhabra, S. Datta, S. K. Nahin, and P. Mohapatra, “Agentic AI Security: Threats, Defenses, Evaluation, and Open Challenges,” IEEE Access, vol. 14, pp. 49455–49482, 2026. doi: 10.1109/ACCESS.2026.3675554.DOI
- [6]C. Schroeder de Witt et al., “Open Challenges in Multi-Agent Security: Towards Secure Systems of Interacting AI Agents,” arXiv:2505.02077, first posted 2025, revised 2026.
- [7]S. Mishra, “ZT-MCP: A Zero-Trust Security Architecture for MCP-Connected AI Agents,” in Proc. IEEE COINS, 2026. doi: 10.1109/COINS62956.2026.11715596.DOI
- [8]J.-H. Mok, H. Jo, and S. Lee, “An Action-Centric Zero Trust Maturity Model for Agentic AI Environments,” Sensors, vol. 26, art. 5205, 2026. doi: 10.3390/s26165205.DOI
- [9]W.-Y. Chen, T.-L. Pao, and Y.-C. Kao, “SwarmGov-ZT: Zero-Trust Runtime Governance for Trust-Aware Multi-Agent Cybersecurity Response,” Computers, vol. 15, art. 662, 2026. doi: 10.3390/computers15100662.DOI
- [10]T. South et al., “Authenticated Delegation and Authorized AI Agents,” arXiv:2501.09674, 2025.arxiv.org/abs/2501.09674
- [11]T. W. Choong, W.-B. Hsieh, and J.-S. Leu, “CapChain: A Capability-Token Access Control Architecture with Verifiable Provenance for Multi-Agent LLM Systems,” Applied Sciences, vol. 16, no. 15, art. 7776, 2026. doi: 10.3390/app16157776.DOI
- [12]X. Muruaga, “Bounded Agents: Delegation Security for Multi-Agent AI Systems,” arXiv:2608.15888, 2026.arxiv.org/abs/2608.15888
- [13]P. S. V. Dantuluri and J. Sundi, “Delegation Without Trust: An Empirical Gap Analysis of Identity, Authorization, and Runtime Governance in Multi-Agent LLM Systems,” arXiv:2609.00267, 2026.arxiv.org/abs/2609.00267
- [14]K. Tallam, “Authorization Propagation in Multi-Agent AI Systems: Identity Governance as Infrastructure,” arXiv:2605.05440, 2026.arxiv.org/abs/2605.05440
- [15]B. Bhushan, K. Pappu, V. R. Jadav, and N. Jaiswal, “Risk-Adaptive Authorization for Agentic AI Systems,” in Proc. IEEE SoutheastCon, 2026, pp. 1–6. doi: 10.1109/SoutheastCon63549.2026.11476129.DOI
- [16]C. Fleming, A. Kundu, and R. Kompella, “Uncertainty-Aware, Risk-Adaptive Access Control for Agentic Systems using an LLM-Judged TBAC Model,” arXiv:2510.11414, 2025.arxiv.org/abs/2510.11414
- [17]E. Debenedetti et al., “AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents,” in Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, 2024. doi: 10.5220/079017-2636.arxiv.org/abs/2406.13352
- [18]R. Shahroz, Z. Tan, S. Yun, C. Fleming, and T. Chen, “Agents Under Siege: Breaking Pragmatic Multi-Agent LLM Systems with Optimized Prompt Attacks,” in Proc. ACL, 2025, pp. 9661–9674. doi: 10.18653/v1/2025.acl-long.476.
- [19]N. H. Arif, Q. Lou, and M. Zheng, “Conjunctive Prompt Attacks in Multi-Agent LLM Systems,” in Proc. ACL, 2026, pp. 34175–34191. doi: 10.18653/v1/2026.acl-long.1577.DOI
- [20]H. Chang, E. Bao, X. Luo, and T. Yu, “Overcoming the Retrieval Barrier: Indirect Prompt Injection in the Wild for LLM Systems,” in Proc. 35th USENIX Security Symposium, 2026, pp. 1567–1586.arxiv.org/abs/2601.07072
- [21]M. Doyle-Spare, “Agentic AI Cyber Subversion: The Semantic Layer Integrity Attack as a New Threat Class Against the Reasoning Layer,” SSRN Working Paper, 2026. doi: 10.2139/ssrn.6926219.
- [22]F. Jia, T. Wu, X. Qin, and A. Squicciarini, “The Task Shield: Enforcing Task Alignment to Defend Against Indirect Prompt Injection in LLM Agents,” in Proc. ACL, 2025, pp. 29680–29697. doi: 10.18653/v1/2025.acl-long.1435.DOI
- [23]H. An et al., “IPGuard: A Novel Tool Dependency Graph-Based Defense Against Indirect Prompt Injection in LLM Agents,” in Proc. EMNLP, 2025, pp. 1023–1039. doi: 10.18653/v1/2025.emnlp-main.53.DOI
- [24]T. A. Syed, A. A. Khan, and A. Akrama, “Intent-Bound Authorization for Cryptocurrency Withdrawals Under Backend Compromise,” arXiv:2611.00839, 2026. [Online]. Available: https://arxiv.org/abs/2611.00839.
- [25]T. A. Syed and A. A. Khan, “PHP2Shell and the Future of AI-Discovered Vulnerability Disclosure: Evidence, Verification, and Human Authority,” arXiv:2610.36334, 2026. [Online]. Available: https://arxiv.org/abs/2610.36334.
