Skip to content
TechnicalNovember 20, 202611 min read

Multi-agent delegation: where authority leaks at handoffs

Tool chains and a swapped symlink leaked files in LangChain, LangGraph, AutoGen and OpenClaw setups. Our re-check by path still leaked. With a handoff record.

Antonella Serine

Antonella Serine

Founder, KLA

Founder of KLA, building the independent runtime governance control plane for regulated AI agents under the EU AI Act.

The question

When one agent passes work to another, whose permission does the receiving agent use when it touches a resource?

The research

Lazer, Aryal, Gupta and Bertino ran 12 experiments on configured LangChain, LangGraph, AutoGen and OpenClaw systems. A chain of permitted tools and a swapped symbolic link each reached a protected file in all four.

What we ran

A local reproduction of the swapped link with four reader strategies. Re-checking the path before reading still leaked; checking the file that was actually opened refused the swap.

The resource

A handoff authority record and test plan: originator, delegated scope, expiry, the check at the resource and the evidence for each handoff.

A planning agent reads a project summary and hands a task to a file-reading agent. The summary contains a line, written by an outsider, asking for a credentials file “for the audit”. The planner has no file access. The reader has file access and no reason to doubt the planner. The credentials appear in the final report. Each agent stayed inside its own permissions; the request crossed from one to the other without the authority of anyone allowed to make it.

This post summarises a 16 November 2026 study of authorisation across four orchestration frameworks, reports a local reproduction of its symbolic-link case in which the paper’s recommended path re-check still leaked, and gives a record for checking authority at each handoff. This post belongs to our research notes on agent execution: each one reads a recent source closely, reports what we checked ourselves, and ends with a resource you can use on your own system.

What the 16 November study tested

Evaluating Authorization and Trust Boundaries in Agentic Orchestration Frameworks, by Sahaya Jestus Lazer, Kshitiz Aryal, Maanak Gupta and Elisa Bertino, was submitted to arXiv on 16 November 2026. It is a preprint; the ACM fields in the PDF are unfilled template placeholders. Read the paper.

The authors built equivalent multi-agent setups in LangChain 1.2.17, LangGraph 1.1.10, AutoGen 0.7.5 and OpenClaw 2026.6.11, all calling gpt-4o-mini. The attacker can supply instructions, retrieved content, files, memory entries or messages from an untrusted agent, and has no host access or stolen credentials. An experiment counts as a success only when the unauthorised effect happens: a tool invocation, a file read or written, a state change.

Permitted tools, forbidden result

Several experiments show authority leaking through combinations of steps that are each allowed.

  • Tool composition (E3). A request to summarise a deployment report was redirected into read secret, encode, write report. All four configurations accessed the sensitive file. Whether the later encoding and writing completed varied, and the paper does not break it down per framework.
  • Decoder to executor (E5). A restricted Base64 decoder passed decoded text to a privileged file-creation agent, which treated the upstream agent’s output as an instruction. LangGraph, AutoGen and OpenClaw created the expected marker file; LangChain invoked the tool with a wrong filename after a decoding error.
  • Authority framing (E1, E2). Instructions framed as delegation or audit made three frameworks invoke read_secret_file. None of them put the secret in the final answer. A filter on the final text saw a clean response after the unauthorised read had happened; controls and logs have to cover the tool invocation itself.
  • Planner to privileged executor (E8). An unprivileged planner’s free-form command reached a privileged executor unvalidated in all four. A detector at the execution interface blocked the reverse-shell variant in all four, on a simulated shell.

Checking the originator, and refusing forged approvals

Two experiments test a protection against a baseline, and both protections worked in all four configurations.

In E11, the attacker’s delegation request was embedded in a legitimate project summary and forwarded to an agent with file-read privilege. Without protection, all four read and disclosed the secret. With an authorisation stage that checked whether the originating agent was allowed to delegate that action before the handoff was built, the unauthorised action was removed and the downstream agent received no privileged tool: no read, no disclosure.

In E12, an untrusted message carried a fabricated reviewer approval, a request ID and an authorisation level. Executors that accepted the textual claim created an unauthorised marker file in all four. With a dedicated reviewer issuing a structured authorisation record, and a coordinator validating its fields before granting execution, the forged requests were rejected and legitimate reviewer requests still ran.

These are application-written controls. The paper does not describe their code or record schema, and it does not say how the reviewer record is authenticated. What made E11’s check work is where it sat: it evaluated the originator’s authority before capabilities were assigned, and the downstream agent never received the privileged tool. In E5 and E8 the downstream agent held standing privileges and no originator check was tested. A practical rule follows, and it is our inference: a receiving agent’s effective capability for a task is the intersection of its own permissions and the originating principal’s scope, fixed before the task runs.

In E6, a validator approved a symbolic link that pointed inside the permitted directory. Before the reader opened it, the link was redirected to a private file outside. All four configurations read the private file, because the reader relied on the earlier validation. The paper recommends re-validating at the point of access and does not test it, so we did.

Our script creates a workspace, a private directory and a link, validates the link, injects the swap at a fixed step and runs four reader strategies. It ran on Node 20.20.2 under Linux on 20 November 2026. The script and its output are in an appendix to the handoff authority record.

Local reproduction of the E6 swap, 20 November 2026 (10 deterministic cases)
Reader strategySwap injectedOutcome
A. Trust the validation record, read by pathAfter validationPrivate file read
B. Re-check the path at use, then read by pathAfter validationRefused
B. Re-check the path at use, then read by pathAfter the re-check, before openPrivate file read
C. Open, check what the descriptor refers to, read from itAfter validationRefused
C. Open, check what the descriptor refers to, read from itAfter openPermitted file read
D. Open with O_NOFOLLOWAny, or noneRefused, including the legitimate link

What the reproduction shows

Strategy C: bind the check to the opened file (Node.js, Linux)
const fd = fs.openSync(requestedPath, fs.constants.O_RDONLY);
try {
  const real = fs.readlinkSync(`/proc/self/fd/${fd}`);
  if (!isInside(real, allowedRoot)) throw new Error(`denied at use: ${real}`);
  return fs.readFileSync(fd, 'utf8');
} finally {
  fs.closeSync(fd);
}
  • Re-checking by path repeats the race. Strategy B refused a swap that landed before the re-check and leaked when the swap landed between the re-check and the open. The window is smaller and still there.
  • Checking the opened object closes it. Strategy C opens first and checks the file the descriptor actually refers to, then reads from that descriptor. A swap after the open cannot change which file is read. On Linux, openat2 with RESOLVE_BENEATH gives the same property in one call; Node 20 does not expose it.
  • Refusing links has a cost. Strategy D refused every link, legitimate ones included, and O_NOFOLLOW applies only to the last path component. A link in a parent directory is still followed.
  • Scope. This is a single-process simulation with an injected swap. It shows the ordering problem and the fix. It does not measure a real attacker’s timing or test any framework’s file tool.

Where the study stops

  • Configured systems only. The outcomes describe the configured systems. The paper ranks no framework as more secure.
  • One model, twelve experiments. All runs used gpt-4o-mini. The authors write that “Twelve experiments across four frameworks cannot represent all attack scenarios.”
  • One tested delegation control. The originator check is tested in E11 only. E5 and E8 are also handoffs and had no matched protected arm.
  • Not covered. Credential-based authentication, enterprise identity systems and external policy engines were not comprehensively evaluated.
  • No released code. We found no repository with the prompts, traces or per-trial counts, so the categorical results cannot be recomputed.

A record for each handoff

The common thread in E3, E5, E8, E11 and E12 is a request whose authority was lost or invented at a boundary. A handoff record makes that authority explicit and gives the receiving side something to check. The handoff authority record has these fields and a test plan built from the study’s scenarios:

  • Originating principal: the person, service or institution whose authority the work runs under, carried unchanged through every hop.
  • Delegating agent and receiving agent, with each agent’s permissions.
  • Delegated scope and expiry: the actions, resources and limits passed on, bounded by the originator’s own authority, with an end time.
  • Origin of the request text: user instruction, retrieved document, tool output or another agent, so content cannot pose as instruction.
  • Originator check: whether the originating principal may delegate the action, evaluated before capabilities are assigned.
  • Approval reference: a structured record from the approval system, validated field by field.
  • Check at the resource: what was verified when the resource was actually touched, and against which object.
  • Evidence: the tool invocation, the resource identifier and the outcome.

How KLA checks authority at the action

Agents that act through KLA agent action ingress work under an agent mandate: a versioned record naming an accountable owner, an institutional principal, and the tools, operations, destinations and purposes allowed. Each proposal is bound to one mandate revision. KLA checks the mandate when the proposal is evaluated and again at the execution boundary, immediately before the destination is invoked; a revoked mandate or a changed revision at that point blocks the action with nothing executed. When a call reaches KLA through its MCP gateway, the gateway’s delegation handle is single-use and bound to the caller, the caller’s roles, the request path and a SHA-256 digest of the request body, so a handle cannot carry a different request. Human approval arrives as a Decision Request decided in KLA, and KLA refuses a decision from the user who requested the action.

These checks cover actions that pass through KLA. A file read inside an agent’s own sandbox, like the E6 case, is outside them and needs a check of the kind shown above. The research in this post did not test KLA.

Frequently Asked Questions

Is a tool allowlist enough to control what an AI agent can do?

No. In the 16 November 2026 study, a sequence of individually permitted tools reached a protected file in all four configured frameworks. An allowlist limits which tools an agent may call. It does not limit what a chain of calls, or a request passed from another agent, can achieve. Check the originator’s authority and the actual resource operation as well.

How do you stop authority escalation when one AI agent delegates to another?

Check whether the originating agent may delegate the action before building the handoff, and give the receiving agent only the capabilities that check allows. In the study’s E11 experiment, that check prevented the unauthorised read and disclosure in all four configurations; without it, all four disclosed the secret.

How do you prevent symbolic-link time-of-check to time-of-use attacks in agent file tools?

Bind the check to the file that is actually opened. In our reproduction, re-checking the path before reading still leaked when the link changed between the check and the open. Opening the file, checking what the descriptor refers to and reading from that descriptor refused the swap. On Linux, openat2 with RESOLVE_BENEATH does this in one call.

Can an AI agent accept an approval written in a message?

It should not. In the study’s E12 experiment, executors that accepted a reviewer approval written in an untrusted message created an unauthorised file in all four frameworks. A structured approval record from a dedicated reviewer, validated before execution, rejected the forgery and still allowed legitimate requests.

Key Takeaways

Authority has to travel with the work and be checked where the work touches a resource. Carry the originating principal through every handoff, never let a message stand in for an approval, and bind file checks to the object actually opened. Start with the handoff authority record.

Sources were checked on 20 November 2026. All paper results are the authors’ own; no code was released, and we reproduced only the symbolic-link case, in a local simulation. This post contains no KLA production result.

See It In Action

Ready to automate your compliance evidence?

Book a 20-minute demo to see how KLA helps you prove human oversight and export audit-ready Annex IV documentation.

Multi-agent delegation: where authority leaks at handoffs | KLA Blog