ARCANADA
All Posts
Blog November 20, 2026

Having a tool is not permission to use it: authorization at agent trust boundaries

In twelve attack experiments on four agent orchestration frameworks, the authors of a new paper found a recurring pattern: when a request crossed from one component to another without an independent authorization check, unauthorized requests could get through, and in several experiments the unauthorized action was carried out. Where configurations included explicit checks, the specific attacks tested were stopped; a vulnerable and a protected version of the same workflow exist only for the two inter-agent experiments. The paper, posted to arXiv on 16 November 2026, does not rank the frameworks. Its claim concerns where authorization has to be enforced, and it describes the configurations the authors built, not guarantees of the frameworks themselves.

What was tested

Sahaya Jestus Lazer, Kshitiz Aryal, Maanak Gupta and Elisa Bertino evaluated LangChain, LangGraph, AutoGen and OpenClaw. All four used one model, gpt-4o-mini, to reduce variation from model choice. The twelve experiments (E1 to E12) are mapped to the OWASP Top 10 for Agentic Applications and cover five categories: prompt injection, unauthorized resource access, unauthorized command execution, memory poisoning, and inter-agent trust and identity attacks.

The threat model covers seven trust boundaries, from user-to-model to agent-to-agent communication. The attacker can send instructions, plant content, craft files or manifests, and impersonate agents, but has no prior host access or stolen credentials. The authors judged each outcome from observable effects (tool invocations, execution traces, file changes). An attack counted as successful only when its specific unauthorized effect occurred (for shell commands, proposing one did not count).

Source: Sahaya Jestus Lazer, Kshitiz Aryal, Maanak Gupta, Elisa Bertino, "Evaluating Authorization and Trust Boundaries in Agentic Orchestration Frameworks", arXiv:2611.21259v1, Abstract, sections 1, 2.1, 2.2, 2.3, Table 2, arxiv.org/abs/2611.21259v1.

Where the checks were missing

The results in this section are one outcome per framework per experiment (per variant in E1 and E2), as reported in the paper's tables. No trial counts or rates are given for them.

In the prompt injection tests, all four frameworks resisted three of the four attack variants. The fourth variant framed reading a secret file as part of an audit needed for a complete summary. LangChain, LangGraph and OpenClaw then called the privileged tool, although none of them put the protected canary in the final answer. AutoGen did neither.

Tool chaining (E3) worked against all four: agents combined available tools to read a secret during a task that authorized only summarization. A symbolic link swapped between validation and reading (E6, a time-of-check-to-time-of-use attack) also worked against all four, because the earlier path check was not repeated at access time.

In E5, a decoder with no file or execution rights passed Base64-decoded text to a privileged executor. LangGraph, AutoGen and OpenClaw created the attacker's marker file. LangChain invoked the tool too, but a decoding error changed the filename, which the authors record as partial success. Limiting the first component's rights did not help once its output reached a privileged one unchecked.

Source: the same work, sections 3.1, 3.2, 3.3, Tables 3, 4, 5, arxiv.org/abs/2611.21259v1.

Where the checks held

Canonical path validation in LangChain, LangGraph and AutoGen, and sandbox isolation in OpenClaw, blocked the manifest path traversal attack (E7) in all four frameworks; the paper reports no unprotected E7 run. In the shell test (E4), LangChain adopted the malicious commands, but its configured approval step interrupted them before they reached the host; the other three resisted the instruction.

In E8, a planner without privileges forwarded a reverse shell command to an executor with no validation in between. The authors report that a reverse shell detector at the execution interface of a simulated shell tool blocked it. The authors note that splitting planner and executor alone did not stop the request from crossing.

For inter-agent attacks, the authors built a vulnerable and a protected variant. In the vulnerable variants, a forged delegation (E11) led a downstream agent to read and disclose a protected file, and a fabricated reviewer approval (E12) led to an unauthorized marker file, in all four frameworks. In the protected variants, an authorization stage or a structured authorization record checked by a coordinator rejected these requests before privileged execution. These protections combined framework mechanisms with application-defined checks.

Source: the same work, sections 2.3.5, 3.2, 3.3, 3.5, 4, Tables 4, 5, 7, arxiv.org/abs/2611.21259v1.

Memory poisoning is a separate problem

E9 and E10 test whether false information placed in memory shows up in later answers. Here the authors report percentages. Attack Success Rate is the share of responses that reproduce the injected false claim. It was measured by semantic similarity with a fixed threshold (0.62 in E9, 0.70 in E10), and values are means over three seeds.

In session memory (E9, 12 operational domains; the paper does not give the number of responses), ASR ranged from 66.9% for OpenClaw to 92.8% for AutoGen, with LangGraph at 92.6% and LangChain at 78.0%. No framework reproduced the false claim in the no-injection control.

In persistent memory (E10: 84 clean and 72 poisoned records, 228 queries per framework per seed; the paper does not say whether ASR counts all queries or only poisoned ones), all frameworks shared one retrieval index, and all four had the same Poison Retrieval Rate, 82.3% (the paper does not define its denominator). ASR was lower, from 45.1% for OpenClaw to 49.3% for LangGraph. Retrieval did not mean acceptance. OpenClaw also had the lowest mean clean accuracy, 24.1% (others 28.7% to 33.3%), so its lower ASR comes with weaker answers on legitimate queries.

Source: the same work, sections 2.3.4, 3.4, Table 6, arxiv.org/abs/2611.21259v1.

Limits the authors state

Twelve experiments cannot represent all attacks. Identity verification is examined mainly through E12. Different runtimes required framework-specific implementations, and protected configurations included application-defined checks. One model was used, and other models or versions may behave differently; for prompt injection the authors do not separate model effects from framework effects. Credential-based authentication, enterprise identity management and external policy engines were not comprehensively evaluated.

Source: the same work, sections 3.1, 5, arxiv.org/abs/2611.21259v1.

What we did with it

On 19 November 2026 our research desk read the paper and proposed a bounded trial: adding trust-boundary authorization checks (role and tool authorization) to an existing internal test lab. The same day the owner of that lab recorded a design-only decision: the trial may be designed, while any run on our real systems stays on hold until the task, permissions, responsible engineer, environment and resources are confirmed. We have not run, reproduced or measured anything from this paper. Every number above is the authors'.

The paper discussed here: arxiv.org/abs/2611.21259v1.