A sales director asks an AI agent to prepare offers for the accounts up for renewal this quarter. The agent receives a token that carries the director's rights, connects to the CRM and pricing APIs, and gets to work. The director may grant discounts of up to 30 percent, a limit meant for the handful of strategic deals that need it. The agent's model finds that the maximum discount gives the highest renewal probability, so it applies it to all 400 accounts. By the end of the afternoon, every offer has gone out.
Every call in this story carried a valid token and matched the API schema, and every discount stayed within the limit the director's role allows. No object belonged to anyone other than the caller, so nothing resembled an enumeration attack, and the API security platform logged a busy afternoon without a single alert. Yet the agent, by doing exactly what it was allowed to do, had given away a large share of the quarter's margin.
Most of what the API security market sells as authorization protection addresses the easy end of this problem. Detecting Broken Object Level Authorization (BOLA) means spotting a caller that walks through object IDs it has no right to, and behavioral analytics handle that well. The hard case is a user with legitimate rights who delegates them to an agent. The agent stays within its intended purpose and still causes harm, either by chaining operations that each look harmless or because the authorization model was never fine-grained enough to tell a strategic exception from a default.
Where Is the Decision Actually Made?
In most deployments, authorization for an agent happens once: when the identity provider issues the token. The scopes in that token are coarse by design. A scope such as pricing:write says nothing about which accounts, which discount, for which task, or on whose behalf. The gateway then checks that the token is valid, unexpired and carries the expected scope, and passes the call through. Everything after that point relies on the backend application, which in most cases trusts the gateway.
Delegation makes this worse. OAuth 2.0 Token Exchange lets a token record both the user and the agent acting for them, so the information needed for a better decision often travels with the request. Most enforcement points read only one of those identities, and very few check the combination against the operation requested. The question that matters is whether this agent, acting for this user, on this task, should perform this operation on this object, yet almost nothing in the request path asks it.
Time compounds both problems. An agent may work for hours on a token issued at the start of its session, while the user's role changes, the session's risk rises, or the task drifts away from what the user asked for. Authorization decided once per session was a weak control for humans, who at least pause between clicks, but for an actor that makes thousands of calls without pausing, it provides almost no control at all.
Should the Gateway Decide at All?
KuppingerCole's Advisory Note From Identity to Access argued that authorization at a gateway is coarse and easily bypassed, and that enforcement has to reach the API, the service and the database where the action lands. The argument still stands, but the agentic case forces a refinement that Martin Kuppinger and I did not address at the time.
A gateway is coarse when it decides on its own, from whatever policy fits into its configuration. A gateway that forwards the full request context to an external decision point, and only enforces the answer, inherits the precision of the policy behind it. The useful question for an agentic deployment is whether the gateway should make the decision itself or merely enforce one made elsewhere.
The standard for that split now exists. The OpenID Foundation approved the AuthZEN Authorization API 1.0 as a Final Specification in January 2026. It defines how a policy enforcement point asks a policy decision point for a decision without either side knowing the other's internals: subject, action, resource and context go in, a decision comes out. A gateway, a service mesh sidecar and a Model Context Protocol (MCP) server can all ask the same question of the same decision point. The policy then lives with whoever is accountable for the decision rather than in the configuration of whichever gateway the traffic happens to cross. For MCP specifically, a Working Group Draft approved in June 2026, the AuthZEN Profile for Model Context Protocol Tool Authorization, defines how each tool call and its parameters map into such a request.
None of this makes enforcement at the resource redundant. The interface can decide on what it can see: the caller, the principal behind it, the operation, the object and the state of the session. Row-level filtering, masking and the final check on the data itself still belong to the data layer, which remains the last line of enforcement for agentic data access. Enforcement at the interface is therefore necessary but not sufficient on its own, so plan for it together with these data-layer controls.
Five Capabilities Belong at the Enforcement Point
In practice, five capabilities close the authorization gap at the interface. Few API security platforms deliver all of them today, and KuppingerCole's 2025 Leadership Compass on API Security and Management named authorization at the enforcement point as the largest gap across the market.
- Validation of delegated tokens against the operation requested, evaluating both the agent and the user it acts for, not only whichever identity sits in the subject claim.
- Per-call decisions from an external decision point over AuthZEN, so that policy is written once and enforced consistently across gateways from different vendors.
- Re-evaluation of authorization during long-running agent sessions, triggered by time, risk signals or changes in the task.
- Human approval for high-risk and irreversible operations, enforced where the call lands rather than in the agent's own instructions.
- Governance of the policies themselves: a named owner, approval and review workflows, and policy as code under version control.
None of these capabilities is new: KuppingerCole's Advisory Note Governing the Agentic AI Lifecycle arrives at the same measures from the identity side, including scope that narrows at every hop of a delegation chain. What is still missing is their implementation at the layer where agent traffic arrives, and that layer is where your questions to vendors should focus.
Two questions separate the field quickly when you evaluate vendors: whether the platform validates on-behalf-of claims against the specific operation or only checks that the token is valid, and whether it can call an external decision point on every request without becoming the bottleneck. A vague answer to either question should weigh more in your decision than anything the datasheet promises.
Back to the Renewal Offers
With a decision made per call, each pricing request carries the task it belongs to. The decision point sees that a maximum discount is an exception the director's role permits for individual deals, not a default for an entire portfolio. It therefore routes every offer at the maximum discount to the director for approval. The agent still prepares every renewal, and the margin survives the afternoon.
The agent broke nothing, and it will not need to break anything next time either, because the gap it found lies in when and how often authorization is decided. You can keep deciding authorization once per session and trusting the result for hours, or you can decide it every time an agent asks. Only the second approach will keep pace with the number of agents you are about to deploy, which is why the two evaluation questions above belong in your next conversation with your API security vendors.