
Effective Authority for AI Agents: Mapping IAM, Tools, and Blast Radius in AWS
AI agent security is not just about what permissions an agent has, but what outcomes it can achieve through its combined access to tools, roles, delegated services, and external systems. The article introduces the concept of Effective Authority and explains why traditional IAM reviews often miss hidden escalation and data-exfiltration paths. It also provides practical AWS-based approaches to map, constrain, and monitor agent authority using IAM, Access Analyzer, SCPs,, and runtime guardrails.
Why “what the agent is allowed to do” and “what the agent can actually reach” are two different questions.
A familiar pattern is starting to repeat in teams that put agents into production on AWS.
The role attached to the agent looks tight. The tool list was reviewed. The system prompt says what the agent must never do. On paper, everything says the agent is well contained.
Then something unexpected happens: a call to a service nobody planned for, a record updated that the agent was never meant to touch, a message sent to a channel outside the workflow. The CloudTrail record shows every call was technically permitted.
Nothing was bypassed. The permissions were simply broader than the paper said.
Several publicly reported incidents this year follow the same shape at a larger scale. An agent meets a blocked path, looks for another one, and finds it through something it was legitimately allowed to use. You do not need a frontier lab’s sandbox for this to matter. You need an IAM role, a few tools, and a goal.
Two questions that are easy to confuse
Declared authority is what you wrote down: the role policy, the tool allowlist, the prompt, the design document.
Effective authority is what the agent can cause to happen once everything it holds is combined. That includes the actions its credentials permit, the tools it can call and what those tools really do, the roles it can assume, the functions and agents it can invoke, and the credentials it can reach indirectly.
IAM can answer part of that question. Tools and delegation answer the rest. The gap between the two is where most surprises live.
Four ways the gap opens
1. Permission paths
Individual permissions can look harmless while a combination is not. The classic example is
iam:PassRole together with lambda:CreateFunction and lambda:InvokeFunction . Together they let a principal run code under a role more powerful than its own.No single statement in the policy looks alarming. The path through them is the risk, and no one reading the policy line by line will see it.
2. Composed capabilities
Consider an agent that can read from a sensitive S3 prefix and also has a “send message” tool wired to Slack or email. Neither capability is dangerous alone. Together they form a data egress path that no IAM policy describes, because the second half of the path lives outside AWS.
The same applies to a tool that accepts a free-form query or command. The IAM role defines what the tool’s backend can do, and the prompt decides what the tool is asked to do. Nobody has reviewed that combination.
3. Delegation chains
When an agent invokes a Lambda function, the function runs with its own execution role. When an agent calls another agent, the callee uses whatever that agent holds. When roles are chained with
sts:AssumeRole , each hop can widen the reachable set.If your agent can invoke a function, its effective authority includes whatever that function’s role can do. That is the confused deputy problem, applied to agents.
4. Ambient credentials
Agents increasingly run code-execution tools. If that tool runs on compute with an instance profile or task role, and the metadata endpoint is reachable, the agent may be able to pick up credentials nobody intended to give it. IMDSv2 with a hop limit of 1 closes the common container path, but only if someone checked.
Tokens for GitHub, Slack, or a SaaS API sit entirely outside IAM. They belong in the same inventory.
A worked example: the invoice-triage agent
Suppose we build an agent that reads invoice PDFs from an S3 prefix, writes summaries to a DynamoDB table, and calls a few helper functions for parsing. The role policy looks like this:
json
{ "Version": "2012-10-17", "Statement": [ { "Sid": "ReadInvoices", "Effect": "Allow", "Action": ["s3:GetObject"], "Resource": "arn:aws:s3:::acme-invoices/inbox/*" }, { "Sid": "WriteSummaries", "Effect": "Allow", "Action": ["dynamodb:PutItem"], "Resource": "arn:aws:dynamodb:eu-central-1:111122223333:table/invoice-summaries" }, { "Sid": "RunHelpers", "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "*" } ]}Two statements are narrowly scoped. The third is the common shortcut: “it needs to call helpers, so allow invocation.”
With
Resource: "*" , the agent can invoke every function in the account. That includes the one that rotates credentials and the one with administrative access to the data warehouse. The agent’s declared job is invoice triage. Its effective authority includes everything those functions can do.The fix is boring and effective:
json
{ "Sid": "RunHelpers", "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:eu-central-1:111122223333:function:invoice-helper-*"}Now add a
send_email tool to the agent. The role policy has not changed, but the effective authority has: the agent can now move invoice contents to any address the tool accepts. That path shows up in no IAM review, because it lives in the tool.Mapping effective authority in practice
You do not need a new platform to start. AWS already gives you most of the raw material.
1. Inventory what the agent holds. List the roles it uses, the roles it can assume, the tools it can call, and every non-AWS token in its environment. Include the credentials a code-execution tool can reach.
2. Compare granted access with used access. IAM Access Analyzer’s unused access findings show permissions that were granted but never exercised. Policy generation from CloudTrail activity can produce a tighter policy based on what the agent actually did. Run a representative workload, then compare.
3. Check for dangerous actions in CI. Access Analyzer’s custom policy checks (such as
CheckAccessNotGranted and CheckNoNewAccess ) let you fail a pipeline if an agent role gains an action like iam:PassRole or sts:AssumeRole that nobody approved.4. Trace reachability, not just grants. For each role the agent can assume, read the trust policy and ask what that role can do. For each function it can invoke, read the execution role. For each resource it can touch, check the resource-based policy. Effective authority is the transitive closure of those steps.
5. Put guardrails outside the agent’s reach. Service control policies (SCPs) set the maximum for member accounts. They never grant access, they do not apply to the management account, and an agent role cannot edit them. For example:
json
{ "Version": "2012-10-17", "Statement": [ { "Sid": "AgentRolesCannotMintCredentials", "Effect": "Deny", "Action": [ "iam:CreateUser", "iam:CreateAccessKey", "iam:CreateRole", "iam:AttachRolePolicy", "iam:PutRolePolicy" ], "Resource": "*", "Condition": { "ArnLike": { "aws:PrincipalArn": "arn:aws:iam::*:role/agent-*" } } } ]}Permission boundaries and per-task session policies narrow the set further. Resource control policies (RCPs) do the same from the resource side.
6. Make every action attributable. Give each agent task its own role session name. Pass
SourceIdentity and session tags such as the task ID and the human the agent is acting for. Then CloudTrail answers “which task, on whose behalf” instead of just “which role.” Remember that data events, including S3 object-level activity and Lambda invocations, must be enabled explicitly.7. Read the denials. A burst of
AccessDenied or UnauthorizedOperation events from an agent session is a signal. It often means the agent is probing for another route to the same goal.8. Rehearse the blocked path. In a sandbox account, deliberately deny a permission the agent needs and observe the behavior. Does it stop and ask? Does it retry? Does it look for another tool? The answer tells you more about effective authority than any policy review.
What AWS-native analysis will not tell you
IAM tooling is excellent at what it covers, but three areas sit outside it.
- Tool semantics. IAM can tell you what a tool’s backend role may do. It cannot tell you what the tool does with free-form input, or what an MCP server does on the agent’s behalf.
- Non-AWS credentials and channels. Email, chat, ticketing systems, and SaaS APIs carry their own authority and their own egress paths.
- Intent at runtime. A policy is static, while an agent decides, call by call, how to use what it has. Controls that only exist at design time cannot see that decision.
Managed platforms such as Amazon Bedrock AgentCore add agent identity and gateway-level controls, which helps with some of this. The same inventory discipline still applies to whatever those controls sit in front of.
Questions to ask before an agent ships
- If this agent’s task is blocked, what is the next-easiest route to the same outcome?
- Which roles can it assume, and what can each of them do?
- Which functions and other agents can it invoke, and under whose credentials do they run?
- Which tool, combined with which data it can read, creates a path out of the account?
- Which actions need a human decision, and is that enforced outside the prompt?
- Can we reconstruct, from logs alone, what the agent did for a given task and on whose behalf?
An agent’s permissions are a starting point for understanding its authority, not the answer. The teams that avoid surprises treat authority as something to map, test, and monitor, not something to declare once.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article