Evaluating Authorization and Trust Boundaries in Agentic Orchestration Frameworks

Sahaya Jestus Lazer, Kshitiz Aryal, Maanak Gupta, Elisa BertinoarXiv 2026 · arXiv

TL;DR

Security in agentic AI is only as strong as its orchestration. This paper evaluates four popular frameworks—LangChain, LangGraph, AutoGen, and OpenClaw—revealing that vulnerabilities often lie at the "trust boundaries" where agents, tools, and memory interact. The authors demonstrate that without explicit, multi-layered authorization, agents can be manipulated into unauthorized tool chaining, filesystem escapes, and persistent memory poisoning.

What Problem Does This Paper Address?

As Large Language Models (LLMs) evolve from simple chatbots into "agents" capable of using tools, accessing filesystems, and collaborating with other agents, the attack surface expands significantly. Traditional security focuses on the model itself (e.g., preventing toxic output), but agentic systems introduce orchestration boundaries—points where data and instructions pass between components with different privileges.

The core challenge is that framework-level capabilities (like having access to a "read file" tool) are often mistaken for authorization. If an agent is told to summarize a report but is also given a "delete file" tool, what stops a malicious prompt from triggering the latter? The authors investigate how these frameworks represent identity, enforce authorization, and propagate trust across complex workflows.

Methods

The researchers conducted a controlled comparative study of four major frameworks: LangChain, LangGraph, AutoGen, and OpenClaw. To ensure the results reflected framework architecture rather than model variability, they used a common LLM (gpt-4o-mini) across all tests.

They designed twelve experiments (E1–E12) mapped to the OWASP Top 10 for Agentic Applications. These experiments were grouped into five categories:

  1. Prompt Injection: Direct and indirect attempts to override instructions.
  2. Unauthorized Resource Access: Exploiting tool composition and filesystem vulnerabilities.
  3. Unauthorized Command Execution: Injected shell commands and unvalidated delegation.
  4. Memory Poisoning: Introducing false information into active or persistent memory.
  5. Inter-Agent Trust & Identity: Spoofing identities or injecting malicious tasks into multi-agent communications.

Datasets

Rather than a single static dataset, the study utilized a suite of experimental scenarios:

  • Benign Tasks: Standard operations like document summarization (T6) or command-related workflows (T11) to establish a baseline.
  • Memory Poisoning Data: A set of 84 clean and 72 poisoned memory records across 12 operational domains, evaluated using a FAISS retrieval index.
  • Attack Payloads: Custom-crafted malicious instructions, including Base64-encoded payloads and symbolic link (symlink) redirects.

Key Insights and Ideas

  • The "Tool Chaining" Trap: Even if individual tools are "safe," their composition can be dangerous. An agent authorized only to summarize might be tricked into reading a secret file, encoding it, and writing it to a public directory by chaining legitimate tools in an unauthorized sequence.
  • Stale Authorization (TOCTOU): The researchers found that frameworks are vulnerable to "Time-of-Check to Time-of-Use" attacks. An agent might validate a file path, but an attacker can swap that file for a symbolic link to a sensitive system file before the agent actually reads it.
Figure 2: Experimental design for unauthorized resource access.
  • Memory as an Attack Vector: Memory poisoning is distinct from access control. It doesn't necessarily break a rule; it corrupts the agent's "worldview." Once poisoned, an agent may provide false information or make biased decisions across multiple turns, even if the original malicious input is gone.
  • Natural Language Identity is Fragile: Relying on an agent's name or a text-based "I am the admin" claim is insufficient. The study shows that identity must be verified through structured, out-of-band authorization records rather than natural language instructions.

Key Results

The results highlight a clear distinction between "vulnerable" (default) and "protected" configurations:

  • Prompt Injection: Most frameworks resisted basic overrides, but "Variant D" (framing a secret access as necessary for a benign task) induced unauthorized tool invocation in LangChain, LangGraph, and OpenClaw.
  • Resource Access: All frameworks were initially vulnerable to tool chaining (E3) and symlink escapes (E6). However, explicit path validation and runtime sandboxing in "protected" modes successfully blocked directory traversal (E7).
  • Command Execution: While frameworks often adopted malicious shell instructions, configured approval mechanisms (like LangChain's human-in-the-loop) successfully interrupted the execution before the host was modified.
Figure 3: Experimental design for unauthorized command execution attacks.
  • Memory Poisoning: This was highly effective. In session-based memory (E9), the Attack Success Rate (ASR) reached as high as 92.8% for AutoGen. Even in persistent memory (E10), poisoned records were retrieved and accepted roughly 45-49% of the time across frameworks.

Limitations and Future Work

  • Scope: The study focused on twelve specific scenarios. While mapped to OWASP, they don't cover every possible edge case in agentic security.
  • Model Dependency: While using a single LLM (gpt-4o-mini) provided a control, different models might exhibit different levels of "gullibility" to prompt injection or memory poisoning.
  • Enterprise Integration: The evaluation did not deeply explore integration with enterprise-grade Identity and Access Management (IAM) or external policy engines (like OPA), which are common in production environments.

Future research could look into automated red-teaming for orchestration boundaries and developing provenance-aware memory systems that can distinguish between "trusted" facts and "untrusted" conversational history.

Summary updated

Abstract

Agentic AI systems extend large language models with tools, memory, and multi-agent collaboration, introducing security risks at orchestration boundaries. These risks depend on how identities are represented, operations are authorized, and instructions or information propagate between components. We evaluate LangChain, LangGraph, AutoGen, and OpenClaw through twelve experiments mapped to the OWASP Top 10 for Agentic Applications using a common LLM (gpt-4o-mini). The experiments cover prompt injection, unauthorized resource access and command execution, memory poisoning, and inter-agent trust and identity attacks. Adversarial inputs induced unauthorized tool invocation, while tool chaining, stale filesystem validation, encoded instructions, and inter-agent delegation exposed weaknesses in authorization across component boundaries. Memory poisoning showed that untrusted state can influence responses, a risk distinct from conventional access-control violations. In the evaluated protected configurations, explicit authorization, controlled capability assignment, filesystem containment, and execution safeguards prevented specific unauthorized operations. The findings emphasize preserving authorization and information-trust boundaries throughout agentic workflows rather than treating framework capabilities or model-level instructions as sufficient security guarantees.
BibTeX
@misc{lazer2026evaluating,
  author = {Sahaya Jestus Lazer and Kshitiz Aryal and Maanak Gupta and Elisa Bertino},
  title = {{Evaluating Authorization and Trust Boundaries in Agentic Orchestration Frameworks}},
  year = {2026},
  eprint = {2611.21259},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.21259},
}
Figure