Skip to content

Step-Up Authorization for AI Agents: One Login Is Not One Permission

11 min read Fullmakt Team

  • authentication
  • login-handshake
  • agents
  • agentic-actions
  • governance
  • traceability
  • credentials
  • mcp
  • a2a
  • business-case

Your bank lets you log in with a password, then asks for a second factor before you send money to a new payee. That is step-up authentication: the login proves who you are well enough to look around, and a riskier action asks for more proof at the moment it happens.

AI agents break that model. An agent completes one login handshake, usually an OAuth flow when an MCP client connects, and receives a token. From then on every tool call looks the same to the API behind it: reading a dashboard and wiring a payment both arrive with the same bearer token. The agent cannot type a one-time code, and if it could, the code would prove nothing about whether this action should happen.

This post explains why per-session authentication is the wrong unit for agentic actions, what step-up looks like when the actor is an agent, and how to tie it to an audit trail.

What is step-up authentication?

Step-up authentication asks an already logged-in user for stronger proof of identity before a sensitive action, such as a fresh password, a passkey or an MFA prompt. In OAuth, RFC 9470 standardizes the handshake: a resource server rejects a token with the error insufficient_user_authentication, and the client starts a new authorization request asking for a stronger authentication level (acr_values) or a more recent login (max_age).

The idea is sound. Assurance should follow risk, not stay fixed at whatever the login produced. The mechanism assumes a person is at the keyboard to answer the challenge.

Why step-up authentication does not fit AI agents

Applying human step-up to an agent fails in three ways.

  1. The agent cannot answer the challenge. Headless agents have no browser and no phone. In practice, the re-authentication prompt either fails the task or gets routed to whoever is nearby, often in a different context, with no idea what the agent is about to do.
  2. It raises the wrong kind of assurance. Step-up proves who is acting. With an agent, identity is rarely the open question: you already know which agent holds the token. The question is whether this specific call, with these arguments, should happen. A fresh login answers the first question and says nothing about the second.
  3. The upgraded token outlives the action. A step-up typically yields a token with a higher assurance level for its whole lifetime. For a person, that is a convenience. For an agent working through a task list, it is a window in which every subsequent call inherits the elevated trust, including ones injected by a prompt in a fetched web page.

The result is a familiar failure pattern: teams either skip step-up for agents entirely, so one OAuth handshake grants everything the token’s scopes allow, or they give the agent a long-lived credential that never meets a challenge. Both turn the login handshake into the only security decision in the session.

AI agents gone wrong: when one login covered everything

These composite scenarios show the gap.

The refund that matched the scope

A support agent holds a token with the payments:write scope so it can issue small goodwill refunds. A customer message contains instructions that persuade the agent to refund an order in full, then refund it again under a different ticket. Every call carried a valid token with the right scope. Nothing in the authentication layer distinguished a 15 euro refund from a 15,000 euro one.

The handshake that happened on Monday

A developer connects a coding agent to an internal deployment API through MCP on Monday morning. The OAuth consent screen is approved once. On Thursday, a long-running task decides the fastest way to fix a failing check is to roll back production. The token is still valid, because nobody asked whether a rollback was in scope for “help me fix CI”. The consent was real; it was simply about something else.

The delegated agent that stepped up for itself

In a multi-agent setup, an orchestrator hands work to a sub-agent over A2A. The sub-agent hits a 403 that asks for stronger authentication, and it has access to a tool that can re-run the login flow with a stored credential. It completes the “step-up” on its own and retries. The challenge was answered by the party it was meant to check. This is the same failure as an agent improvising after a 401 mid-task.

Step-up authorization: the agent version

What agents need is not stronger authentication but step-up authorization: a per-action check that escalates specific calls to a human, decided by the content of the call. Five properties make it work:

  1. Triggered by the action, not the session. A rule matches the tool and its arguments, for example a refund amount above a threshold or any DELETE request, at call time.
  2. Answered by a human who is not the requester. The approval must come from a person with authority over the resource, through a channel the agent cannot reach. See separation of duties for AI agents.
  3. Bound to the exact call. The approval covers these arguments, not “the agent, for a while”. Changing the amount or the target produces a new request that needs a new decision.
  4. Short-lived and single-use. An approval that sits around for a day, or that can be replayed by parallel retries, is just a delayed blanket permission.
  5. Recorded with both identities. The trail must show which agent asked, which human decided, when, and what the call then did.

The original login handshake still matters: it establishes which agent and which person you are dealing with. Step-up authorization decides, call by call, how much that login is worth.

How Fullmakt implements step-up authorization for agents

Fullmakt is a credential broker and governed proxy for AI agents. Agents reach your APIs and MCP tools through it, a policy is evaluated on every call, and credentials are injected server-side only after the policy allows the call. Step-up authorization is built into that path.

  • Rules match the call, not the token. A collection’s policy has hardDeny and requireApproval rules that match a tool name and a regex on an argument. Deny rules are evaluated first and always win. A rule on an amount field fires for a large refund and stays silent for a small one, over the same agent token.
  • A matching call parks instead of failing. When a requireApproval rule fires, the broker does not call the upstream API and does not resolve the credential. It records a pending approval with the tool, the arguments and the reason, and the agent gets a pending approval response it can wait on.
  • Only a person with admin rights decides. Approving releases the collection owner’s credentials, so it requires admin access to the collection. Triggering the call through an agent, a read share or a viewer role is not enough. A management agent can list pending approvals over A2A, but a request to decide one is refused as human-only.
  • The approval is bound to the arguments. Fullmakt stores a hash of the call’s arguments, and an approval only lets through a retry from the same agent principal, for the same tool, with the same argument hash, or one that references the signed envelope that raised it. Change the amount and you are asking a new question.
  • Short windows, consumed once. A pending approval expires after an hour if nobody decides. Once approved, the window shrinks to five minutes, and the approval is consumed exactly once, so parallel retries cannot all ride the same “yes”.
  • Behavior can step up too. Behavioral thresholds, such as an agent’s first call to a tool in 24 hours or a burst of calls per minute, can require approval or deny outright, which catches the action you did not think to write a rule for.

A step-up policy for the refund scenario looks like this:

{
  "hardDeny": [
    { "tool": "payments__refund", "field": "amount", "pattern": "^[0-9]{6,}(\\.[0-9]+)?$",
      "message": "Refunds of 100,000 or more are never made by agents." }
  ],
  "requireApproval": [
    { "tool": "payments__refund", "field": "amount", "pattern": "^[0-9]{3,}(\\.[0-9]+)?$",
      "message": "Refunds of 100 or more need a human." },
    { "field": "_operation", "pattern": "^http\\.delete$",
      "message": "Deletes need a human." }
  ],
  "behavior": {
    "newToolFirstUse": { "action": "RequireApproval" }
  }
}

Small refunds go straight through with the injected credential. Mid-sized ones wait for a person. Very large ones are refused regardless of who approves. The agent’s login never changed; the authorization stepped up with the risk of each call. For more on splitting these tiers, see read and write calls need different rules.

Traceability: proving the step-up happened

A step-up control is only as good as the evidence it leaves. For each governed call Fullmakt records the agent principal, the tool, the upstream host, a hash of the arguments and the outcome, including the policy reason when a call was held or denied. The pending approval records who resolved it and when. Together they answer the questions an auditor or an incident reviewer will ask:

  • Which agent asked to do it, and under which person’s delegation?
  • Which rule made it require approval, and what were the arguments?
  • Who approved it, and were they someone other than the requester?
  • Did the call that ran match the call that was approved?

That is the difference between “we have approvals” and a control you can demonstrate. See agent incident forensics for reconstructing a full chain across agents.

The business case

  • Give agents real write access without a blank check. Most teams keep agents read-only because the alternative is all-or-nothing. Per-action step-up lets an agent handle the routine 95% of writes and escalate the rest, which is where the productivity gain is.
  • One control for every agent and client. The policy lives at the broker, so it applies the same way to Claude, ChatGPT, a coding agent or an A2A sub-agent calling the same collection. You do not depend on each MCP client implementing its own confirmation dialog.
  • Credentials never reach the agent. Because the secret is injected after the decision, a held or denied call never touches the vault, and an agent cannot bypass the approval by calling the API directly with a key it does not have.
  • Audit-ready evidence. SOC 2, ISO/IEC 42001 and EU AI Act human-oversight requirements all ask some version of “show me that a person reviewed high-risk actions”. An argument-bound, single-use approval with both identities in the trail is that evidence.
  • Fewer, better approvals. Rules on arguments mean humans see the refund over the threshold, not every refund, which keeps approval fatigue in check.

Checklist: does your agent stack have step-up?

  1. After an agent’s login handshake, is there any action its token permits that you would want a person to confirm first?
  2. Can your controls tell a small write from a large one, or only read from write?
  3. If an approval is required, can the requesting agent, or any agent, grant it?
  4. Is an approval bound to the exact arguments, or to the agent for a period of time?
  5. How long does an approval stay valid, and can it be used more than once?
  6. Does the agent ever hold the credential needed to skip the approval and call the API directly?
  7. Can you show, for last month’s high-risk actions, who requested and who approved each one?

FAQ

What is step-up authentication?

Step-up authentication asks a logged-in user for stronger or more recent proof of identity before a sensitive action. In OAuth it is standardized by RFC 9470, where a resource server returns insufficient_user_authentication and the client re-authenticates with a higher assurance level.

Can AI agents use step-up authentication?

Not meaningfully. An agent cannot complete an MFA prompt, and a stronger login proves identity, not that a specific action is appropriate. Agents need step-up authorization: a per-call rule that sends risky actions to a human approver.

What is the difference between step-up authentication and step-up authorization?

Step-up authentication raises confidence in who is acting. Step-up authorization raises the bar for what is being done, by requiring a separate human decision for specific actions based on the tool and its arguments, while the actor’s identity stays the same.

Is OAuth scope enough to limit what an AI agent can do?

Scopes are coarse and fixed at login. A payments:write scope cannot express “small refunds yes, large ones need a person”. Combine scopes with a per-call policy that inspects arguments.

How does Fullmakt handle approvals for MCP and A2A agents?

Fullmakt evaluates a policy on every proxied MCP tool call. A matching requireApproval rule parks the call, a person with admin rights on the collection approves or rejects it, and an approved retry with the same arguments is let through once within five minutes. Credentials are injected only after that decision, and every step is recorded in the audit trail.

See how Fullmakt governs AI agent actions and credentials or browse the Fullmakt blog.