AI agent authorization is decided by the agent's identity, the resource's policy and, where used, the user's token
Facts read 16 Nov 2026. Page reviewed 16 Nov 2026.
AI agent authorization in a cloud account is one decision made on up to three inputs: the identity the agent runs as, the policies attached to the resource it calls, and, on platforms that support it, a token that carries the user. AWS, Azure and Google Cloud documentation read on 16 Nov 2026 describes each input.
The cloud decides on the identity that signed the call
A cloud API does not see an agent. It sees a request signed by an identity, and it decides whether that identity may perform that action on that resource. AWS documents the sequence: it first authenticates the principal, then processes the request context to find which policies apply, then evaluates all policy types to allow or deny (AWS: policy evaluation logic, read 16 Nov 2026).
For an agent, the identity is the role, service account or agent identity the platform runs it as. The identity an AI agent runs as lists it per platform. The rest of this page covers what the cloud then checks against that identity, and where a user can enter the decision.
Authorization inputs in each cloud
| Cloud | Identity the decision is made on | Where the grant sits | Limits applied on top |
|---|---|---|---|
| AWS | An IAM role, for example the execution role of AgentCore Runtime or the service role of a Bedrock agent | Identity-based policies on the role, and resource-based policies on the resource; AWS documents that within one account the result is the union of the two | SCPs, RCPs, permissions boundaries and session policies; AWS documents the result as the intersection with the grant |
| Azure | An Entra agent identity or a managed identity | Azure RBAC role assignments at a scope (management group, subscription, resource group or resource), or a service's own data-plane roles | Deny assignments, which Azure Resource Manager checks first, and optional role assignment conditions that filter a grant by attributes |
| Google Cloud | An agent identity principal, the default service agent, or a service account | Allow policies that bind roles to the principal on a resource, inherited down the hierarchy | Deny policies, which IAM checks before allow policies, and Principal Access Boundary policies on the principal |
The role or identity decides what the agent is allowed to try
On AWS, AWS documents that the AgentCore Runtime execution role is the identity the agent assumes, and that the console can create it when the console role holds the listed IAM create permissions (AWS: IAM permissions for AgentCore Runtime). A Bedrock agent runs as a service role whose trust policy names bedrock.amazonaws.com (AWS: service role for Bedrock Agents). Anything that role's policies allow is something the agent can attempt.
On Azure, Microsoft documents that a new Foundry agent identity starts without resource permissions and that Foundry assigns it no RBAC roles (Microsoft: agent identity concepts). The grant is whatever an administrator adds, and Microsoft names the object ID of the agent identity as the assignee. On Google Cloud, Google documents that a deployed agent identity receives the Agent Default Access and Agent Context Editor roles by default, and advises against granting it project-level roles such as Vertex AI User (Google Cloud: agent identity on Agent Runtime).
The resource's own policy can allow or refuse the same call
A resource can carry its own policy, and it is evaluated beside the identity's. AWS lists IAM role trust policies and S3 bucket policies as resource-based policies and documents that a resource-based policy must name a principal (AWS: policies and permissions in IAM). AWS also documents that AgentCore Runtime resources can be protected with resource-based policies. An explicit deny in either the identity policy or the resource policy overrides an allow.
Azure and Google Cloud place most of this in the hierarchy rather than on the resource. Azure Resource Manager retrieves the role assignments and deny assignments that apply to the resource and blocks the call if a deny assignment applies (Microsoft: Azure RBAC overview). Google documents that IAM always checks relevant deny policies before allow policies (Google Cloud: deny policies). Put those ceilings in place first; the guardrails page covers them.
The on-behalf-of user is a third input, and not every platform adds it
Authorization can run on the agent's authority, the user's, or both. In the Microsoft identity platform, the on-behalf-of flow uses delegated scopes only: roles stay attached to the user and never to the application acting for them (Microsoft: on-behalf-of flow). For a Foundry agent, Microsoft documents delegated access as needing both the agent's authorization and the user's access to the resource.
AWS documents several outbound options for AgentCore Gateway: the caller's IAM credentials, a user-delegated authorization code grant, a token exchange that carries both the user and agent identities, and a client credentials grant that acts on the application's own behalf (AWS: Gateway outbound authorization). The AgentCore Runtime page warns that the BedrockAgentCoreFullAccess managed policy includes GetWorkloadAccessTokenForUserId, which issues workload access tokens from a caller-supplied user ID string without checking the identity provider, and advises production use of GetWorkloadAccessTokenForJWT instead. Google describes a delegated identity that combines the user and the agent when the agent calls downstream services for the user (Google Cloud: identity delegation architecture).
The map records which platforms document each option, and why an agent's permissions are not its user's explains the gap when the platform does not carry the user.
What to check in a review
- Name the identity the agent runs as, and confirm it is not shared with another agent (check: own identity per agent).
- List the identity's grants and the resource policies on what it reaches.
- Find the ceilings above it: organization policies, deny rules and boundaries (check: set a ceiling).
- For each tool, record whether it runs on the agent's authority or the user's (check: user or agent authority).
- Read the Agent Access Map for the platform's documented defaults.
Related pages
Sources
- AWS: policy evaluation logic, read 16 Nov 2026
- AWS: policies and permissions in IAM, read 16 Nov 2026
- AWS: IAM permissions for AgentCore Runtime, read 16 Nov 2026
- AWS: create a service role for Amazon Bedrock Agents, read 16 Nov 2026
- AWS: AgentCore Gateway outbound authorization, read 16 Nov 2026
- Microsoft: Azure RBAC overview, read 16 Nov 2026
- Microsoft: agent identity concepts in Foundry, read 16 Nov 2026
- Microsoft: OAuth 2.0 on-behalf-of flow, read 16 Nov 2026
- Google Cloud: deny policies, read 16 Nov 2026
- Google Cloud: agent identity on Agent Runtime, read 16 Nov 2026
- Google Cloud: identity delegation architecture, read 16 Nov 2026
Last reviewed 16 Nov 2026.