Anthropic CCA-F: Human Approval in Claude Agent Architectures
Human approval is an architectural control for Claude agents that can move from reasoning to consequential action. The goal is not to interrupt every tool call; it is to put accountable review in front of actions where business context, legal responsibility, irreversible change, or safety risk exceeds what the agent should decide alone. Reading a document and deleting a production record do not deserve the same approval policy. A safe design exposes the precise pending action, validates its scope outside the model, and records what the reviewer actually authorized before execution.
On this page
An approval gate needs an exact proposed action, not a general expression of confidence in the assistant. Bind the tool name, target resource, typed arguments, requesting identity, approval scope and expiration to one reviewable request. If the agent changes the recipient, amount or affected files after the reviewer approves, the earlier authorization should not cover the new payload. The execution service must validate both the reviewer’s authority and the current resource state before acting; a model-generated statement that an action was approved is not an authorization record.
Anthropic’s Agent SDK exposes several mechanisms for controlling tool execution, including permission modes, allow and deny rules, hooks, and a canUseTool callback that can allow, deny, or modify tool inputs. Anthropic’s official SDK examples demonstrate automatically allowing read operations, blocking dangerous commands, redirecting writes, and prompting a user for approval when a tool is not covered by prior rules. Every consequential tool request needs enforceable policy in the surrounding Claude production engineering system; prompt instructions alone cannot authorize an operation.
Separate intent from authority
Claude can propose an action, but the application—not the model’s prompt—must determine whether that action is authorized. Effective tool control checks the caller’s identity, target resource, parameters, and applicable business rules against the current state before execution. For example, a proposed file deletion must fail when it exceeds the user’s permitted scope, even if the model claims approval was granted. Keeping these decisions in trusted code makes permission enforcement reliable rather than depending on a natural-language instruction that the agent could misunderstand. Human approval in Claude Certified Architect – Foundations (CCAR-F) architecture should attach to a specific proposed action and its consequences, not a generic confirmation prompt.
Permission design should use allowlists for expected safe behavior. A file-editing agent can be limited to one workspace; an email agent can be limited to approved domains; a deployment agent can be limited to nonproduction environments until another workflow promotes the change. Narrow tool boundaries reduce the number of cases that require judgment at runtime.
Approve high-impact actions
Approval should be proportional to the consequence of the action. Searching an approved repository or reading public documentation usually requires less intervention than modifying customer records, sending external messages, or deleting production data. A well-designed agent can automatically perform narrowly authorized, low-risk reads while requiring explicit review for consequential writes. Overusing approval prompts creates fatigue and makes important decisions easier to miss. Set the boundary using reversibility, affected resources, data sensitivity, and the confidence of the underlying evidence—not simply whether the agent requested a tool.
Approval should occur as late as practical but before the irreversible step. The agent can gather data, draft a message, calculate an amount, or prepare a patch automatically, then ask the user to approve the final action. This keeps the workflow efficient while ensuring the human reviews the exact payload that will be executed. In multi-step work, one approval should not automatically authorize every later action. If the workflow changes target, amount, or scope after approval, the application should either revalidate the original authorization or ask again. Authorization is tied to a proposed action, not to a vague statement that the user “trusts the agent.”
Show what will happen
An approval request should expose the intended action, affected resources, important parameters, and expected consequence so the reviewer can decide independently. Useful human approval identifies recipients before sending an email, lists files before deleting them, and shows the exact change before modifying production configuration. A generic “Allow tool?” prompt withholds critical context. If the proposed action depends on data that may change while approval is pending, recheck that state immediately before execution rather than treating an earlier preview as permanent authorization.
The approval surface should also make uncertainty visible. If the agent is unsure which customer record is correct, the user should see the ambiguity before approving the update. Hiding uncertainty behind a polished summary turns the human into a rubber stamp instead of a meaningful control. The approval experience should be tested with real users under time pressure. Long technical payloads are difficult to review, but oversimplified summaries can hide material details. The right interface shows the consequence first and gives reviewers a way to inspect supporting evidence before deciding.
Use permission callbacks for policy
The Agent SDK’s canUseTool callback turns approval policy into an executable check. For each proposed action, trusted application code can allow it, deny it, or modify parameters after checking the caller, resource, and current authorization. This supports narrow file-path access, blocked commands, approved API destinations, and review for operations outside an allowlist. Keep these rules testable in code and record the decisions. A natural-language restriction in the prompt cannot replace an execution-layer permission check when the tool itself holds powerful credentials.
Tool schemas should carry business meaning. A function named transfer_funds with typed destination and amount fields is easier to govern than a generic execute_api_request tool that can call arbitrary endpoints. Clear tools make approval easier because the user sees a concrete operation rather than a low-level request whose impact is hard to infer. Approval policy should be versioned with the agent. If one release adds a new tool or changes a tool from read-only to write-capable, the permission and approval configuration should change in the same deployment. This prevents an agent from gaining operational capability while the old approval model still assumes a smaller blast radius.
When approval is denied, capture the reason where practical. A denial caused by wrong parameters should lead to a corrected proposal; a denial caused by policy should terminate the workflow. Treating all denials as “try again with different words” can turn the agent into a pressure mechanism against the human control.
Approval architecture should be reviewed whenever the agent becomes more autonomous. Adding scheduled execution, memory, background sessions, or new MCP tools can create actions when the original user is no longer present. The system should decide whether those actions require pre-authorized policy, deferred approval, or a hard stop. A control designed for an interactive chat should not be assumed to remain sufficient after the same agent starts operating asynchronously.
Use hooks for broader control
Lifecycle hooks provide another point of control around tool execution. Pre-execution hooks can enforce organization-wide restrictions even when an agent’s permission mode would otherwise allow a tool, while later hooks can record outcomes or trigger controlled follow-up checks. Decide which controls belong in the tool implementation, which belong in permission callbacks, and which should run centrally through hooks. Test their behavior during denied operations, exceptions, and retries so a failure in a hook cannot silently convert a restricted action into an unrestricted one.
Keep authentication separate
A user approving an action does not automatically mean the agent has the right credential to perform it. Agent boundaries should combine user authorization with a workload identity whose tool permissions are already limited. Approval narrows intent; least-privilege identity limits blast radius if the approval logic is bypassed or the agent is manipulated.
Organizations should define who is allowed to approve each class of action. The end user may approve a customer-facing draft, while a production deployment might require an operator or change manager. Identity and role checks should happen at the approval service, not be inferred from who happens to be present in the chat. Approval should also preserve separation of duties where required. The person who prepared an action may not be the person allowed to authorize it, particularly for financial, privileged, or regulated workflows. A production agent can support that process by packaging the evidence and proposal without collapsing both roles into one click.
Handle unavailable reviewers
Production agents need deterministic behavior when approval never arrives. Expire pending actions, preserve the proposal for later review where appropriate, or fall back to a read-only result. Do not leave an external transaction in an ambiguous partially completed state because the conversation ended.
Approval systems also need concurrency control. If two sessions propose conflicting changes to the same record, the second action should re-read current state before execution. A human may approve something that was safe five minutes ago but is now stale. Optimistic locking, version numbers, and transaction checks help keep approval meaningful. For asynchronous agents, approval can be modeled as a pending task with expiry. Store the proposed action and enough context for the reviewer, but do not keep privileged execution tokens alive indefinitely. When the user approves later, obtain fresh credentials and revalidate the target state.
Audit approvals and denials
An approval audit trail should record who requested and approved an action, the affected resource, validated parameters, the agent release, any denial reason, and the eventual execution result. Effective agent observability connects that decision to the tool call and business outcome, making failed checks and unauthorized attempts explainable. Preserve the evidence needed for investigation without indiscriminately storing sensitive prompts or every intermediate model message.
Security teams should monitor approval patterns. Repeated denials can reveal poor tool descriptions or risky agent behavior. Repeated approvals without review may indicate too much friction. High rates of modified inputs can show that the agent frequently proposes unsafe parameters. These signals should feed prompt, tool, or workflow redesign. Keep approval owners and policy tests current as tools, user roles, and asynchronous capabilities change so the human gate remains tied to real consequence.
Test and maintain approval boundaries
Adversarial prompts should attempt to disguise dangerous actions as harmless ones, modify paths, split one action into several calls, or exploit broad tool schemas. For Claude agents, the durable pattern is read freely where policy allows, validate deterministically, require approval at consequence boundaries, execute through narrow identities, and audit the result. Human approval works when it is one enforceable layer in a larger authorization system.
Approval policy should be derived from consequence, reversibility, and confidence. Reading a repository is usually reversible and low-impact; sending a payment, changing production infrastructure, deleting files, or communicating externally can have consequences the model cannot repair by simply trying again. Those actions deserve stronger gates even when Claude appears confident. Human approval is therefore strongest as one layer in a permission architecture: narrow tools, least-privilege identity, deterministic validation, explicit consequence, useful review context, fresh-state checks, audited execution, and adversarial tests. The human does not make the agent safe alone; the system makes the human decision enforceable.