policies

Creates, updates, deletes, gets or lists a policies resource.

Overview

Name	`policies`
Type	Resource
Id	`aws.bedrock_agentcore_control.policies`

Fields

The following fields are returned by SELECT queries:

get_policy
list_policies

Name	Datatype	Description
`name`	`string`	The customer-assigned name of the policy. This is the human-readable identifier that was specified when the policy was created. (pattern: <code>[A-Za-z][A-Za-z0-9_]*</code>)
`created_at`	`string (date-time)`	The timestamp when the policy was originally created.
`definition`	`object`	Represents the definition structure for policies within the AgentCore Policy system. This structure encapsulates different policy formats and languages that can be used to define access control rules.
`description`	`string`	The human-readable description of the policy's purpose and functionality. This helps administrators understand and manage the policy.
`enforcement_mode`	`string`	The enforcement mode for a policy. Run this policy in LOG_ONLY mode to collect data on how it affects your application. Once you are satisfied with the data gathered, switch the policy to ACTIVE. (ACTIVE, LOG_ONLY)
`policy_arn`	`string`	The Amazon Resource Name (ARN) of the policy. This globally unique identifier can be used for cross-service references and IAM policy statements. (pattern: <code>arn:aws[-a-z]{0,7}:bedrock-agentcore:[a-z0-9-]{9,15}:[0-9]{12}:policy-engine/[a-zA-Z][a-zA-Z0-9-]{0,47}-[a-zA-Z0-9]{10}/policy/[a-zA-Z][a-zA-Z0-9-]{0,47}-[a-zA-Z0-9]{10}</code>)
`policy_engine_id`	`string`	The identifier of the policy engine that manages this policy. This confirms the policy engine context for the retrieved policy. (pattern: <code>[A-Za-z][A-Za-z0-9_]*-[a-z0-9_]{10}</code>)
`policy_id`	`string`	The unique identifier of the retrieved policy. This matches the policy ID provided in the request and serves as the system identifier for the policy. (pattern: <code>[A-Za-z][A-Za-z0-9_]*-[a-z0-9_]{10}</code>)
`status`	`string`	The current status of the policy. (CREATING, ACTIVE, UPDATING, DELETING, CREATE_FAILED, UPDATE_FAILED, DELETE_FAILED)
`status_reasons`	`array`	Additional information about the policy status. This provides details about any failures or the current state of the policy.
`updated_at`	`string (date-time)`	The timestamp when the policy was last modified. This tracks the most recent changes to the policy configuration.

Name	Datatype	Description
`name`	`string`	The customer-assigned immutable name for the policy. This human-readable identifier must be unique within the account and cannot exceed 48 characters. (pattern: <code>[A-Za-z][A-Za-z0-9_]*</code>)
`created_at`	`string (date-time)`	The timestamp when the policy was originally created. This is automatically set by the service and used for auditing and lifecycle management.
`definition`	`object`	Represents the definition structure for policies within the AgentCore Policy system. This structure encapsulates different policy formats and languages that can be used to define access control rules.
`description`	`string`	A human-readable description of the policy's purpose and functionality. Limited to 4,096 characters, this helps administrators understand and manage the policy.
`enforcement_mode`	`string`	The enforcement mode for a policy. Run this policy in LOG_ONLY mode to collect data on how it affects your application. Once you are satisfied with the data gathered, switch the policy to ACTIVE. (ACTIVE, LOG_ONLY)
`policy_arn`	`string`	The Amazon Resource Name (ARN) of the policy. This globally unique identifier can be used for cross-service references and IAM policy statements. (pattern: <code>arn:aws[-a-z]{0,7}:bedrock-agentcore:[a-z0-9-]{9,15}:[0-9]{12}:policy-engine/[a-zA-Z][a-zA-Z0-9-]{0,47}-[a-zA-Z0-9]{10}/policy/[a-zA-Z][a-zA-Z0-9-]{0,47}-[a-zA-Z0-9]{10}</code>)
`policy_engine_id`	`string`	The identifier of the policy engine that manages this policy. This establishes the policy engine context for policy evaluation and management. (pattern: <code>[A-Za-z][A-Za-z0-9_]*-[a-z0-9_]{10}</code>)
`policy_id`	`string`	The unique identifier for the policy. This system-generated identifier consists of the user name plus a 10-character generated suffix and serves as the primary key for policy operations. (pattern: <code>[A-Za-z][A-Za-z0-9_]*-[a-z0-9_]{10}</code>)
`status`	`string`	The current status of the policy. (CREATING, ACTIVE, UPDATING, DELETING, CREATE_FAILED, UPDATE_FAILED, DELETE_FAILED)
`status_reasons`	`array`	Additional information about the policy status. This provides details about any failures or the current state of the policy lifecycle.
`updated_at`	`string (date-time)`	The timestamp when the policy was last modified. This tracks the most recent changes to the policy configuration or metadata.

Methods

The following methods are available for this resource:

Name	Accessible by	Required Params	Optional Params	Description
`get_policy`	`select`	`policy_engine_id`, `policy_id`, `region`		Retrieves detailed information about a specific policy within the AgentCore Policy system. This operation returns the complete policy definition, metadata, and current status, allowing administrators to review and manage policy configurations.
`list_policies`	`select`	`policy_engine_id`, `region`	`nextToken`, `maxResults`, `targetResourceScope`	Retrieves a list of policies within the AgentCore Policy engine. This operation supports pagination and filtering to help administrators manage and discover policies across policy engines. Results can be filtered by policy engine or resource associations.
`create_policy`	`insert`	`policy_engine_id`, `region`, `name`, `definition`		Creates a policy within the AgentCore Policy system. Policies provide real-time, deterministic control over agentic interactions with AgentCore Gateway. Using the Cedar policy language, you can define fine-grained policies that specify which interactions with Gateway tools are permitted based on input parameters and OAuth claims, ensuring agents operate within defined boundaries and business rules. The policy is validated during creation against the Cedar schema generated from the Gateway's tools' input schemas, which defines the available tools, their parameters, and expected data types. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion. If the new policy is a temporal policy, creating it invalidates the policy engine's active temporal sessions. For more information about temporal policy sessions, see session-based temporal policies. The policy engine returns an HTTP 409 ConflictException to in-flight sessions. To resume, you must start a new session with a new session ID.
`update_policy`	`update`	`policy_engine_id`, `policy_id`, `region`		Updates an existing policy within the AgentCore Policy system. This operation allows modification of the policy description and definition while maintaining the policy's identity. The updated policy is validated against the Cedar schema before being applied. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion. If the updated policy is a temporal policy, the policy engine invalidates all active temporal sessions. If the update adds or removes temporal operators, the policy engine also invalidates active temporal sessions. For more information about temporal policy sessions, see session-based temporal policies. The policy engine returns an HTTP 409 ConflictException to in-flight sessions. To resume, you must start a new session with a new session ID.
`delete_policy`	`delete`	`policy_engine_id`, `policy_id`, `region`		Deletes an existing policy from the AgentCore Policy system. Once deleted, the policy can no longer be used for agent behavior control and all references to it become invalid. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion.
`start_policy_generation`	`exec`	`policy_engine_id`, `region`, `resource`, `content`, `name`		Initiates the AI-powered generation of Cedar policies from natural language descriptions within the AgentCore Policy system. This feature enables both technical and non-technical users to create policies by describing their authorization requirements in plain English, which is then automatically translated into formal Cedar policy statements. The generation process analyzes the natural language input along with the Gateway's tool context to produce validated policy options. Generated policy assets are automatically deleted after 7 days, so you should review and create policies from the generated assets within this timeframe. Once created, policies are permanent and not subject to this expiration. Generated policies should be reviewed and tested in log-only mode before deploying to production. Use this when you want to describe policy intent naturally rather than learning Cedar syntax, though generated policies may require refinement for complex scenarios.

Parameters

Parameters can be passed in the WHERE clause of a query. Check the Methods section to see which parameters are required or optional for each operation.

Name	Datatype	Description
`policy_engine_id`	`string`	The identifier of the policy engine that provides the context for policy generation. This engine's schema and tool context are used to ensure generated policies are valid and applicable.
`policy_id`	`string`	The unique identifier of the policy to be deleted. This must be a valid policy ID that exists within the specified policy engine.
`region`	`string`	AWS region (default: us-east-1)
`maxResults`	`integer`	The maximum number of policies to return in a single response. If not specified, the default is 10 policies per page, with a maximum of 100 per page.
`nextToken`	`string`	A pagination token returned from a previous ListPolicies call. Use this token to retrieve the next page of results when the response is paginated.
`targetResourceScope`	`string`	Optional filter to list policies that apply to a specific resource scope or resource type. This helps narrow down policy results to those relevant for particular Amazon Web Services resources, agent tools, or operational contexts within the policy engine ecosystem.

`SELECT` examples

get_policy
list_policies

Retrieves detailed information about a specific policy within the AgentCore Policy system. This operation returns the complete policy definition, metadata, and current status, allowing administrators to review and manage policy configurations.

SELECT
name,
created_at,
definition,
description,
enforcement_mode,
policy_arn,
policy_engine_id,
policy_id,
status,
status_reasons,
updated_at
FROM aws.bedrock_agentcore_control.policies
WHERE policy_engine_id = '{{ policy_engine_id }}' -- required
AND policy_id = '{{ policy_id }}' -- required
AND region = '{{ region }}' -- required
;

Retrieves a list of policies within the AgentCore Policy engine. This operation supports pagination and filtering to help administrators manage and discover policies across policy engines. Results can be filtered by policy engine or resource associations.

SELECT
name,
created_at,
definition,
description,
enforcement_mode,
policy_arn,
policy_engine_id,
policy_id,
status,
status_reasons,
updated_at
FROM aws.bedrock_agentcore_control.policies
WHERE policy_engine_id = '{{ policy_engine_id }}' -- required
AND region = '{{ region }}' -- required
AND nextToken = '{{ nextToken }}'
AND maxResults = '{{ maxResults }}'
AND targetResourceScope = '{{ targetResourceScope }}'
;

`INSERT` examples

create_policy
Manifest

Creates a policy within the AgentCore Policy system. Policies provide real-time, deterministic control over agentic interactions with AgentCore Gateway. Using the Cedar policy language, you can define fine-grained policies that specify which interactions with Gateway tools are permitted based on input parameters and OAuth claims, ensuring agents operate within defined boundaries and business rules. The policy is validated during creation against the Cedar schema generated from the Gateway's tools' input schemas, which defines the available tools, their parameters, and expected data types. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion. If the new policy is a temporal policy, creating it invalidates the policy engine's active temporal sessions. For more information about temporal policy sessions, see session-based temporal policies. The policy engine returns an HTTP 409 ConflictException to in-flight sessions. To resume, you must start a new session with a new session ID.

INSERT INTO aws.bedrock_agentcore_control.policies (
name,
definition,
description,
validationMode,
enforcementMode,
clientToken,
policy_engine_id,
region
)
SELECT 
'{{ name }}' /* required */,
'{{ definition }}' /* required */,
'{{ description }}',
'{{ validationMode }}',
'{{ enforcementMode }}',
'{{ clientToken }}',
'{{ policy_engine_id }}',
'{{ region }}'
RETURNING
name,
created_at,
definition,
description,
enforcement_mode,
policy_arn,
policy_engine_id,
policy_id,
status,
status_reasons,
updated_at
;

# Description fields are for documentation purposes
- name: policies
props:
  - name: policy_engine_id
    value: "{{ policy_engine_id }}"
    description: Required parameter for the policies resource.
  - name: region
    value: "{{ region }}"
    description: Required parameter for the policies resource.
  - name: name
    value: "{{ name }}"
  - name: definition
    description: |
      Represents the definition structure for policies within the AgentCore Policy system. This structure encapsulates different policy formats and languages that can be used to define access control rules.
    value:
      cedar:
        statement: "{{ statement }}"
      policyGeneration:
        policyGenerationId: "{{ policyGenerationId }}"
        policyGenerationAssetId: "{{ policyGenerationAssetId }}"
      policy:
        statement: "{{ statement }}"
  - name: description
    value: "{{ description }}"
  - name: validationMode
    value: "{{ validationMode }}"
    valid_values: ['FAIL_ON_ANY_FINDINGS', 'IGNORE_ALL_FINDINGS']
  - name: enforcementMode
    value: "{{ enforcementMode }}"
    description: |
      The enforcement mode for a policy. Run this policy in LOG_ONLY mode to collect data on how it affects your application. Once you are satisfied with the data gathered, switch the policy to ACTIVE.
    valid_values: ['ACTIVE', 'LOG_ONLY']
  - name: clientToken
    value: "{{ clientToken }}"

`UPDATE` examples

update_policy

Updates an existing policy within the AgentCore Policy system. This operation allows modification of the policy description and definition while maintaining the policy's identity. The updated policy is validated against the Cedar schema before being applied. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion. If the updated policy is a temporal policy, the policy engine invalidates all active temporal sessions. If the update adds or removes temporal operators, the policy engine also invalidates active temporal sessions. For more information about temporal policy sessions, see session-based temporal policies. The policy engine returns an HTTP 409 ConflictException to in-flight sessions. To resume, you must start a new session with a new session ID.

UPDATE aws.bedrock_agentcore_control.policies
SET 
description = '{{ description }}',
definition = '{{ definition }}',
validationMode = '{{ validationMode }}',
enforcementMode = '{{ enforcementMode }}'
WHERE 
policy_engine_id = '{{ policy_engine_id }}' --required
AND policy_id = '{{ policy_id }}' --required
AND region = '{{ region }}' --required
RETURNING
name,
created_at,
definition,
description,
enforcement_mode,
policy_arn,
policy_engine_id,
policy_id,
status,
status_reasons,
updated_at;

`DELETE` examples

delete_policy

Deletes an existing policy from the AgentCore Policy system. Once deleted, the policy can no longer be used for agent behavior control and all references to it become invalid. This is an asynchronous operation. Use the GetPolicy operation to poll the status field to track completion.

DELETE FROM aws.bedrock_agentcore_control.policies
WHERE policy_engine_id = '{{ policy_engine_id }}' --required
AND policy_id = '{{ policy_id }}' --required
AND region = '{{ region }}' --required
;

Lifecycle Methods

start_policy_generation

Initiates the AI-powered generation of Cedar policies from natural language descriptions within the AgentCore Policy system. This feature enables both technical and non-technical users to create policies by describing their authorization requirements in plain English, which is then automatically translated into formal Cedar policy statements. The generation process analyzes the natural language input along with the Gateway's tool context to produce validated policy options. Generated policy assets are automatically deleted after 7 days, so you should review and create policies from the generated assets within this timeframe. Once created, policies are permanent and not subject to this expiration. Generated policies should be reviewed and tested in log-only mode before deploying to production. Use this when you want to describe policy intent naturally rather than learning Cedar syntax, though generated policies may require refinement for complex scenarios.

EXEC aws.bedrock_agentcore_control.policies.start_policy_generation 
@policy_engine_id='{{ policy_engine_id }}' --required, 
@region='{{ region }}' --required 
@@json=
'{
"resource": "{{ resource }}", 
"content": "{{ content }}", 
"name": "{{ name }}", 
"clientToken": "{{ clientToken }}"
}'
;

Overview​

Fields​

Methods​

Parameters​

SELECT examples​

INSERT examples​

UPDATE examples​

DELETE examples​

Lifecycle Methods​