AI Security Maturity Model·AWS v1.0.0

Drag to explore · pinch to zoom

Enhanced AI Application SecurityDefense-in-depth layer: AI Application Capability 5 · Generative AI agentsUse case: AI that acts 👤 CustomerAWS Shared Responsibility Model: who implements and operates this control. Customer = you own it; AWS = AWS operates it and you inherit it; Shared = both have obligations.

c5.5 Require human approval for high-consequence actions

Insert a human-in-the-loop checkpoint before an agent performs sensitive, mutative, or destructive operations, so autonomy is bounded on the actions that matter most.

Foundational
Enhanced
Advanced
Effort: Medium Impact: High GenAI scopesFrom the AWS Generative AI Security Scoping Matrix.: 3 · Pre-trained models; 4 · Fine-tuned models Agentic security dimensionsFrom the AWS Agentic AI Security Scoping Matrix.: Operational boundaries

Implementation guidance

How to implement on AWS

Identify high-consequence actions and require explicit human approval before the agent proceeds (implementable with hooks in the agent framework or an approval step via Lambda/Step Functions). Combine with least-privilege roles and instruction hardening so the model cannot route around the checkpoint.

Bound autonomy at the point of consequence

An agent that can act on its own is convenient — until it deletes production data, moves money, or emails customers because a prompt injection told it to. The fix is not to remove autonomy everywhere, but to insert a human-in-the-loop checkpoint in front of the specific operations that are sensitive, mutative, or destructive. Everything else stays autonomous; the high-consequence actions pause for an explicit human approval.

Model the approval as a pausing workflow

AWS Step Functions' callback pattern (waitForTaskToken) is a clean way to implement this: the workflow reaches the sensitive step, emits a task token to a human (email, Slack, a ticket), and pauses — for up to a year — until someone approves or rejects:

{
  "ApproveHighRiskAction": {
    "Type": "Task",
    "Resource": "arn:aws:states:::lambda:invoke.waitForTaskToken",
    "Parameters": {
      "FunctionName": "notify-approver",
      "Payload": {
        "action.$": "$.proposedAction",
        "taskToken.$": "$$.Task.Token"
      }
    },
    "Next": "ExecuteAction",
    "TimeoutSeconds": 86400
  }
}

The approver's decision resumes the workflow:

# Approve
aws stepfunctions send-task-success \
  --task-token "<token>" --task-output '{"approved":true}'

# Reject
aws stepfunctions send-task-failure \
  --task-token "<token>" --error "Rejected" --cause "Not authorized by reviewer"

Decide what needs a human

Route only high-consequence actions through the checkpoint — deletes, financial transactions, permission changes, external communications, anything irreversible. Let the agent classify a proposed tool call and branch: low-risk actions execute directly; high-risk ones enter the approval state. Keep the classification server-side, not something the model can talk its way around.

Fail closed and record the decision

If the approval times out, the workflow should fail closed (do not execute), not proceed. Log who approved or rejected, when, and the exact action — this is both your audit trail and your evidence that autonomy stayed bounded.

Naming note: set TimeoutSeconds to a window that fits your operations; on timeout the action is not taken. Send the approver enough context (the exact operation and its parameters) to decide safely.

How it fits together

Agent proposes action Classify risk (server-side) low risk Execute directly stays autonomous high risk Step Functions waitForTaskToken (paused) Human approve / reject approved → execute rejected / timeout → fail closed (no action)
The agent proposes an action and a server-side classifier judges its risk. Low-risk actions execute directly and stay autonomous; high-risk actions pause on a Step Functions waitForTaskToken callback until a human approves (execute), rejects, or the request times out (fail closed — no action).

Acceptance criteria

High-consequence actions pause for documented human approval; approvals are logged; the agent cannot bypass the checkpoint.

Practical implementation

How this control is implemented in each reference architecture:

High-consequence actions pause at a Step Functions approval step in the Generative AI account; a human must approve before the agent proceeds, and least-privilege prevents routing around it.

  1. Identify high-consequence (sensitive, mutative, destructive) actions and require explicit human approval before the AgentCore Runtime agent proceeds, implemented as a Step Functions approval step or an AgentCore agent-framework hook.
    Generative AI account Bedrock AgentCore Step Functions AWS Lambda
  2. Route the approval request to the responsible human (e.g. via the Application account UI) and record the decision.
    Application account AWS Lambda
  3. Combine with least-privilege roles and instruction hardening so the model cannot bypass the checkpoint, and log every approval to the Log archive.
    Generative AI account → Log archive IAM CloudTrail

How to validate: High-consequence actions pause for documented human approval; approvals are logged centrally; the agent cannot execute the gated action without approval.

Avoid: Full autonomy on destructive actions with only prompt-level 'please confirm'. Enforce the checkpoint in the workflow and IAM, not in the prompt.

Generative AI OU (multi-account) →

A Step Functions/Lambda approval step gates high-consequence agent actions in the account, with least-privilege ensuring the checkpoint cannot be bypassed.

  1. Gate sensitive/mutative/destructive actions of the AgentCore Runtime agent behind an explicit human-approval step (Step Functions or an AgentCore agent hook).
    Generative AI tier (IAM role) Bedrock AgentCore Step Functions AWS Lambda
  2. Surface the approval to a human and record the decision.
    Application tier (IAM role) AWS Lambda
  3. Back it with least-privilege roles and hardened instructions, and log approvals.
    In-account logging IAM CloudTrail

How to validate: High-consequence actions pause for documented approval; approvals are logged; the agent cannot bypass the checkpoint.

Avoid: Letting the agent self-approve high-impact actions. Put a human in the loop for the actions that matter and enforce it structurally.

Single account (entry point) →

Threats addressed

  • An autonomous agent executing a damaging action without oversight.
  • Cascading harm from an unchecked high-impact decision.

AWS services

Amazon Bedrock AgentCore AWS Lambda AWS Step Functions

Pricing

Step Functions Standard Workflows bill per state transition; a paused waitForTaskToken state incurs no charge while waiting. The approval notification (Lambda/SNS) has minor per-use costs. This is inexpensive relative to the risk it contains. See Wait for a callback with the task token.

Framework mappings

OWASP GenAI/LLM Top 10 (2026)

  • LLM03 Excessive Agency

NIST AI Risk Management Framework (AI 100-1)

  • GOVERN.5 Processes for stakeholder engagement and feedback
  • MANAGE.2 Strategies to maximize benefits and minimize impacts are planned
  • MANAGE.4 Risk treatments, monitoring and response are documented and applied

AWS Well-Architected Generative AI Lens (Security)

  • GENSEC05-BP01 Implement least privilege and permission boundaries for agentic workflows

OWASP GenAI Top 10 for Agentic Applications (2025)

  • ASI09 Human-Agent Trust Exploitation

Learning resources

References

  • AWS SRA for AI — Capability 5, Application security