Skip to content
    Gaincontrol

    Authenticating the agent isn't authenticating the action

    Gaincontrol Team··3 min read

    "Which agent is this" and "is this specific action allowed right now" are different questions, and most systems that handle agent authentication only ever build an answer to the first one. An agent proves its identity once, usually at startup or at the top of a session, and every call it makes afterward inherits whatever trust that one check established. The two questions collapse into one, and the gap opens exactly where they do: authenticating the agent says who's asking. It says nothing about whether this specific request, right now, is something that agent should be allowed to make.

    Authentication answers "who," not "may"

    A workload identity, a certificate, an attested credential — these establish that the caller really is the agent it claims to be, not an impostor and not a stale session replaying old credentials. That's a real check and a necessary one. But it's a static fact about an actor, checked once, not a judgment about an action, checked every time one is attempted. The identity verified at session start has no opinion about the hundredth call that session makes, whether that call reads a log file or drops a production table. It already said yes, and nothing asked it to say anything else.

    Conflating the two checks is the confused deputy problem

    Norm Hardy's confused deputy described this shape decades before agents existed: a program holding legitimate authority gets tricked into using it for something that authority was never meant to cover, because nothing re-examines the request once the program's standing to act is already settled. An agent authenticated once and trusted for everything it does afterward is the same failure wearing a newer name. MCP's own security guidance describes a version of it at the protocol level: a client that accepts an upstream credential at face value and passes it straight through is conflating proof of who sent a request with a decision about whether that request should be allowed, and loses the ability to tell the two apart once something goes wrong.

    An agent that authenticated five minutes ago isn't making this request on behalf of that authentication. It's making a request the system still has to decide about on its own.

    Two checks on every call, not one check at the start

    The fix isn't a stronger identity check. It's a second, separate check that runs on every action, after identity is already settled. Authenticating the agent answers who's calling. A policy decision on the specific call in front of it — this tool, these arguments, this target — answers whether that call is allowed right now, and it has to run again on the next one, and the one after that, because the fact that changes between calls is never who the agent is. It's what it's now asking to do. Re-running that allow-or-deny decision at the moment of execution, rather than once at the top of a session, is what actually keeps the two questions answered separately instead of merged into one.

    Keeping them separate is a design decision, not a formality

    Treating identity and authorization as one settled fact is the easier system to build: fewer checks, fewer round trips, one less thing that can go wrong in the critical path. It also means an agent that is fully, provably who it claims to be can still do something nobody meant to allow, because nothing after the first check was ever asked whether this particular action made sense. Keeping the two questions apart has to be something a system decides on purpose. It doesn't happen because the first answer felt thorough enough to cover the second.

    Sources

    • The Confused Deputy. Norm Hardy, ACM SIGOPS Operating Systems Review, 1988. Describes a program with legitimate authority tricked into misusing it because nothing re-examines a request once its standing to act is already settled — the same shape as an agent trusted for everything once it has authenticated.
    • Security Best Practices. Model Context Protocol documentation, version 2026-07-28. Its token passthrough section describes a client that accepts an upstream credential at face value, conflating proof of who sent a request with a decision about whether that request should be allowed.

    Zino issues every workload a cryptographically attested identity through two-layer attestation, then re-authorizes each REST, Shell, and MCP call against signed policy before it leaves — identity and action checked separately, every time.

    See how Zino checks identity and every action separately →