# An agent's access in AWS is its role's policy, plus what its tools reach, plus resource policies, minus the ceilings above it

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

To answer what an agent can reach in an AWS account, read four layers: the role it assumes, the tools and Lambda functions behind it, the resource-based policies on the targets, and the ceilings and network controls above them. This guide gives the order and the AWS pages that document each layer.

## Access is a sum and a subtraction, read in four layers

No single page in the console answers what an agent can access. The answer comes from four layers. The first is the identity-based policy on the role the agent assumes. The second is what the agent's tools can reach, because a tool can run under a different role. The third is the resource-based policies on the targets, which can name the agent's role as a principal. The fourth is the ceilings and network controls above the role, which can remove access the role's own policy grants. Read them in that order and write down each result. [The map](/map/) records the first two layers for the AWS platforms, and the [AWS cloud page](/clouds/aws/) sums them up.

## Layer one is the role the agent assumes

For [Bedrock Agents Classic](/agent-platforms/bedrock-agents/), the documented service role policy covers invoking named foundation models, reading the OpenAPI schema objects in S3 and querying attached knowledge bases. For [AgentCore](/agent-platforms/bedrock-agentcore/), Runtime runs under an execution role that AgentCore assumes. For an agent on [Lambda or EKS](/agent-platforms/self-hosted-aws/), the function runs as its execution role, and an EKS pod gets the role mapped to its service account by an EKS Pod Identity association. AWS documents that a container never has access to credentials used by containers in other pods, but that pods can reach the node's role if access to the instance metadata service is not restricted. Read the attached policies, not the role's name.

## Layer two is what the tools reach, and they may not use that role

In Bedrock Agents Classic, an action group is usually a Lambda function. AWS documents that the agent reaches it through a resource-based policy on the function, and that the function then runs under its own Lambda execution role. An action can also return control to the calling application, which then runs the action with its own credentials. On AgentCore, Gateway turns APIs, Lambda functions and existing services into tools, and each target chooses how its call is authorized: the gateway service role, the caller's credentials, OAuth, token passthrough or an API key. List every tool and name the identity it runs as ([check](/checklist/tool-own-role/)). An agent with five tools has up to six roles to read.

## Layers three and four add policies on the target and ceilings above

Resource-based policies live on the thing being accessed. AWS documents a KMS key policy as a resource policy and the primary way to control access to a key, so the agent's reach into encrypted data depends on that policy as well as its role ([check](/checklist/control-the-keys/)). S3 bucket policies, Lambda function policies and VPC endpoint policies work the same way. Above the role, AWS documents that service control policies specify the maximum available permissions for roles in an organization, and that a permissions boundary sets the maximum an identity-based policy can grant to a role ([check](/checklist/set-permission-ceiling/)). Network controls decide whether the call can leave at all ([check](/checklist/data-perimeter/)).

## Three defaults catch reviewers out

Three documented defaults tend to surprise reviewers. When you create a function in the Lambda console, AWS documents that it creates an execution role with minimal permissions, so a role that looks small may have been widened later by hand. On EKS, if access to the instance metadata service is not restricted, a pod's containers can also reach the node's IAM role. And the BedrockAgentCoreFullAccess policy, for the person or pipeline using AgentCore, grants broad permissions. None of the three appears in the agent's own role policy, so none shows up if the review reads only that.

AWS's data perimeter whitepaper describes organizations that want perimeter controls to help protect against unintended access, built from identity, resource and network controls together. For an agent this is the layer that decides whether data the role can read can also leave. Ask which organization-level controls apply to the account the agent runs in. The checklist item [put data the agent reads inside a perimeter](/checklist/data-perimeter/) records the documented form on each cloud.

## A worksheet for the review meeting

Fill one worksheet per agent. Each row is a question the AWS documentation lets you answer, and each answer is a fact about the account, not a promise from the builder. Rows left empty are open questions for the meeting described in [the approval guide](/guides/approving-an-agent-for-production/). Add a sixth row for the network path once the first five are filled. Keep the finished sheet with the review record.

| Question | Where to look in AWS | Checklist item |
| --- | --- | --- |
| Which role does the agent run as? | The service role or execution role and its trust policy | [own identity per agent](/checklist/own-identity-per-agent/) |
| What does that role allow? | Attached identity-based policies | [least-privilege policy](/checklist/least-privilege-policy/) |
| What do the tools run as? | Each Lambda execution role, each Gateway target | [tool role](/checklist/tool-own-role/) |
| What caps the role? | SCPs and permissions boundaries | [ceiling](/checklist/set-permission-ceiling/) |
| Who can call the tools? | Resource-based policies on the functions | [tool invokers](/checklist/restrict-tool-invokers/) |

## Related pages

- [Approving an AI agent for production: running the review meeting](/guides/approving-an-agent-for-production/)
- [AI agent permissions in Azure: Foundry Agent Service, identities and RBAC](/guides/ai-agent-permissions-in-azure/)
- [AI agent authorization in AWS, Azure and Google Cloud](/ai-agent-authorization/)
- [All of them](/guides/)

## Sources

- AWS: create a service role for Amazon Bedrock Agents: https://docs.aws.amazon.com/bedrock/latest/userguide/agents-permissions.html (read 10 Nov 2026)
- AWS: Lambda functions for Bedrock action groups: https://docs.aws.amazon.com/bedrock/latest/userguide/agents-lambda.html (read 10 Nov 2026)
- AWS: AgentCore Gateway outbound authorization: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-outbound-auth.html (read 10 Nov 2026)
- AWS: EKS Pod Identity: https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html (read 10 Nov 2026)
- AWS: AWS KMS key policies: https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html (read 10 Nov 2026)
- AWS: service control policies: https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html (read 10 Nov 2026)
- AWS: permissions boundaries: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html (read 10 Nov 2026)

Last reviewed 16 Nov 2026. Canonical: https://aiagentaccesscontrol.com/guides/what-can-an-ai-agent-access-in-aws/
