Technical Guide

    Enforcing tool-call policy in Amazon Bedrock Agents action groups

    No single layer in a Bedrock Agents action group does everything. The schema defines the tool surface, IAM limits which identities can reach an executor, and a Lambda function or application handler can validate the parameters it receives. Only a layer that sees the tool name, the parameters and the caller at the moment of invocation can allow, redact, block, rate limit or escalate one call. Only a layer that retains each decision produces evidence an auditor can use.

    Choosing an enforcement placement

    • Does the layer see tool name, parameter values and caller identity for each call?
    • Can it block, redact, rate limit or pause for approval before execution, not only record afterwards?
    • Is the decision made outside the model's reasoning path, with no alternative route to the tool?
    • Does it cover both Lambda-executed and return-of-control action groups with one rule set?
    • Is there a durable per-call record of the call, decision, approver and outcome, with defined retention?
    • Have you measured the added latency and the failure behavior if the policy layer is unavailable?

    The unit of enforcement is the single tool call

    In an action group, the model chooses the tool and its parameters at runtime. That makes each invocation the point where an agent's intent becomes a business action, and it is the level at which policy has to be evaluated. NIST's published thinking on agent identity takes the same view: an individual tool invocation, API call or resource access should be verified at runtime against current state, context and risk, rather than trusting the session as a whole.

    Three questions describe what a security engineer needs from any control. Which tool is allowed? Which parameter values are acceptable for this caller and this moment? When does a person need to approve? A control that cannot answer these for one call is still useful, but it is a constraint on the surrounding system, not a policy decision about the call.

    Mapping the invocation path

    An action group exposes business tools through an OpenAPI schema or function definitions. When the agent decides to use a tool, the call is executed either by a Lambda function or by the calling application through return of control. Each hop in that path is a candidate enforcement point, and each has a different view of the call.

    The schema sits before execution and describes what can be requested. IAM and resource-based policies sit around the executor and describe who can invoke it. The Lambda function is the first place that sees concrete parameter values together with business logic. With return of control, the same decision moves to the application, which can inspect the request, ask a user and then execute. An external policy layer placed in the execution path sees the call regardless of which executor handles it, provided the call is routed through it.

    The practical difference between these points is what they can do with a call. Some can only shape what is possible. Others can refuse, modify or pause a specific request.

    What each enforcement point can and cannot do

    The rows below describe each point by the decisions it can make on a single tool call, where it stops, and the evidence it is likely to leave.

    • Action group schema: Can: define which tools and parameters exist and their types. Cannot: judge whether a well-formed value is acceptable for a given caller, rate limit calls, or escalate. Evidence: a versioned statement of what the agent could call, not of what it did.
    • IAM and resource policies: Can: restrict which principals invoke an executor and which resources it can touch. Cannot: evaluate parameter values the model chose, or redact content. Evidence: identity-level access records at most, with no decision rationale.
    • Lambda executor: Can: validate inputs and apply business rules in code, then refuse the call. Cannot: govern other executors, and rules are duplicated per function and change with each deployment. Evidence: whatever the function writes, so consistency depends on the code.
    • Return of control: Can: pass the request to the application, which may apply any check, ask a user, then execute. Cannot: enforce anything on its own. Every application must implement the checks. Evidence: the application's own records.
    • External policy layer in the path: Can: allow, redact, block, rate limit or escalate each call before execution, using one rule set. Cannot: cover calls that bypass it, and it adds a decision step to each call. Evidence: a decision record per call, if retained.

    Deciding versus recording, and why placement matters

    A useful test for every layer is whether it decides or only records. Evidence supports governance, but it does not authorize an action. A runtime governance model should evaluate current authority and applicable policy before the action happens, not reconstruct it afterwards. Logs written after execution are necessary, yet they cannot block a call that has already run.

    Placement also determines whether policy depends on the model. NIST's agent identity tenets include the separation of policy from reasoning, which in practice means the decision about a call should not be something the model can talk its way around. Prompt injection can arrive inside an otherwise valid API call, so a call that passes identity checks may still be unwanted. Parameter-level and context-level rules are what catch it.

    Bypass paths deserve the same scrutiny. A published vulnerability in Amazon Bedrock AgentCore, a different product from Bedrock Agents, describes crafted content blocks that could execute configured tools while skipping model invocation and security controls. It does not apply to action groups, but it illustrates why enforcement should sit where every route to a tool converges, and why input validation on any tool-executing component is security-critical.

    There are trade-offs. Per-function validation is simple and close to the data, but it fragments policy. Return of control keeps decisions in the application, which suits human approval flows but multiplies implementation effort. A single external policy layer centralizes rules and evidence, at the cost of an additional component in the path whose latency and availability need measuring against your own workload.

    Evidence an auditor can use

    Regulated teams are asked to show what an agent was allowed to do and what it did. That requires per-call records of the tool, the parameters, the policy decision and the outcome. Guidance presented at NIST workshops names tool calls, authorization decisions and agent decision traces as the relevant evidence, and an AWS incident-response presentation notes that customers often lack this AI-specific trail.

    For each enforcement point, map the evidence source to a retention period and an owner, as general log management guidance recommends. Then check for gaps. A schema shows intent, not behavior. Identity records show who invoked an executor, not why a parameter value was acceptable. Function logs vary with the code that writes them. For escalations, the record should also show who approved a call and when, which is easy to lose if approval happens in a separate workflow.

    Trussed is one placement option. It enforces policy in the execution path on individual interactions and tool calls, with actions that include allow, redact, block, rate limit and escalate for human approval. Enforcement is at runtime, not reviewed after the fact. The decisions generate audit-ready evidence mapped to frameworks including HIPAA, NAIC, NYDFS, the EU AI Act and NIST, and it can be self-managed in the customer cloud with configurable retention and data residency. It does not trace whole agentic workflows or govern business transactions across tasks.

    Enforcement points in an action group invocation path

    Schema definition

    Declares which tools and parameters exist

    IAM and resource policy

    Limits which identities reach an executor

    Lambda executor

    Validates inputs in function code

    Return of control

    Hands the call to the application to decide

    External policy layer

    Decides per call in the execution path

    See what per-call enforcement and evidence look like

    Review how policy is enforced on individual tool calls in the execution path and how each decision becomes audit-ready evidence.

    See How Evidence Is Produced