Skip to content
AI Agent Access Control

The Agent Boundary Checklist: 30 checks before an agent goes to production

The Agent Boundary Checklist has 30 checks in seven sections: identity, permissions, data, network, tools, change control and logging. Each check says why it matters and gives the AWS, Google Cloud and Azure way to do it, with a documentation quote, so an approval meeting can mark each one done or open.

Download the checklist ยท The map

Use it as the agenda of the approval meeting. Take the sections in order and ask the engineer to show the answer for each check in the cloud the agent runs in: the role, the ceiling policy, the endpoint, the log query. A check with no evidence is open. A check the cloud has no documented answer for is marked none found on 2026-11-10, and the meeting decides whether to accept the risk.

The checks are about the cloud boundary around the agent, not about what the model says. Prompt and output filtering is a different job for a different tool, and this list does not cover it. Count the open checks at the end, record who owns each, and approve the agent only when the identity, permissions and logging sections are closed.

Identity

An agent should run as one identity of its own, with short-lived credentials and no long-lived keys. The checks cover a separate role or service account per agent, who may pass or attach that role, trust that names the specific workload, and avoiding default or pre-granted accounts. If two agents share an identity, one agent's access is every agent's access, and the logs cannot say which one acted.

  1. Give each agent its own role or service account, not a shared one. A shared identity means one agent's access is every agent's access, and logs cannot say which agent acted. A separate identity lets you grant, review and revoke access agent by agent.
  2. Use short-lived role credentials and no long-lived access keys for the agent. A key stored in code, a config file or a container image stays valid until someone rotates it, so a leak gives an attacker lasting access. Temporary credentials from a role expire on their own.
  3. Limit who can pass, attach or impersonate the agent's role. Anyone who can attach the agent's role to a new resource can borrow its access without ever being granted it. Limiting that right keeps the agent's permissions from spreading.
  4. Scope the role's trust to the specific agent, service account or workload. A role that any workload in an account or cluster can assume is a role every compromised workload can use. Tying trust to one agent keeps a break-in elsewhere from reaching it.
  5. Do not run the agent as a default or pre-granted account. Default accounts are created for convenience and can carry broad roles that nobody chose for the agent. An agent that inherits one gets access no one reviewed.

Permissions

These checks decide how much the identity can do. Write the policy from what the tools actually call, set an organization-level ceiling the role cannot exceed, and deny IAM changes and destructive actions outright. Then compare what was granted with what was used, and grant at the narrowest scope that works. The ceiling matters most, because it still holds when someone later widens the agent's own policy by mistake.

  1. Write the agent's permission policy from what its tools actually call. Broad starter policies make every tool call possible, including ones nobody planned. A policy limited to the real calls limits what a wrong or hijacked call can do.
  2. Set an organization-level ceiling the agent's role cannot exceed. A role policy can be edited by whoever manages that account, so it is a weak limit by itself. A ceiling set higher in the hierarchy holds even if the role's own policy is widened.
  3. Explicitly deny the agent IAM changes and destructive actions. An agent that can edit roles or delete data can widen its own access or cause damage no review would have approved. An explicit deny wins over any allow added later by mistake.
  4. Compare the agent's granted permissions with what it used and remove the rest. Permissions granted during a pilot tend to stay long after the agent stops using them. Each unused permission is access an attacker could use for nothing the agent needs.
  5. Grant roles at the narrowest scope that works. A role granted on a whole account, project or subscription covers every resource in it, including ones created later. Granting on specific resources keeps new resources out of the agent's reach by default.

Data

An agent is only as dangerous as the data it can read and move. These checks keep encryption keys under your control, block public access on storage the agent writes to, put the data stores inside a perimeter that stops copying data out, and limit access with tags or conditions instead of resource lists alone. Run them against the stores the agent's tools touch, not against every store in the account.

  1. Keep the encryption keys for agent data under your control and limit who can use them. If the agent's role can use a key, it can read whatever that key protects. Customer-managed keys let you cut off access by changing the key policy or disabling the key.
  2. Block public access on storage the agent can write to. An agent that can change a bucket setting, or write to a bucket that already allows public reads, can expose data by accident. Account-level public access blocks stop that even when a policy says otherwise.
  3. Put data stores the agent reads inside a perimeter that blocks copying data out. An agent allowed to read data can usually also send it somewhere else unless something stops the transfer. A perimeter turns an allowed read into a read that cannot leave.
  4. Limit data access with tags, attributes or conditions, not only resource lists. Resource lists go stale as new data stores appear. Conditions on tags or attributes keep access tied to what the data is, so a new store does not become reachable by default.

Network

The network decides where the agent's traffic can go and what can call it. The checks run agent compute on private networks with no direct path to the internet, allow outbound traffic only to needed destinations, reach cloud APIs through private endpoints, and keep agent code from reading node or instance credentials. Defaults differ by cloud: Container Apps is public by default, AKS pods are open by default, and a Foundry Standard Setup removes public egress.

  1. Run agent compute on private networks with no direct path to the internet. Compute with a direct internet path can send data out or pull in instructions from anywhere. A private network makes every outside path an explicit choice.
  2. Allow outbound traffic only to the destinations the agent needs. Open outbound access lets a hijacked agent reach any server to send data or fetch tools. A short allow list makes unexpected destinations fail and show up in logs.
  3. Reach cloud APIs and data stores through private endpoints. Calls to cloud services over public addresses can be made from anywhere that holds valid credentials. Private endpoints keep the path inside your network, so stolen credentials are harder to use from outside.
  4. Keep the agent's code from reading node, instance or other workloads' credentials. If agent code can read the host's metadata service, it can take the host's credentials, which are often broader than the agent's own. Isolating credentials keeps one compromised agent from becoming a compromised node.

Tools

A tool is where an agent's words become actions. These checks give each tool function its own least-privilege role, restrict which principals can invoke each tool endpoint, cap how much the agent can run and spend, and decide for every tool whether the action runs with the agent's authority or the signed-in user's. That last decision is the one reviewers most often find undocumented, so ask for it per tool.

  1. Give each tool function its own least-privilege role instead of the agent's role. A tool that runs with the agent's full role can do everything the agent can, even if the tool needs one action. A narrow role per tool limits damage when one tool is abused or buggy.
  2. Restrict which principals can invoke each tool endpoint. A tool endpoint that accepts calls from any caller can be used without the agent. Limiting invokers means only the intended agent can trigger the action.
  3. Cap how much the agent can run and spend. A looping or hijacked agent can start thousands of runs and a large bill before anyone notices. Limits on concurrency and budget alerts shrink the damage window.
  4. Decide for each tool whether the action runs with the agent's authority or the signed-in user's. If a tool runs with the agent's authority, every user can reach whatever the agent can reach. If it runs with the user's authority, the agent can only do what that user may.

Change control

These checks keep the boundary in place after launch. Run agents in their own account, project or subscription, tag every agent resource with an owner and environment and enforce the tags, test permission and policy changes in a dry run before enforcing them, and remove the agent's identity and access when the agent is retired. For AWS the retirement step has no documented answer: none found on 2026-11-10.

  1. Run agents in their own account, project or subscription. Agents placed beside production workloads share their blast radius, quotas and admin rights. A dedicated container lets you apply stricter policy and limits and remove it cleanly.
  2. Tag every agent resource with an owner and environment, and enforce the tags. Untagged agent resources cannot be traced to an owner when something goes wrong. Tags also let policy and cost controls target agent resources specifically.
  3. Test permission and policy changes in a dry run before enforcing them. A new deny or boundary can break an agent's tools in ways nobody saw coming, and a mistaken allow can open access without anyone noticing. Testing first shows the effect before it reaches production.
  4. Remove the agent's identity and access when the agent is retired. Leftover identities from retired agents keep their permissions and nobody is watching them. Tying the identity to the agent's lifecycle removes the access with the agent.

Logging

If an incident happens, the logs must show which agent did what. The checks turn on organization-wide audit logging of control-plane actions, log reads and writes to the data the agent touches, make every logged action traceable to one agent identity, and alert on denied calls and on changes to the agent's role or policies. Data events and resource logs are off by default in all three clouds until you enable them.

  1. Turn on organization-wide audit logging of control-plane actions. Without audit logs there is no record of which role or setting the agent changed, or who changed the agent's access. A log kept outside the agent's reach is the base for every investigation.
  2. Log reads and writes to the data the agent touches. Control-plane logs show configuration changes, not which records the agent read. Data-level logs are what show whether the agent touched something it should not have.
  3. Make every logged action traceable to the specific agent identity. If logs only show a shared role or a generic account, you cannot tell which agent did what. Per-agent attribution turns a log line into a decision about one agent.
  4. Alert on denied calls and on changes to the agent's role or policies. A string of denied calls or an edit to the agent's role is often the first visible sign of misuse. Without an alert, these show up only after the damage.

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.

Sources

  1. docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html, read 10 Nov 2026
  2. docs.aws.amazon.com/eks/latest/userguide/pod-identities.html, read 10 Nov 2026
  3. cloud.google.com/iam/docs/best-practices-service-accounts, read 10 Nov 2026
  4. docs.cloud.google.com/gemini-enterprise-agent-platform/scale/runtime/agent-ident, read 10 Nov 2026
  5. learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/agent-identity, read 10 Nov 2026
  6. learn.microsoft.com/en-us/azure/container-apps/managed-identity, read 10 Nov 2026
  7. docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html, read 10 Nov 2026
  8. cloud.google.com/iam/docs/workload-identity-federation, read 10 Nov 2026
  9. learn.microsoft.com/en-us/entra/identity/managed-identities-azure-resources/over, read 10 Nov 2026
  10. docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html, read 10 Nov 2026
  11. cloud.google.com/iam/docs/service-account-permissions, read 10 Nov 2026
  12. docs.aws.amazon.com/eks/latest/userguide/pod-id-role.html, read 10 Nov 2026

Last reviewed 16 Nov 2026.