Related terms
Related terms
Borrowed authority is about whose permissions an action runs on. Borrowed Clearance is about whose check an action trusts. The two are complementary. An agent can hold full authority and still act on borrowed clearance.
Rule
Signed, payload-bound clearance is never inherited.
Two published uses of "borrowed authority" already exist, and they point in different directions. Neither one describes Borrowed Clearance. Separating them is this reference's reading; the sources cited below do not make that comparison themselves.
Borrowed authority as permissions passed down from a principal
NHI Mgmt Group's glossary entry on borrowed authority (published 2 September 2026) uses the phrase for an agent that operates with permissions which began with a person, a service account, or a connected app (paraphrased). The agent is spending rights that were first granted to some other identity, and it can call tools, read data, or start workflows inside that original scope without holding an identity of its own.
The entry gives two reasons the condition matters. First, it is what turns prompt injection into real damage: an attacker needs no fresh credentials when the agent can already use valid ones for them. Second, the usual mistake is to treat the arrangement as harmless proxy access and let an agent inherit a user's broad rights with no task scoping or revocation discipline. Its remedy is to bound the borrowed rights by task, time, and resource, with clear revocation paths and detailed logging, and it points to the access-enforcement and account-management families of NIST SP 800-53 Rev. 5 as the nearest formal framing (all paraphrased).
One of the entry's own examples sits close to this site's subject: a procurement agent that approves routine requests through a business user's session becomes risky when the downstream system does not enforce the approval threshold. That is where the two ideas meet, and where they part, as set out below.
Borrowed authority as a confused deputy
Watchlight AI (18 October 2026) applies the phrase the other way round. Its example: a sales agent asks a finance agent to issue a $40,000 refund to a customer. The finance agent has refund rights, so the refund is processed, even though the salesperson who started the request has no power to approve refunds. In Watchlight's words, the request "comes out looking legitimate" because it rides on the authority of the agent relaying it.
Watchlight links that pattern to the confused deputy, citing Norm Hardy's 1988 account of a program with authority being manipulated into exercising it for someone without that authority (paraphrased). The original paper is summarised in the next section.
The OWASP Top 10 for Agentic Applications 2026 files a confused-deputy example under ASI03, Identity and Privilege Abuse, titled "Cross-Agent Trust Exploitation (Confused Deputy)". OWASP notes that agents in multi-agent systems tend to accept requests from inside the system by default, so a less privileged agent can hand plausible instructions to a more privileged one, which acts without rechecking what the original user intended (OWASP Top 10 for Agentic Applications 2026, paraphrased). That describes a failure of authority and inter-agent trust. On its own it is not what Borrowed Clearance names.
The original confused deputy (Hardy, 1988)
The term comes from Norm Hardy's short paper "The Confused Deputy (or why capabilities might have been invented)", published in ACM SIGOPS Operating Systems Review, volume 22, issue 4, October 1988, pages 36 to 38 (DOI 10.1145/54289.871709; archived copy of the text from Hardy's site). Hardy, then at Key Logic, tells what he calls a nearly true story from Tymshare, a commercial timesharing company. A compiler had been given a licence to write files in its own home directory so that it could record usage statistics. A user who knew the name of the billing file kept in that same directory gave it to the compiler as the place to write debugging output. The operating system saw the licence and allowed the write, and the billing records were lost (summarised).
Hardy's diagnosis is that the compiler ran on authority from two sources, the user who invoked it and its own licence, and had no way to say which of the two it meant to use for a given write. In his words, the compiler "serves two masters". His remedy was capabilities: one reference that both names a file and permits writing to it, so the compiler would send debugging output only through a capability its invoker handed over (summarised).
The parallel with Borrowed Clearance is partial, and drawing it is this reference's reading, not Hardy's. His deputy misuses authority it really holds; an agent acting on borrowed clearance relies on a check it never ran. What carries over is the shape of the fix. Hardy joined the designation of a target and the permission to act on it into a single object, and the controls join an approval to the single payload it covers.
Intermediaries that drop the initiator (CWE-441)
MITRE's Common Weakness Enumeration catalogues the confused deputy as a class-level weakness, CWE-441, Unintended Proxy or Intermediary (CWE 5.0; page last updated 28 October 2026). Until 28 October 2026 the entry's name carried "('Confused Deputy')" in brackets; that phrase is now listed as an alternate term. The entry describes a product that takes a request, message or directive from an upstream component and forwards it to an external actor outside its control sphere without adequately preserving where the request came from. Because the forwarded request appears to come from the intermediary, an attacker who cannot reach a target directly can get past access controls or hide the real source (summarised).
MITRE treats forwarding as normal and says it becomes a weakness only when three things hold together: the intermediary has different privileges or access from the upstream component, the attacker cannot make the request to the target directly, and the attacker can craft a request the intermediary never meant to pass on, such as one aimed at an unexpected service or carrying disallowed commands. Server-side request forgery (CWE-918) is listed as one of its children. The mitigations are strong mutual authentication between the two parties and a rule that a proxy must not drop the initiator's identity, which should stay unchanged all the way to the target (summarised).
Applying the entry to agents is this reference's reading, not MITRE's. A coordinator that relays "this was checked" to an executing agent is an intermediary of this kind, and what gets lost is not only who asked but which check ran and on what. Keeping the initiator attached is the identity half. The delegation trail and a signed clearance carry the other half to the service that acts.
Token passthrough in the Model Context Protocol
The Model Context Protocol (MCP), an open-source standard for connecting AI applications to tools and data, names a closely related failure in its own security guidance. The project's Security Best Practices page calls "token passthrough" an anti-pattern: an MCP server takes a token from a client without confirming that the token was issued to that server, and forwards it unchanged to a downstream API. The page describes two failures. The server may accept a token meant for some other service because it never checks the audience claim. When it then forwards that token, the downstream API may treat it as though it came from the MCP server, or may assume the upstream side already validated it (summarised). The page files this under the confused deputy problem and points to the audit cost: downstream logs can show requests under an identity other than the server that actually forwarded them.
The protocol's authorization specification (revision 2026-07-28) makes the rule normative. A server must check that an access token was issued specifically for it as the intended audience, following RFC 8707 on resource indicators, must accept only tokens valid for its own resources, and "MUST NOT accept or transit any other tokens."
Treating this as an instance of Borrowed Clearance is this reference's reading, not the MCP project's. The second failure has the same shape as the term: a downstream service acting on validation it assumes happened upstream, with nothing in hand that proves it. The MCP remedy also lines up with the controls. The check runs at the service that receives the request, against a credential bound to that one recipient, instead of being inherited from whoever passed the request along.
Implicit trust in zero trust architecture
Zero trust thinking reaches the same problem from the network side. NIST Special Publication 800-207, Zero Trust Architecture (Rose, Borchert, Mitchell and Connelly, August 2020) sets out seven basic tenets, presented as an ideal goal rather than a checklist every deployment meets in full. Three of them bear on this term.
The second tenet says a request is not trusted because of where it comes from: one sent from inside the enterprise network has to meet the same security requirements as one from outside it, and "Network location alone does not imply trust." The third grants access to each resource on a per-session basis, evaluates trust in the requester before access is given, and keeps privileges to what the task needs. It adds that "authentication and authorization to one resource will not automatically grant access to a different resource." The sixth makes authentication and authorisation dynamic and strictly enforced before access, with reauthentication and reauthorisation during a transaction when policy calls for it, for example after a set time, a request for a new resource, or anomalous activity (summarised).
Reading these tenets against Borrowed Clearance is this reference's interpretation, not NIST's. The publication is about subjects reaching resources, not about one agent accepting another component's verdict. The structure still carries over. A forwarded "approved" works like a trusted network location: it says the request came from somewhere that should have checked, not that a check covered this transfer. The per-resource tenet matches the rule that a sign-off covers one payload and does not move to the next, and the reevaluation tenet sits beside withdrawing clearance when conditions change.
Indirect prompt injection
The content-as-authority pattern has a research name on the attack side. In Not What You've Signed Up For: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection, Greshake, Abdelnabi, Mishra, Endres, Holz and Fritz describe how an attacker with no direct access to a model can still steer it, by planting instructions in data the application is likely to retrieve, such as a web page or a document. The paper appeared in the Proceedings of the 16th ACM Workshop on Artificial Intelligence and Security (AISec 2023, pages 79 to 90). Its central claim is that applications built around language models "blur the line between data and instructions." The authors set out a taxonomy of impacts, including data theft and contamination of the information a system relies on, and report working attacks against real systems, among them Bing's GPT-4 powered chat and code-completion engines, as well as test applications built on GPT-4. They also report that retrieved text can shape whether and how an application calls other APIs (summarised).
Linking this work to Borrowed Clearance is this reference's reading, not the authors'. Indirect prompt injection is the delivery route: text arrives from outside and is processed as though it carried instructions. Borrowed Clearance names one specific consequence for systems that move money or grant access, where the planted text claims a check has already passed and a later step accepts that claim as a verdict. The approval in the inbox scenario follows that path. The defences differ in kind. Filtering or isolating retrieved text tries to stop the sentence from being read as an instruction. The controls assume some such text will get through, and require that any clearance arrive as a signed result bound to one payload and checked where the transfer executes, so a sentence inside ingested content cannot count as one however it is worded.
Security decisions taken on untrusted input (CWE-807)
MITRE's Common Weakness Enumeration has a base-level entry for the general mistake underneath many of these cases. CWE-807, Reliance on Untrusted Inputs in a Security Decision (CWE 5.0; page last updated 28 October 2026) covers a protection mechanism that depends on whether some input is present, or on its value, when an untrusted party can alter that input and so get past the protection. The entry's reasoning is short: without encryption, integrity checking or a comparable mechanism, nothing that arrives from outside can be trusted. One of its examples is a medical records page that runs the password check only when an "authenticated" cookie is missing. The developer assumed the cookie would only ever be set after a successful login, but anyone can set it to 1 themselves, and the check never runs (summarised).
The mitigations follow from that. Keep state and sensitive data on the server and let it change only through legitimate state transitions. Where data has to travel through the client, protect it with a message authentication code such as HMAC. Repeat any client-side check on the server (the server-side enforcement section covers that sibling entry, CWE-602). Map every input that feeds a security decision, including email, files, database results and other systems reached indirectly through API calls, and redesign so the decision no longer rests on submitted input where possible (summarised).
Reading Borrowed Clearance as a case of CWE-807 is this reference's interpretation, not MITRE's. A status line saying a payment was "approved" plays the part of the cookie: a value the executing agent reads and acts on, which someone else could have written. The entry's remedies match the controls closely. The clearance becomes a signed record the executing service can verify, the decision is taken where the action happens, and an unverifiable claim is treated as absent.
Where the line falls
Both readings of borrowed authority ask which identity's rights an action is exercising. Borrowed Clearance asks which check an action is relying on: a result passed down from elsewhere that the executing agent never ran and has no means to confirm.
The two problems sit side by side. An agent may be fully entitled to move money under its own permissions and still release a transfer on a check it cannot prove, because what is missing is evidence, not entitlement. Limiting whose permissions get used does not, in itself, pin a clearance to a single amount, payee, and validity window, nor require validation at the service that executes. The controls handle that half. The OWASP mapping places ASI03 and ASI07 next to the term.