The Agent Access Map: the identity each agent platform runs as and what it can reach
Facts read 10 Nov 2026. Page reviewed 16 Nov 2026.
The Agent Access Map lists eight agent setups across AWS, Google Cloud and Azure: five managed agent platforms and three self-hosted patterns. For each it gives the identity the agent runs as, its default permissions, the tools it calls, the network path, the logs and the boundary mechanisms that apply, all from provider documentation.
Download the map ยท Run the checklist
Read the map one row at a time. Start with the identity column: it says whose authority the agent acts with. Then read default permissions, which show what the agent holds before you change anything, and the boundary mechanisms, which show what you can use to cap it. Where the provider documents no answer, the cell says none found on 2026-11-10, which is a statement about the pages read.
The map was built from provider documentation only, read on 10 Nov 2026. Every cell carries a quote and a source URL from AWS, Google Cloud or Microsoft pages. Three renames are recorded: Amazon Bedrock Agents is now Amazon Bedrock Agents Classic, Agent Runtime was formerly Vertex AI Agent Engine, and Microsoft Foundry Agent Service was formerly Azure AI Foundry Agent Service. Amazon Q Business and Copilot Studio agents are left out, with the reasons recorded.
The identity it runs as
| Agent platform | Cloud | The identity it runs as |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | AWS documents that the agent runs as an IAM service role that Amazon Bedrock assumes. You can let Bedrock create the role automatically or supply a custom service role. The trust policy names the bedrock.amazonaws.com service principal. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | Runtime runs the agent under an IAM execution role that AgentCore assumes. Gateway uses a gateway service role for IAM-based outbound calls. AgentCore Identity is a separate service that manages credentials so agents can reach AWS resources and third-party services on behalf of users. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | Google documents three choices: a per-agent IAM agent identity (recommended, a principal tied to the individual agent); the Google-managed AI Platform Reasoning Engine Service Agent used by default; or a custom service account. Service accounts are shared across agents you deploy. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | Gemini Enterprise registers an ADK agent that runs on Agent Runtime, so the agent runs under the Agent Runtime identity described in that entry. A Gemini Enterprise administrator can see the agent's identity, typically its SPIFFE ID, or the Agent Registry resource ID if no SPIFFE ID is published. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | Each agent gets a Microsoft Entra agent identity, a special service principal created under an agent blueprint. Hosted agents get a dedicated Entra agent identity at deploy time. A project-wide managed identity also exists, and legacy agents share it, with no per-agent separation. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | A Lambda function runs as its execution role. On EKS, EKS Pod Identity associates an IAM role with a Kubernetes service account in a namespace; IAM roles for service accounts (IRSA) is the older OIDC-based option. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | Cloud Run runs the service as a service account (the Compute Engine default service account if you do not choose one). On GKE, Workload Identity Federation for GKE assigns distinct IAM identities to each application in the cluster. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | A container app can have a system-assigned managed identity (tied to the app) or user-assigned identities (standalone resources). On AKS, Microsoft Entra Workload ID uses a projected Kubernetes service account token and OIDC federation to give pods an Entra identity. (source) |
What it gets by default
| Agent platform | Cloud | What it gets by default |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | The documented service role policy covers invoking named foundation models, reading the OpenAPI schema objects in S3, and querying attached knowledge bases, with optional statements for guardrails, collaborators and code interpretation. The policy of the role the console creates automatically is not listed on that page: none found on 2026-11-10 for its exact contents. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | AWS documents that the console can create the execution role for you if the console role has the listed IAM create permissions, and that Gateway can create a service role and attach permissions each time you add a target. AWS warns that the BedrockAgentCoreFullAccess managed policy, for the person or application using AgentCore, grants broad permissions. The contents of the auto-created execution role: none found on 2026-11-10 in the pages read. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | With agent identity, an agent starts with the Agent Default Access role (basic project-wide logging and model calling) and the Agent Context Editor role (own sessions, memories and sandboxes only). With the default service agent, Google documents the Reasoning Engine Service Agent role. A custom service account likely needs Agent Platform User plus roles your code needs. Google notes that some features of these roles may be in Preview. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | Permissions Gemini Enterprise itself grants to a registered agent: none found on 2026-11-10. Registering an ADK agent requires the Gemini Enterprise Admin role for the person doing it; the agent's own Google Cloud access comes from Agent Runtime. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | Microsoft documents that a newly created agent identity starts without resource permissions and that Foundry does not automatically assign RBAC roles to it; you or an administrator grant access through the target service. For people, Microsoft names Foundry Agent Consumer as the least-privilege role for those who only interact with agents. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | When you create a function in the Lambda console, AWS documents that it creates an execution role with minimal permissions (basic logging to CloudWatch Logs). On EKS, if IMDS access is not restricted, a pod's containers can also reach the node IAM role. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | Google documents that, depending on organization policy, the Compute Engine default service account might automatically be granted the Editor role on the project, and that the constraint iam.automaticIamGrantsForDefaultServiceAccounts is enforced by default for organizations created after May 3, 2024. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | Microsoft documents that for some resources you must configure role assignments for the app's managed identity, otherwise calls to services such as Key Vault and SQL Database are rejected even with a valid token. A default role grant: none found on 2026-11-10. (source) |
Tools and actions
| Agent platform | Cloud | Tools and actions |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | Tools are action groups defined by an OpenAPI schema or function details, usually backed by a Lambda function. Bedrock invokes the function through a resource-based policy on the function; the function then runs under its own Lambda execution role. An action can instead return control to the calling application, which then runs the action itself. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | Gateway turns APIs, Lambda functions and existing services into tools reachable through Gateway endpoints. For each target, outbound authorization can use the gateway service role (SigV4), the caller's IAM credentials, OAuth (client credentials, authorization code, or token exchange), token passthrough, or an API key, so the identity of a tool call depends on which option the target uses. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | Agent code calls Google Cloud APIs through Application Default Credentials, which use the agent identity once IAM is configured. For external services, Google documents an auth manager that brokers 2-legged or 3-legged OAuth credentials. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | An agent that must reach Google Cloud resources for a user needs authorization details configured: an OAuth client, an authorization resource registered with Gemini Enterprise, and user consent. Other tool and action behavior sits in the Agent Runtime entry. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | For MCP and A2A tools, Agent Service passes a scoped agent identity token and the downstream resource checks the agent identity's RBAC role assignments. Tool connections can also use key-based access, the agent's or project's managed identity, or OAuth identity passthrough. OpenAPI tools support anonymous, API key or project managed identity authentication. With function calling, your own app executes the function. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | The agent code calls AWS APIs through an SDK, signing requests with the role's temporary credentials; every tool the code calls runs as that same role unless the code assumes another role. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | The agent code calls Google Cloud APIs as its service account or Kubernetes workload principal; Google documents using IAM policies to grant Kubernetes workloads access to specific Google Cloud APIs. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | Workloads on AKS need Entra application credentials or managed identities to reach Entra-protected resources such as Key Vault and Microsoft Graph; calls run as that identity. (source) |
The agent's permissions or the user's
| Agent platform | Cloud | The agent's permissions or the user's |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | none found on 2026-11-10 |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | Both are documented. Runtime can fetch OAuth tokens on behalf of end users when a user ID header or a JWT is supplied. Gateway outbound calls can use the caller's IAM credentials, a user-delegated authorization code grant, a token exchange that carries the user and agent identities, or the machine-to-machine client credentials grant that acts on the application's own behalf. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | Both are documented. Google describes three identities: the user, the agent (acting on its own authority), and a delegated identity when the agent acts for a user with scoped 3-legged OAuth. Calls to Google Cloud APIs with agent identity are evaluated against the agent identity. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | Both. ADK agents receive the user's email address from Gemini Enterprise, and an agent that must access Google Cloud resources on behalf of a user needs the authorization details configured. Agent-level access follows the Agent Runtime entry. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | Both are documented. Application-only access uses the agent's own authority; delegated access acts on behalf of the signed-in user, which needs both the agent's authorization and the user's access. Microsoft labels agent identity acting on behalf of the user as preview. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | The workload uses its own role credentials. Propagation of an end user's permissions to the workload: none found on 2026-11-10 in the Lambda and EKS pages read. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | The workload uses its own service account or workload identity. Propagation of an end user's permissions to the workload: none found on 2026-11-10 in the Cloud Run and GKE pages read. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | The workload uses its own managed or workload identity. Propagation of an end user's permissions to the workload: none found on 2026-11-10 in the Container Apps and AKS pages read. (source) |
Network reachability
| Agent platform | Cloud | Network reachability |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | AWS documents interface endpoints (AWS PrivateLink) for the bedrock-agent and bedrock-agent-runtime APIs, with an endpoint policy you can attach. AWS's VPC page lists model customization, batch inference and knowledge bases as the features it describes for VPC protection; egress controls for the agent's own orchestration: none found on 2026-11-10. Network egress of an action group Lambda function follows that function's own VPC settings. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | AWS documents VPC connectivity for Runtime and the built-in Code Interpreter and Browser tools: AgentCore creates network interfaces in your VPC through a service-linked role. A public subnet does not give internet access; AWS says internet access needs private subnets with a route to a NAT Gateway. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | Google documents that the agent runs in a Google-managed network without access to your VPC unless you configure a Private Service Connect interface, which gives private egress to your VPC and on-premises resources. With VPC Service Controls, a PSC interface is required for internet access, and the project must be in the perimeter before the agent is deployed or the agent keeps public internet access. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | Google documents that the connection between Agent Runtime and Gemini Enterprise is compliant with VPC Service Controls. Cross-project ADK agents connect over Google Cloud private networking. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | Microsoft documents a Standard Setup with private networking: no public egress and a delegated subnet from your virtual network. Private networking is available for prompt agents; hosted agents support bring-your-own virtual network, with each session in a VM-isolated sandbox connected to your VNet. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | AWS documents attaching a Lambda function to a VPC: private subnets for private resources, and a public subnet does not give a function internet access. Network controls for pods in EKS: none found on 2026-11-10 in the pages read. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | Cloud Run can send egress traffic to a VPC network with Direct VPC egress (recommended) or a VPC connector, giving access to resources with internal IP addresses. In GKE, by default all Pods in a cluster can communicate with each other until network policy is enforced. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | By default Container Apps is publicly accessible and can communicate only with internet-accessible endpoints; supplying your own virtual network adds control over outbound traffic and access to private endpoints. In AKS, all pods can send and receive traffic without limitations by default. (source) |
What is logged
| Agent platform | Cloud | What is logged |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | AWS | AWS documents that InvokeAgent and InvokeInlineAgent calls are logged to CloudTrail as data events, which you must enable with advanced event selectors for the AWS::Bedrock::AgentAlias resource type. Model invocation logging is off until you turn it on. The agent's step-by-step reasoning is available through traces. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AWS | AgentCore stores metrics, spans and logs in Amazon CloudWatch. AWS documents CloudTrail coverage for only some AgentCore capabilities (Gateway and Agent Registry are the ones named); CloudTrail coverage for Runtime API calls: none found on 2026-11-10 in the pages read. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Google Cloud | Agent stdout and stderr go to Cloud Logging under reasoning_engine_stdout and reasoning_engine_stderr. Google documents that agent identity shows up in logs across Google Cloud services, and for user-delegated flows logs show both the user and the agent. Cloud Logging is not supported for child resources such as Sessions and Memory Bank. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Google Cloud | Google documents Cloud Audit Logs for administrative and data-access operations on Gemini Enterprise (Vertex AI Agent Builder) resources, viewable in Logs Explorer, with an option to enable Data Access audit logs. Logging of what the agent does inside Google Cloud sits in the Agent Runtime entry. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure | Microsoft documents three sources: Entra sign-in logs (which agent identity obtained a token for which resource, including on behalf of which user), Entra audit logs (blueprint and agent identity creation and deletion), and Foundry tracing in the connected Application Insights resource for tool calls. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | AWS | CloudTrail records Lambda API calls with identity information on who made each request. By default CloudTrail does not log most data events. For EKS, control plane logging can send audit logs to CloudWatch Logs. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Google Cloud | Google documents Admin Activity audit logs that cannot be disabled, and Data Access audit logs that must be explicitly enabled to receive them. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure | Container Apps send console logs (from your app) and system logs (from the service) to Log Analytics. For AKS, the Azure Monitor activity log collects some data automatically and control plane logs are resource logs sent through a diagnostic setting. (source) |
Boundaries that apply
| Agent platform | Mechanism | How it applies |
|---|---|---|
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | IAM identity-based policy on the agent service role | The service role's policy is the main limit on what the agent itself can call. AWS shows statements scoped to specific model, knowledge base and prompt ARNs. (source) |
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | Trust policy conditions (aws:SourceAccount, aws:SourceArn) | AWS recommends condition keys in the role's trust policy so only agents in your account can use the role, and says to replace the wildcard with specific agent IDs once they exist. (source) |
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | Resource-based policy on the action group Lambda function | The function only accepts calls from Bedrock when its resource-based policy allows the bedrock.amazonaws.com principal, which AWS scopes to the account and agent ARN. (source) |
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | SCPs and permissions boundaries | AWS documents SCPs and permissions boundaries as limits on IAM entities in general, so they cap the permissions of the service role and of the Lambda execution role as well. (source) |
| Amazon Bedrock Agents (now Amazon Bedrock Agents Classic) | VPC endpoint policy | An endpoint policy on the bedrock-agent-runtime interface endpoint can limit which principals and actions use that private path. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | IAM policy on the execution role and gateway service role | AWS says the execution role is what Runtime assumes to run the agent, so its policy limits what agent code can call in your account. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | Resource-based policies on AgentCore resources | AWS documents resource-based policies to control access to runtime resources. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | SCPs and permissions boundaries | AWS lists permissions boundaries and SCPs among the policy types that apply to AgentCore IAM entities. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | IAM deny of InvokeAgentRuntimeForUser | Passing a user ID header to Runtime needs a separate IAM action, so you can deny that action where user ID delegation is not needed. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | AgentCore Policy at Gateway | AWS describes AgentCore Policy as intercepting every tool call at Gateway before execution, with rules for which tools agents can use and under what conditions. (source) |
| Amazon Bedrock AgentCore (Runtime, Gateway, Identity) | VPC security groups | When Runtime uses VPC connectivity, security groups on the network interfaces control reachable destinations. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | IAM allow policies on the agent identity | The agent's access to Google Cloud resources follows the roles you grant the agent identity. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | IAM deny policy | Google shows a deny policy that targets all agent identities in the organization to block actions such as deleting buckets. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Principal Access Boundary policy | Google documents a PAB policy that limits the resources an agent may access despite other permissions it might have. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Context-Aware Access (mTLS binding) | By default, agent identity credentials are bound by a Google-managed Context-Aware Access policy to the trusted runtime, which Google says makes stolen credentials un-replayable. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | VPC Service Controls | A service perimeter can limit data exfiltration, and the project must be in the perimeter before deploying the agent. (source) |
| Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder) | Organization policy for cross-project service accounts | Using a custom service account from another project requires that the iam.disableCrossProjectServiceAccountUsage organization policy is not enforced in the service account's project. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Gemini Enterprise IAM roles | Roles such as Gemini Enterprise Admin, Discovery Engine Editor and Viewer control who manages agents; users with the discoveryengine.agents.manage permission can view a private agent's details but not use it. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Agent sharing state | A private agent is meant for personal use and only its creator can chat with it. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | VPC Service Controls | The Agent Runtime connection is compatible with VPC-SC perimeters. (source) |
| Gemini Enterprise (agents hosted on Agent Runtime) | Agent Runtime IAM, deny, PAB | Limits on what the agent can call in Google Cloud are the Agent Runtime boundaries. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure RBAC on the agent identity | The downstream resource checks the agent identity's role assignments before granting or denying access. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Foundry RBAC roles and agent-scope assignments | Role assignments at the agent scope are currently evaluated only for agent endpoint access, so they limit who can call a specific agent, not what the agent can reach. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Azure Policy | Microsoft documents Azure Policy for auditing and governing Foundry resource state. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Virtual network isolation | The Standard Setup with private networking removes public egress and uses your delegated subnet. (source) |
| Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service) | Hosted agent sandbox | Each hosted-agent session runs in its own VM-isolated sandbox that holds no blueprint credential. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | IAM policy on the execution role or pod role | The role's permissions policy is the main limit on what the agent can do in the account. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | Pod Identity trust policy conditions | Session tags let the trust policy restrict which service accounts, namespaces and clusters can use the role. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | SCPs and permissions boundaries | AWS documents both as maximum-permission controls that apply to IAM entities. (source) |
| Self-hosted agent on AWS Lambda or Amazon EKS | IMDS restriction | With IMDS access restricted, a pod's containers can retrieve credentials only for the role tied to their service account. (source) |
| Self-hosted agent on Google Cloud Run or GKE | IAM roles on the service account | The roles granted to the service account decide what the agent can reach. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Organization policy iam.automaticIamGrantsForDefaultServiceAccounts | Google recommends enforcing this constraint to stop the automatic Editor grant on default service accounts. (source) |
| Self-hosted agent on Google Cloud Run or GKE | IAM deny policies | Deny policies set guardrails on access to Google Cloud resources regardless of allow policies. (source) |
| Self-hosted agent on Google Cloud Run or GKE | Principal Access Boundary policies | PAB policies define the resources a principal is eligible to access. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure RBAC role assignments | You use role-based access control to grant specific permissions to the managed identity. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Azure Policy | Azure Policy enforces organizational standards and assesses compliance at scale. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Deny assignments | A deny assignment attaches deny actions to a principal at a scope; Microsoft notes customer-managed deny assignments are in private preview. (source) |
| Self-hosted agent on Azure Container Apps or AKS | Kubernetes network policy on AKS | Network policies define rules for traffic between pods. (source) |
Cite this
Cite this
Cite this line: 'AI Agent Access Control, The Agent Access Map, edition 10 Nov 2026, https://aiagentaccesscontrol.com/datasets/'
Where Act is behind
Act draws the boundary at the access layer (cloud IAM and network controls, and the gateways or MCP servers in front of agents); it does not inspect prompts or model outputs, which needs a different tool. Your team applies the boundaries it proposes, and its customer evidence for AI boundaries is less mature than for its core access control.
Related pages
Sources
- docs.aws.amazon.com/bedrock/latest/userguide/agents.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/agents-classic-maintenance-mode.htm, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/agents-permissions.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/agents-lambda.html, read 10 Nov 2026
- docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/agents-how.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/vpc-interface-endpoints.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/usingVPC.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/logging-using-cloudtrail.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore., read 10 Nov 2026
- docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-permissions.html, read 10 Nov 2026
- docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-outbound-auth.html, read 10 Nov 2026
Last reviewed 16 Nov 2026.