---
title: How does Policy in Amazon Bedrock AgentCore control agent tool calls?
url: https://opencontroller.lyzr.com/blog/amazon-bedrock-agentcore-policy-explained
published: 2026-11-13
updated: 2026-11-13
author: Lyzr
---

# How does Policy in Amazon Bedrock AgentCore control agent tool calls?

**Policy in Amazon Bedrock AgentCore checks every tool call an agent makes through an AgentCore Gateway against rules written in Cedar. A call goes through only if a permit rule matches and no forbid rule matches; everything else is denied. The rules live outside the agent code, so security teams can change them without redeploying the agent.**

AWS made Policy generally available on 3 March 2026 in 13 Regions across the US, Asia Pacific and Europe. It answers a question buyers ask early: "Can AgentCore stop an agent from calling a tool it should not use?" The short answer is yes, for tools behind an AgentCore Gateway. This guide explains how it works, where it stops, and how it fits a wider [AI agent control plane](/blog/what-is-an-ai-agent-control-plane).

## How does AgentCore Policy work?

There are three parts:

1. **Policy engine.** A container for Cedar policies. You create it once and attach it to one or more Gateways.
2. **AgentCore Gateway.** The Gateway turns APIs, Lambda functions and MCP servers into tools. It sits between the agent and those tools, so it can intercept every `tools/call` request. See our explainer on [what AgentCore Gateway is](/blog/what-is-amazon-bedrock-agentcore-gateway).
3. **Cedar policies.** Each rule names a principal (who is calling), an action (which tool) and a resource (which Gateway), plus optional `when` conditions.

Evaluation follows Cedar semantics:

| Situation | Result |
|---|---|
| Any `forbid` policy matches | Denied, and no `permit` can override it |
| A `permit` matches and no `forbid` matches | Allowed |
| No policy matches | Denied by default |
| Policy engine has no policies | Everything denied |

Each Gateway tool becomes a Cedar action named `<TargetName>___<tool_name>`, with three underscores. The arguments of the tool call are exposed as `context.input`. That lets you write rules about values, not just tool names. For example, a refund tool can be allowed only when `context.input.amount < 500`.

## Who is the principal in an AgentCore policy?

It depends on how the Gateway authenticates inbound calls:

- **OAuth or JWT.** The principal comes from the token's `sub` claim. Other claims, such as role or department, become tags you can test with `principal.hasTag()` and `principal.getTag()`.
- **AWS IAM.** The principal holds the caller's IAM ARN.

This matters for delegated access. If the agent passes the end user's token, policies can depend on who the agent is acting for. If it uses a shared service identity, every call looks the same. Our guide to [on-behalf-of delegation for AI agents](/blog/ai-agent-identity-on-behalf-of-delegation) covers the identity side.

## How do you roll out AgentCore Policy safely?

Gateways support two enforcement modes: `LOG_ONLY` records the decision it would have made without blocking, and `ENFORCE` blocks. A sensible rollout:

1. **Inventory the tools** behind each Gateway and decide which agents need each one.
2. **Write permits first**, scoped to named tools and principals. Avoid broad wildcards.
3. **Add forbids** for actions that must never happen, such as deletes in production or payments above a limit.
4. **Attach in LOG_ONLY** and review decisions in Amazon CloudWatch for one or two release cycles.
5. **Fix false denials**, then switch the Gateway to ENFORCE.
6. **Keep policies in version control** and review changes like code.

You can also write a rule in plain language. AgentCore generates the Cedar and validates it against the Gateway's tool schema. Automated reasoning checks flag policies that allow everything or deny everything. Keep the default validation mode in production, so a policy with findings fails instead of loading.

In June 2026 AWS also added the option to reference Amazon Bedrock Guardrails from policy conditions. Check the current developer guide before relying on newer condition types.

## What does AgentCore Policy not cover?

Policy is a strong control for one traffic path. It does not cover:

- **Tool calls that bypass the Gateway.** An agent that calls an API or MCP server directly is never evaluated.
- **Model calls.** Policy governs agent-to-tool traffic, not which model the agent uses or what it costs.
- **Agents on other platforms.** Copilot Studio, Agentforce, Vertex AI or a LangGraph service on Kubernetes need their own controls.
- **Discovery.** Policy does not tell you which agents exist across your AWS accounts, or which ones skip the Gateway.
- **Behaviour over time.** A policy decides one call at a time. Spotting an agent that drifts from its normal pattern needs monitoring.

That is why most enterprises use platform-native policy and a cross-platform layer together. Our [guide to governing agents across platforms](/blog/how-to-govern-ai-agents-across-platforms) shows how the two fit.

## How Opencontroller does this

Opencontroller has a runtime adapter for Bedrock AgentCore and auto-discovers agents, models and API keys across AWS, Azure and Google Cloud. It keeps a governed registry of agents, versions, tools and MCP servers, so you can see which AgentCore agents use which tools. Policy as code in Opencontroller applies across the estate, with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001. Behavioural-deviation monitoring can alert on, quarantine or kill a rogue agent. Use Cedar at the Gateway for per-call decisions, and Opencontroller for estate-wide policy and evidence. [Book a demo](https://www.lyzr.ai/book-demo/) to see it on your accounts.

## Frequently asked questions

**Is Policy in Amazon Bedrock AgentCore generally available?**
Yes. AWS announced general availability on 3 March 2026 in 13 Regions.

**Can AgentCore Policy check tool arguments, not just tool names?**
Yes. Tool-call arguments are available as `context.input`, so a rule can allow a tool only when, for example, an amount is under a limit.

**Does AgentCore Policy replace a cross-platform control plane?**
No. It governs tool calls through AgentCore Gateways. Agents on other platforms, model traffic and discovery need other controls.

## Key facts

Policy in Amazon Bedrock AgentCore became generally available on 3 March 2026 in 13 AWS Regions. Policies are written in Cedar (or in natural language that AgentCore converts to Cedar), stored in a policy engine and attached to an AgentCore Gateway, which checks every agent-to-tool request before allowing or denying it. Evaluation is default deny: a request passes only if a permit matches and no forbid matches; an empty policy engine denies everything. Each Gateway tool becomes a Cedar action named Target___tool. Tool-call arguments are available as context.input, and JWT claims become principal tags. Gateways support LOG_ONLY and ENFORCE modes. Policy covers only tool calls that pass through an AgentCore Gateway. Opencontroller by Lyzr has a runtime adapter for Bedrock AgentCore and applies policy as code across agent platforms; pricing starts from $250K per deployment per year.

## Related

- [How do you govern AI agents built on Amazon Bedrock AgentCore?](https://opencontroller.lyzr.com/blog/govern-amazon-bedrock-agentcore-agents.md)
- [What is Amazon Bedrock AgentCore Gateway and how do you govern it?](https://opencontroller.lyzr.com/blog/what-is-amazon-bedrock-agentcore-gateway.md)
- [How do you limit which tools each AI agent can call?](https://opencontroller.lyzr.com/blog/limit-which-tools-each-ai-agent-can-call.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
