{
 "name": "The Agent Access Map",
 "edition": "2026-11-10",
 "read_date": "2026-11-10",
 "source": "https://aiagentaccesscontrol.com/datasets/",
 "license": "CC BY 4.0",
 "cite": "Cite this line: 'AI Agent Access Control, The Agent Access Map, edition 10 Nov 2026, https://aiagentaccesscontrol.com/datasets/'",
 "description": "8 agent platforms: the identity each runs as, default permissions, tools, network, logging and the boundaries that apply, each with its source.",
 "rows": [
  {
   "key": "bedrock-agents",
   "platform": "Amazon Bedrock Agents (now Amazon Bedrock Agents Classic)",
   "cloud": "AWS",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "none found on 2026-11-10",
   "network": "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.",
   "logging": "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.",
   "boundaries": "IAM identity-based policy on the agent service role; Trust policy conditions (aws:SourceAccount, aws:SourceArn); Resource-based policy on the action group Lambda function; SCPs and permissions boundaries; VPC endpoint policy",
   "docs_url": "https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html",
   "read_date": "2026-11-10"
  },
  {
   "key": "bedrock-agentcore",
   "platform": "Amazon Bedrock AgentCore (Runtime, Gateway, Identity)",
   "cloud": "AWS",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "IAM policy on the execution role and gateway service role; Resource-based policies on AgentCore resources; SCPs and permissions boundaries; IAM deny of InvokeAgentRuntimeForUser; AgentCore Policy at Gateway; VPC security groups",
   "docs_url": "https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html",
   "read_date": "2026-11-10"
  },
  {
   "key": "agent-runtime-gcp",
   "platform": "Agent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine, Agent Builder)",
   "cloud": "Google Cloud",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "IAM allow policies on the agent identity; IAM deny policy; Principal Access Boundary policy; Context-Aware Access (mTLS binding); VPC Service Controls; Organization policy for cross-project service accounts",
   "docs_url": "https://docs.cloud.google.com/gemini-enterprise-agent-platform/scale/runtime/agent-identity",
   "read_date": "2026-11-10"
  },
  {
   "key": "gemini-enterprise",
   "platform": "Gemini Enterprise (agents hosted on Agent Runtime)",
   "cloud": "Google Cloud",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "Gemini Enterprise IAM roles; Agent sharing state; VPC Service Controls; Agent Runtime IAM, deny, PAB",
   "docs_url": "https://cloud.google.com/gemini/enterprise/docs/register-and-manage-an-adk-agent",
   "read_date": "2026-11-10"
  },
  {
   "key": "foundry-agent-service",
   "platform": "Microsoft Foundry Agent Service (formerly Azure AI Foundry Agent Service)",
   "cloud": "Azure",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "Azure RBAC on the agent identity; Foundry RBAC roles and agent-scope assignments; Azure Policy; Virtual network isolation; Hosted agent sandbox",
   "docs_url": "https://learn.microsoft.com/en-us/azure/ai-foundry/agents/overview",
   "read_date": "2026-11-10"
  },
  {
   "key": "self-hosted-aws",
   "platform": "Self-hosted agent on AWS Lambda or Amazon EKS",
   "cloud": "AWS",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "IAM policy on the execution role or pod role; Pod Identity trust policy conditions; SCPs and permissions boundaries; IMDS restriction",
   "docs_url": "https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html",
   "read_date": "2026-11-10"
  },
  {
   "key": "self-hosted-gcp",
   "platform": "Self-hosted agent on Google Cloud Run or GKE",
   "cloud": "Google Cloud",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "Google documents Admin Activity audit logs that cannot be disabled, and Data Access audit logs that must be explicitly enabled to receive them.",
   "boundaries": "IAM roles on the service account; Organization policy iam.automaticIamGrantsForDefaultServiceAccounts; IAM deny policies; Principal Access Boundary policies",
   "docs_url": "https://cloud.google.com/run/docs/securing/service-identity",
   "read_date": "2026-11-10"
  },
  {
   "key": "self-hosted-azure",
   "platform": "Self-hosted agent on Azure Container Apps or AKS",
   "cloud": "Azure",
   "identity": "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.",
   "default_permissions": "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.",
   "tools_and_actions": "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.",
   "user_vs_agent": "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.",
   "network": "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.",
   "logging": "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.",
   "boundaries": "Azure RBAC role assignments; Azure Policy; Deny assignments; Kubernetes network policy on AKS",
   "docs_url": "https://learn.microsoft.com/en-us/azure/container-apps/managed-identity",
   "read_date": "2026-11-10"
  }
 ]
}