Agent-ZTA: A Chain-Aware Zero-Trust Model for Bidirectional Security State Propagation and Runtime Containment in Multi-Agent Delegation
Agent-ZTA: A chain-Aware Zero Trust Model for Bidirectional Security-State Propagation and Runtime Containment in Multi-Agent Delegation
The authors propose Agent-ZTA: a zero-trust authorization and containment model for multi-agent delegation chains, with formal rules and worked examples, and no experiments.
In autonomous multi-agent workflows, an agent at any position on a delegation path (e.g., U→A→B→C) may be influenced or compromised (e.g., via malicious instructions injected through untrusted tool responses); the adversary does not need to forge credentials—the failure point is that the authorization system treats the continued validity of downstream credentials as a sufficient condition. Assumes identity and delegation provenance are reliable, authorization infrastructure is trusted, resource access goes through mediated enforcement points, and security state inputs are available.
- In multi-agent delegation chains, credentials remain valid throughout the workflow, but the security state of agents on the chain may deteriorate during execution; authorization models that look only at the direct caller and static authorization scope cannot handle such in-flight state changes.
- Proposes Agent-ZTA: distinguishes the path-specific delegation permission upper bound Di from the currently exercisable effective permissions Ei(t), defines bidirectional security state propagation, branch-level containment (restricted/jail modes), and a deterministic authorization decision process, with decisions enforced outside the language model.
- The paper has no experiments. It provides an analytical argument for 5 security properties (non-escalation, conditional downstream restriction, request-bound enforcement, fail-closed on missing state, branch-local restriction) and the derivation-style authorization decision examples in Table I; the authors explicitly state that these are not measurement results.
- The authors note: the model depends on trusted delegation records and external security state inputs, and erroneous or delayed signals reduce security or availability; no empirical evaluation was conducted, and comparison with chain-aware baselines is left for future work; it does not solve intrusion detection or prompt injection itself.
Agent-ZTA is a chain-aware zero-trust authorization and containment model for multi-agent delegation, addressing runtime security state degradation caused by upstream compromise or downstream ingestion of untrusted input that cannot be detected by the static authorization of the direct caller alone. The model distinguishes path-level delegation permissions from actually exercisable permissions, supports bidirectional security state propagation, and implements branch-level containment through restricted permissions and sandbox modes. Five security properties show that the model constrains affected operations while preserving the original delegation boundaries.
Paper analysis
What problem does this paper attempt to solve?
Addresses authorization failure in multi-agent delegation chains when credentials remain valid but the security state along the chain has degraded.
Core question: in a multi-agent delegation chain, the downstream agents' credentials and delegated permissions remain valid, but the security state of some agent in the chain has already degraded at runtime, and authorization models based only on the direct caller and static authorization scope cannot perceive this runtime state change.
- Problem scenario: a user delegates a task to Agent A, A delegates to B, and B delegates to C, and C calls a protected tool. If A is compromised after delegation, B's and C's credentials remain valid; conversely, C may ingest malicious content and need to change how A and B handle the affected workflow. The authors state that this constitutes a "delegation-chain security state problem": a valid credential by itself cannot indicate whether the current operation should still be authorized.
- Shortcomings of existing methods (per the paper): identity and delegation-origin research can determine who is acting, but does not say whether downstream credentials can still be safely exercised after an upstream security event; capability attenuation and credential expiry/revocation handle only the authorization upper bound and termination, not the case where "the credential has not expired but the relevant upstream state has degraded."
- Core observation: one must distinguish the downstream agent's maximum legitimate delegation permission upper bound Di from the currently exercisable effective permission Ei(t), with the basic safety constraint Ei(t) ⊆ Di; authorization decisions should consume security-state information relevant to the request path.
- What the paper proposes: Agent-ZTA, a chain-aware zero-trust authorization and containment model, including a deterministic decision procedure, bidirectional security-state propagation, branch-level containment (restricted and jail modes), 5 security properties, and worked authorization examples.
- Threat model (Section III):
- Attacker goals and capabilities: can influence or compromise any agent at any position on the delegation path or its runtime context, e.g., by injecting malicious instructions through untrusted tool responses, or manipulating retrieval or shared context; can cause an affected agent to propose unauthorized subtasks or induce downstream agents to misuse already-granted permissions.
- Attacker knowledge: does not need to forge credentials or obtain new permissions; the failure point is that the authorization system treats the continued validity of downstream permissions as a sufficient condition.
- Victim system: autonomous multi-agent workflows, with protected operations mediated by an enforcement point; direct, unmediated tool access is outside the model's guarantees.
- Trust assumptions: identity and delegation origin are reliable, the authorization infrastructure (PDP/PEP, policy and record sources) is trusted, and security-state inputs can be supplied to the authorization system (their correctness, timeliness and completeness are assumptions, not conclusions).
What related research exists?
Related work falls into four groups: zero trust and agent identity, delegation and capability attenuation, dynamic risk-adaptive authorization, and cross-agent attacks and semantic integrity.
Zero trust, agent identity, and runtime enforcement
- NIST SP 800-207 [1]—defines zero trust as a framework that does not grant trust based on network location and explicitly evaluates access at relevant boundaries.
- ZT-MCP [7], the action-centric zero trust maturity model [8], SwarmGov-ZT [9]—respectively apply zero trust controls to tool access over MCP connections, emphasize governing tool calls rather than relying on authentication alone, and perform runtime governance in multi-agent cybersecurity scenarios.
- IWAP [24] and the AI-assisted vulnerability disclosure framework [25]—bind actions to independently verified intent, current admission state, or evidence revision, rather than treating earlier approval as permanently sufficient. The paper states that Agent-ZTA treats independent policy enforcement as an architectural foundation rather than an invention claimed by it.
Delegation chains, capability attenuation, and revocation
- South et al. [10]—discuss authenticated delegation and distinguishing the current actor from the represented principal.
- CapChain [11]—uses field-level capability tokens and verifiable provenance to constrain shared-state access among agents; the paper notes that it addresses a different access control plane.
- Bounded Agents [12] and Delegation Without Trust [13]—address delegation bounds, compositional risk, and external execution; the paper states that these works are closest to Agent-ZTA because they already address multi-hop permissions, containment, and not trusting language models to make policy decisions.
- Authorization Propagation in Multi-Agent AI Systems [14]—examines transitive delegation relationships and changes in workflow-level authorization validity; the paper states that Agent-ZTA extends the policy problem beyond credential validity.
Dynamic, risk-adaptive, and continuous authorization
- Risk-adaptive authorization by Bhushan et al. [15], SwarmGov-ZT [9], and the uncertainty-aware access control preprint [16]—incorporate context and risk indicators into authorization decisions. The paper notes that continuous or risk-aware authorization alone cannot be considered novel, and poses a contrastive challenge: a sufficiently expressive general-purpose policy engine could in principle also consume upstream chain state attributes.
Cross-agent attacks, workflow context, and semantic integrity
- AgentDojo [17]—a benchmark environment for evaluating prompt injection attacks and defenses on tool-using agents.
- Agents Under Siege [18], Conjunctive Prompt Attacks [19], and indirect prompt injection research [20]—show that adversarial influence can cross component or agent boundaries; the paper notes that these works typically study attack success rates rather than the formal state of downstream delegated permissions.
- Task Shield [22], IPIGuard [23]—defend against indirect prompt injection; the paper states that unless their policies specifically track upstream principal security state, they should not be conflated with delegated permission mechanisms.
Positioning: The authors state that Agent-ZTA combines the above foundations (identity governance, multi-hop delegation, capability attenuation, risk adaptation, independent enforcement) with "an explicit relationship between delegation path dependence and any agent's security state event," distinguishing it from purely caller-local authorization rules. The paper has no comparative baseline experiments; related work serves only for textual positioning.
How does the paper address this problem?
Uses a formal security model plus a PEP/PDP architecture: binds each request to an authenticated delegation path and performs deterministic authorization and branch containment based on chain state.
Overall approach: move authorization decisions out of the language model, and have a trusted policy decision point (PDP) make deterministic decisions based on the authenticated delegation path, relevant upstream security state, and branch containment mode, with effective permissions always a subset of the original delegation upper bound. The method is named Agent-ZTA.
Problem formalization (Section IV)
- Delegation graph: G = (V, L), where an edge (u,v) records u's delegation to v, and each edge carries an authorization scope Cu,v; a request q = (i, a, c, t, π) is bound to a specific authenticated path π, and multiple paths are not allowed to silently merge permissions.
- Two kinds of permission: the path-specific delegation upper bound Diπ is the maximum set of operations i may legitimately perform via π, constrained by the scope of each edge on the path (attenuation, child no greater than parent); the effective permission Eiπ(t,c) is the set actually exercisable at decision time.
- Core invariant: Eiπ(t,c) ⊆ Diπ, i.e., effective permission never exceeds the delegation upper bound; a valid credential establishes only the upper bound and does not guarantee that operations within the upper bound are exercisable at every moment.
- Security states: the state vocabulary is {normal, degraded, compromised, unavailable}; unavailable is assigned when records are missing, unverifiable, or outside the freshness window, and is never inferred as normal.
Bidirectional event propagation and branch containment (Section IV-D/E)
- Impact set: an event e = (v, γ, s, τ, ρ) has an impact set IP(e, π, a, c) ⊆ {v} ∪ Ancπ(v) ∪ Descπ(v) selected by trusted policy; upstream events can restrict descendants, and downstream events can "contaminate" the parent workflow context but do not mean the parent principal is compromised.
- Containment modes: the branch mode Mγ(t) ∈ {normal, restricted, jail} is derived by policy mapping from the branch record Tγ(t); jail mode's allowed set JP(γ,c) excludes sensitive operations and may be empty.
- Branch allowed set: CP(γ,c,t) takes A, the restricted allowed set QP, or JP according to the mode, then intersects with the delegation upper bound; the authors emphasize that jail is an authorization restriction, and physical isolation still requires an external sandbox.
Architecture components (Section V)
- Six responsibilities: agent workflows and protected tools, PEP (intercepts requests and executes only on P ERMIT), PDP (deterministic evaluation), delegation and origin records, chain state view (maintains Sv(t), Tγ(t) and freshness metadata), and policy store.
- Key design: the language model only proposes actions, and self-reported security state has no authority; the request path (steps 1a–6) and the state-change path (E1–E3) are separated; Figure 1 compares a baseline design that performs only identity plus static scope checks (panel a) with Agent-ZTA (panel b).
Decision procedure (Section VI-D)
- Authentication and binding: the PEP intercepts the request, and the PDP verifies the principal and path π; failure yields D ENY.
- Check delegation upper bound: if a is not in Diπ, D ENY; security-state policy is not used to expand the upper bound.
- Select relevant upstream principals: compute Rπ(i,a,c,t) per trusted policy, without using requester self-reported state.
- Read decision snapshot: obtain principal state, upstream conditions and branch records, and reject missing, stale or unverifiable required inputs.
- Apply containment and restrictions: check the branch allowed set, the local predicate BP, the own-state allowed set LP, and the HP predicate of each relevant ancestor; P ERMIT only if all are satisfied.
- Boundary enforcement: the PEP enforces only for the current request and snapshot; a prior permit is not a permanent authorization.
Handling missing state and decision criterion
- fail-closed default: when required inputs are unavailable, deny the affected operations until information is sufficient; the authors state that this is a formalized fail-closed rule, not a claim of immediate revocation or a globally synchronized store.
- Success criterion: the paper has no experimental evaluation; Section VII uses 5 properties (non-escalation, conditional downstream restriction, request-bound enforcement, conservative handling of required state, branch-local restriction) as testable invariants, and Table I gives worked decision examples.
What experiments did the paper conduct?
The paper has no experiments; its main content is an analytical argument for 5 security properties and the derivation-style authorization decision examples in Table I.
Experimental setup
- Models tested: None; the paper did not run any language model or agent system.
- Datasets/benchmarks: None.
- Baselines: No empirical baseline; Section VII-E only textually contrasts a "local authorization baseline" (which does not consume upstream state changes) with chain-aware rules in terms of different decisions under the same derivation scenario.
- Metrics and review method: None; the paper's "results" are formal properties and derivation examples.
- Sample size and number of repetitions: Not applicable.
Main results
The paper's main results are the 5 properties in Section VII and the derivation decisions in Table I. The Table I caption notes that these decisions are "derivations under the specified policy predicates (not empirical measurements)":
Situation (Table I) Relevant policy inputs Decision result All states normal (t0) Path valid; A is normal Both read and write allowed Upstream A degraded (t1) Accepted record; A related only to write read allowed; write denied Required state unavailable (t2) A record required for write is missing or expired write denied (fail-closed) Event at C (untrusted input) Accepted event; Mγ = jail write denied on branch γ; other branches unchanged Unrelated principal degraded That principal is not on the authenticated path The event brings no restriction write exceeds original scope write is not within DCπ Denied regardless of state - Authors' interpretation: The key contrast is two requests where C's identity and delegation upper bound are unchanged—the local baseline might allow both, while the chain-aware rules deny the affected write after accepting A's state record; the authors explicitly state that this comes from the specified policy inputs and does not constitute an empirical measurement of attack success.
- How the properties are argued: All 5 properties are derived from the set-intersection construction in Eq. (15)/(16); the authors note that non-escalation does not prove the authenticity of delegation records, and monotonicity holds only when the policy configuration satisfies Eq. (18).
What the formal analysis covers
- What was tested: Sections VII-A–D give the properties and arguments one by one, assuming trusted PEP/PDP, authenticated delegation provenance, a fixed policy version, and an accepted snapshot at the decision boundary.
- Results: Property 1 (non-escalation within the path) follows directly from the set intersection; Property 2 (conditional downstream restriction) holds when the ancestor is relevant and the new state excludes the operation; Property 3 (request-bound enforcement) relies on the assumption that the PEP cannot be bypassed; Property 4 (deny by default when required state is missing); Property 5 (branch-local restriction) holds when branch δ is outside the influence set, its effective permissions are unchanged.
- Authors' interpretation: Section VII-F explicitly states that these properties do not constitute proof of "being able to detect upstream compromise, prevent all malicious actions, achieve immediate global revocation, guarantee availability, or actually reduce attack success rates"; such claims require an implementation model and empirical evidence.
Other ablations and analyses
- The paper has no ablations, parameter analyses, human evaluations, or transfer experiments.
- The derivation examples in Sections IV-H and VI-G repeatedly illustrate the same set of policy situations; the authors state that these are "policy situations derived from the stated predicates, not measurement results."
What are some points that can be further explored?
The authors list dependencies such as signal quality, availability cost, and policy design, and leave empirical comparisons on a controlled multi-agent testbed to future work.
Limitations and future directions noted by the authors
- Evidence boundary (Section VIII-A): The derivation decision traces are results of predicates under selected inputs, not measurements of attack containment, latency, or sandbox isolation; whether there is an advantage over a well-configured chain-aware baseline requires direct comparison.
- Signal dependence (Section VIII-B): The mechanism depends on the correctness and provenance of delegation records, policies, state-to-principal association, and PEP/PDP enforcement; erroneous, incomplete, or delayed external signals can lead to unsafe permits or unnecessary denials.
- Availability cost (Section VIII-B): The fail-closed behavior for required state reduces availability when records are delayed or temporarily unreachable.
- Runtime boundary (Section VIII-B): Re-authorization occurs only at mediated decision points; the model does not specify immediate state propagation, cancellation of in-progress tool operations, or recovery of already-affected resources.
- Open policy design (Section VIII-B): Which ancestors are relevant to which operations, what state counts as degraded, and whether recovery restores permissions all need to be decided per scenario; the model deliberately does not specify general risk scores, anomaly detectors, credential formats, or distributed coordination protocols.
- Future evaluation (Section VIII-C): Rules can be instantiated in a controlled multi-agent testbed and compared with local/per-request authorization baselines, examining downstream restriction after upstream events, parent workflow re-evaluation after downstream events, branch isolation behavior, and authorization performance; a fair comparison should use the same delegation scope and tool operations, vary event source and timing, and record changes in authorization operations, continuity of unaffected branches, and per-request decision overhead.
Scope of experimental coverage
- The paper has no experiments of any kind: no models, benchmarks, or testbeds were run; all results are definitions, formal properties, and derivation examples from Sections IV–VII.
- The derivation examples cover only one path U→A→B→C, two operations {read, write}, and the six situations listed in Table I.
- The paper reports no implementation, latency, query overhead, or availability data; Section VII-F explicitly states that these require an explicit implementation model and empirical evidence.
- What the paper explicitly does not address (Section III-E): intrusion detection, correctness of compromise classification, repairing the reasoning of a manipulated agent, preventing every prompt injection, resources that bypass enforcement points, compromise of trusted policy infrastructure, and rollback of operations already completed before a state change.
Summarize the main content of the paper
Agent-ZTA: a zero trust authorization and containment model for multi-agent delegation chains, with formal rules and property arguments, and no empirical evaluation.
An access control model paper: addressing the authorization failure problem in multi-agent delegation chains where "credentials remain valid but the security state on the chain has deteriorated," it proposes a chain-aware zero trust model, Agent-ZTA.
- Problem: After any agent on a delegation path is compromised or ingests malicious content, downstream credentials remain valid; authorization that looks only at caller identity and static scope cannot perceive such in-flight changes (Section III).
- Method highlights: Distinguishes path-specific delegation upper bound Diπ from effective permissions Eiπ(t,c), with the invariant Eiπ(t,c) ⊆ Diπ; authorization decisions are made outside the language model by a deterministic PDP that consumes the authenticated path, relevant upstream state, and branch containment records; supports bidirectional propagation (upstream events restrict descendants, downstream events contaminate parent workflow context) and branch-level restricted/jail containment; fails closed when required state is missing.
- Main results: 5 security properties (non-escalation, conditional downstream restriction, request-bound enforcement, conservative handling of required state, branch-local restriction) are derived from the set-intersection construction; Table I gives derivation decisions for six situations, e.g., when A is degraded and related only to write, read is allowed and write denied; when a required record is missing, write is denied.
- Strength of evidence: The authors explicitly state that Table I and the examples are derivations of policy predicates rather than measurements, and that the properties do not constitute proof of detecting compromise or reducing attack success rates.
- Authors' conclusion: The model provides a testable specification for bidirectional chain-state authorization; actual containment also depends on correct event inputs, non-bypassable enforcement points, and isolated environments when physical sandboxing is required, with empirical comparison left for future work.