jcardena.com › Blog › Acting On Behalf Of: Delegation Without Standing Privilege
184 posts
EN ES

Acting On Behalf Of: Delegation Without Standing Privilege

AI

When an agent acts for a person it should borrow only that person's authority, for that task, then give it back. Delegation without standing privilege.

Acting On Behalf Of: Delegation Without Standing Privilege

Once an agent has its own identity, the next question is sharper and more dangerous: what is it allowed to do, and on whose authority. It is tempting to give the agent broad, permanent power so it can handle anything a user might ask. That convenience is exactly the risk. An agent that always holds a lot of authority is a loaded tool sitting in the open, and anyone who can get the agent to act, including through a cleverly worded request, can borrow that authority. The safer path is the opposite of convenient: give the agent almost nothing by default, and let it borrow just enough, just in time.

TL;DR: Do not give agents standing privilege, broad power they hold all the time. When an agent acts for a person, it should act on behalf of that person: borrowing only that user's authority, scoped down to the task at hand, for a short and revocable window, and then returning it. An agent should never end up able to do more than the person it is helping, and it should never keep that power lying around between tasks. Delegation, not accumulation.

User AsksBorrow ScopedAuthorityAct ForThis TaskReturn It
Delegation: borrow just enough, just in time, then give it back.

The dangerous convenience of standing power

Standing privilege is power an actor holds continuously, whether or not it is using it. For a human employee we already know this is risky, which is why good systems grant narrow access and expand it only when needed. For an agent it is worse, because the agent is reachable by software and, increasingly, by anyone who can phrase a request it will act on. Every bit of standing authority an agent holds is authority that a manipulated agent can be made to use. The more it can do at rest, the larger the prize for anyone who learns to steer it. Convenience at rest is danger in motion.

Borrow the user's authority, not your own

The core move is that when an agent works for a person, it should act with that person's authority, not with a powerful identity of its own. If I ask an agent to pull up my records, it should reach them as me, limited to exactly what I could have reached myself. This sounds obvious and it is routinely violated, because it is easier to give the agent one strong identity that can reach everyone's records and trust it to only touch the right person's. That trust is the hole. An agent that can technically reach everything, and is only supposed to reach one person's slice, is one bug or one clever prompt away from reaching all of it.

A gold token passed forward then dissolving back to its origin
Borrow the user's authority, not a powerful identity of the agent's own.

Scope it down, never up

Borrowed authority should also be narrowed to the task. If the job is to read one thing, the borrowed power should permit reading that one thing, not reading everything the user could read, and certainly not writing. Delegation should only ever scope down from what the person could do, never up, and ideally down to the single action at hand. The question I ask of every delegated action is whether the authority handed over is the smallest that completes the task. If the agent is borrowing more than the moment requires, that surplus is pure risk with no benefit, waiting for something to go wrong.

Give it back: short-lived and revocable

Borrowed authority must also be returned. The window in which an agent holds a person's delegated power should be short, tied to the task, and revocable at any moment. When the task is done, the power evaporates; it does not linger in the agent for later. And if something looks wrong, you should be able to pull it back immediately, everywhere, without hunting. Short-lived and revocable are what keep delegation from quietly turning into standing privilege by accident, one un-returned grant at a time. Authority that is easy to borrow and automatic to return stays small; authority that is borrowed and kept becomes the very thing we were trying to avoid.

A wide bundle of light narrowed to one thin scoped beam
Scope it down, never up: the smallest authority that completes the task.

The confused deputy, and how to not be one

There is an old name for the failure this all guards against: the confused deputy, a helpful actor with more authority than the person asking, tricked into using that authority on their behalf. An agent is the perfect confused deputy if you build it wrong: eager, capable, and holding broad power. The whole discipline of delegation is how you keep your agent from becoming one. If the agent only ever acts with the asker's own scoped-down, short-lived authority, then a manipulated agent can only do what the asker could already have done, which is a bounded, survivable failure instead of a catastrophic one. You do not prevent every trick. You make sure no trick grants more than the person deserved.

REQUESTUserIntentDELEGATIONOn-Behalf-OfNot StandingPowerSCOPENarrowed tothe TaskLIFETIMEShort-LivedRevocableAUDITAttributable:User + Agent
Delegation without standing privilege: borrowed, scoped, short-lived, revocable, attributable.

The takeaway

Giving an agent its own identity answers who it is. Delegation answers what it may do, and the safe answer is: as little as possible, borrowed from the person it is helping, scoped to the task, for a short and revocable moment, then returned. Never let an agent hold broad standing power just because it is convenient, because convenient power at rest is exactly what a manipulated agent turns into harm. Build for delegation, not accumulation, and the worst an agent can be talked into is whatever the person it serves was already allowed to do. That boundary is the difference between a helpful deputy and a confused one.

JC
Juan Cardena
Enterprise AI & Agentic Systems Architect

Enterprise architect with 25 years across web, software, data, and AI. MIT CDAO ’25. Writing on agentic AI in production.