# An agent acts with its own authority unless the platform is set up to carry the user's, so users can reach more than they hold

Facts read 10 Nov 2026. Page reviewed 16 Nov 2026.

A user who talks to an agent does not lend it their access. The agent calls tools with its own identity unless the platform exchanges tokens to act for the user. This guide shows how AgentCore, Agent Runtime and Foundry separate the two, and what to ask in a review.

## Two kinds of authority sit behind one chat window

A person signs in, asks an agent for something, and the agent calls a tool. Whose permissions does the tool call carry? There are two answers. In the first, the tool runs with the agent's own authority, so every user of the agent can reach whatever the agent can reach, whatever their own rights. In the second, the tool runs with the user's authority, so the agent can do only what that user may. Both are legitimate, and most agents mix them tool by tool. The mistake is not choosing. A review has to ask which one each tool uses, and the answer has to be written down.

## AgentCore Gateway offers a different identity for each target

On [Amazon Bedrock AgentCore](/agent-platforms/bedrock-agentcore/), AWS documents that outbound authorization is set per gateway target. A target can sign requests with the gateway service role, use the caller's IAM credentials, run the client credentials grant (machine to machine, acting on the application's behalf), run the authorization code grant (user-delegated, with consent), or use a token exchange. AWS describes the token exchange as swapping the inbound user's access token for a new, scoped token that carries both the user's identity and the agent's identity. The identity of a tool call therefore depends on which option each target uses, so one gateway can hold targets on both sides of the line.

AWS also documents a sharp edge in the broad managed policy. BedrockAgentCoreFullAccess grants GetWorkloadAccessTokenForUserId, which issues workload access tokens from a caller-supplied user identifier string without verifying a token from an identity provider. AWS recommends a custom policy with only the permissions the application needs. The point for a review is that a policy that broad lets the caller choose whose identity to claim, so the people who can call that API deserve the same scrutiny as the agent.

## Google and Microsoft name the same split

Google documents three identities for [Agent Runtime](/agent-platforms/agent-runtime-gcp/): the user identity, which sets caller context at ingress; the agent identity, which authenticates the workload inside the runtime; and a delegated identity that combines both when the agent acts for the user with scoped 3-legged OAuth. Calls to Google Cloud APIs made with agent identity are evaluated against the agent identity. Microsoft documents the same pair for [Foundry Agent Service](/agent-platforms/foundry-agent-service/): application-only access, where the agent acts under its own authority, and delegated access, where it acts for the signed-in user and needs both the agent's authorization and the user's access. Microsoft labels the delegated mode as preview. Both mean the review must ask for the agent's mode per tool, not per agent.

## Self-hosted agents get no user propagation from the platform

For agents on Lambda, EKS, Cloud Run, GKE, Container Apps or AKS, the workload uses its own role, service account or managed identity. We found no documented mechanism in the Lambda, EKS, Cloud Run, GKE, Container Apps or AKS pages read on 2026-11-10 that carries an end user's permissions to the workload, so any such behavior is written in the builder's code. That is a reason to ask for it in writing: how does the code decide which user a call is for, and what stops it from using the workload's broader role instead? Compare the [self-hosted AWS](/agent-platforms/self-hosted-aws/), [Google Cloud](/agent-platforms/self-hosted-gcp/) and [Azure](/agent-platforms/self-hosted-azure/) entries.

## A worked case shows what changes between the two modes

Take a support agent with one tool that reads customer records. If the tool runs on the agent's authority, every employee who can open the chat can read any record that the agent's role allows, whatever their own rights. The audit log may name only the agent's identity. If the tool runs on the user's authority, a support trainee gets the records the trainee could already open, and the log can show both identities on platforms that carry them. The second mode costs more to build, since a token has to be exchanged and verified. The first mode costs less to build and more to review, since the role must be narrow enough for the least trusted user.

Neither mode fixes a broad role. On the agent's authority, the role is the limit. On the user's authority, the user's own access is the limit, and many users hold more than they need. The review should therefore record the mode for each tool and also say which role bounds it. Do not let the second mode stand in for the first: it moves the question from the agent's role to the user's role, and both need an owner.

## Put one question to the builder for every tool

The checklist item is [decide for each tool whether it runs with the agent's authority or the user's](/checklist/decide-user-or-agent-authority/). Ask the builder for a list of tools with one of two answers beside each. For tools on the agent's authority, check that the agent's role is narrow enough for every user to hold it ([check](/checklist/least-privilege-policy/)). For tools on the user's authority, ask where the user's token comes from and who verifies it. A tool that needs neither answer should be deleted. Give each tool its own role where you can ([check](/checklist/tool-own-role/)), so that a misused tool reaches only what it was built for.

## Related pages

- [Network reachability for AI agents on AWS, Google Cloud and Azure](/guides/network-reachability-for-agents/)
- [Logging what an AI agent did: audit, data and model logs](/guides/logging-what-an-agent-did/)
- [AI agent permissions: how to cut an agent's access](/guides/least-privilege-for-ai-agents/)
- [All of them](/guides/)

## Sources

- AWS: AgentCore Gateway outbound authorization: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-outbound-auth.html (read 10 Nov 2026)
- AWS: IAM permissions for AgentCore Runtime: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-permissions.html (read 10 Nov 2026)
- Google Cloud: identity delegation architecture for agents: https://docs.cloud.google.com/gemini-enterprise-agent-platform/govern/identity-delegation-architecture (read 10 Nov 2026)
- Microsoft: agent identity in Foundry Agent Service: https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/agent-identity (read 10 Nov 2026)
- AWS: Lambda execution role: https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html (read 10 Nov 2026)

Last reviewed 16 Nov 2026. Canonical: https://aiagentaccesscontrol.com/guides/why-an-agents-permissions-are-not-its-users/
