Agent-ZTA: A chain-Aware Zero Trust Model for Bidirectional Security-State Propagation and Runtime Containment in Multi-Agent Delegation

Asadullah Abdullah Khan, Toqeer Ali SyedarXiv 2026 · arXiv

TL;DR

Agent-ZTA introduces a "chain-aware" Zero Trust model for multi-agent AI systems, ensuring that security compromises propagate through delegation paths in real-time. Unlike traditional models that only check the immediate caller’s credentials, Agent-ZTA dynamically restricts an agent's permissions if any ancestor in its delegation chain becomes compromised or if a downstream agent ingests malicious content.

What Problem Does This Paper Address?

In multi-agent systems (MAS), tasks are often delegated across a chain (e.g., User → Agent A → Agent B → Agent C). Current security models typically validate an agent's identity and its static delegated scope at the start. However, they fail to account for mid-execution state changes.

If Agent A is compromised after it has already delegated a subtask to Agent B, Agent B (and its descendants) might continue to operate with valid credentials despite the upstream security failure. Conversely, if Agent C ingests a malicious prompt injection, the upstream agents (A and B) need to be alerted to re-evaluate their workflow. The authors tackle this "delegation-chain security-state problem," where valid credentials no longer guarantee that an operation is safe to execute.

Methods

The authors propose a formal authorization and containment model called Agent-ZTA. Key components include:

  • Separation of Authority: The model distinguishes between $D_i$ (the maximum authority an agent was originally granted) and $E_i(t)$ (the effective authority it can currently exercise based on the system's security state).
  • Bidirectional Propagation: Security events move both ways. Upstream events restrict what descendants can do, while downstream events "taint" the parent workflow context, triggering a reassessment of the delegator's plan.
  • Branch-Scoped Containment: Instead of a global "kill switch," restrictions are applied only to the affected delegation branch. Unrelated branches continue to operate normally.
  • Containment Modes: The model defines three states for a workflow branch: normal, restricted (limited permissions), and jail (a sandbox mode for suspicious but not yet revoked operations).
  • Deterministic Decision Procedure: A six-step process enforced at a Policy Enforcement Point (PEP). It verifies the authenticated delegation path, checks original bounds, selects relevant ancestors, reads the current security snapshot, and applies policy-defined restrictions—all outside the influence of the agent's LLM "brain."

Datasets

As a theoretical and formal model paper, Agent-ZTA does not use a traditional training dataset. Instead, the authors evaluate the model using:

  • Formal Security Properties: Mathematical proofs of five core properties (e.g., non-escalation and branch-local restriction).
  • Worked Authorization Traces: Logical scenarios (detailed in Table I) that simulate specific attacks—such as upstream compromise or untrusted downstream input—to demonstrate how the model's predicates result in correct "Permit" or "Deny" decisions.

Key Insights and Ideas

  • Identity $\neq$ Trustworthiness: A valid cryptographic credential does not mean the agent is currently operating in a trusted state. Trust must be continuously re-evaluated based on the entire chain's health.
  • The "Fail-Closed" Default: If security state information is missing, stale, or unverifiable, the system defaults to "Deny." This prevents "silent optimistic assumptions" that could lead to breaches.
  • Contextual Taint: A downstream agent ingesting malicious data doesn't necessarily mean the agent itself is "compromised" in the traditional sense, but it "taints" the specific workflow branch, forcing the orchestrator to stop and re-plan.
  • LLM Independence: A critical design choice is that the security logic resides in a dedicated Policy Decision Point (PDP), ensuring that a manipulated or "hallucinating" LLM cannot bypass security rules by simply generating persuasive text.

Key Results

The paper establishes the mathematical soundness of the Agent-ZTA model through five proven properties:

  1. Non-escalation: An agent can never gain more power than its original delegation, regardless of security state changes.
  2. Conditional Downstream Restriction: If a relevant ancestor is compromised, the descendant's effective authority is automatically reduced or revoked.
  3. Request-Bound Enforcement: Every tool call requires a fresh check; a prior "Permit" does not grant a permanent license to act.
  4. Conservative Handling: The system successfully fails-closed when state data is unavailable.
  5. Branch-Local Restriction: Security failures are contained within the specific delegation path, preventing a single compromised sub-task from paralyzing the entire multi-agent ecosystem.

Limitations and Future Work

  • Detection Dependency: Agent-ZTA is an authorization model, not a detection system. It relies on external monitors to provide accurate and timely security signals. If a compromise isn't detected, Agent-ZTA cannot mitigate it.
  • Performance Overhead: Checking the entire delegation chain and fetching state snapshots for every tool call introduces latency, which may be significant in complex, high-frequency MAS.
  • Sandbox Requirements: The "jail" mode requires an underlying execution environment (like a container or sandbox) that can actually enforce isolation; the model provides the logic, but the infrastructure must provide the walls.
  • Future Work: The authors suggest empirical evaluation in a controlled multi-agent testbed to measure the real-world impact on attack success rates and system performance.

Summary updated

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.
BibTeX
@misc{khan2026agent,
  author = {Asadullah Abdullah Khan and Toqeer Ali Syed},
  title = {{Agent-ZTA: A chain-Aware Zero Trust Model for Bidirectional Security-State Propagation and Runtime Containment in Multi-Agent Delegation}},
  year = {2026},
  eprint = {2611.18999},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.18999},
}
Figure