Require approval for Claude computer use actions on Anthropic and Bedrock
Claude proposes computer use actions, but your client application executes them. That makes the point between receiving a proposed action and executing it the place to require approval. Normalize each proposed action into one internal schema, classify it by risk tier, and hold consequential actions for a named human approver before they run. Applied at that point, the same policy works on the Anthropic API and on Amazon Bedrock, and each decision can produce a durable record.
- 1
Provider adapter
Parses requests and formats results for the Anthropic API or Bedrock.
- 2
Common action record
One schema for every proposed action, whatever its origin.
- 3
Policy evaluation
Returns allow, redact, block or escalate for approval.
- 4
Executor
Runs only permitted actions inside the sandboxed environment.
- 5
1. Receive and normalize
Parse the tool-use request into the common action record.
- 6
2. Evaluate policy
Match the action, target and session context to a tier and rule.
- 7
3. Allow, redact or block
Permitted actions proceed, sensitive content is redacted, prohibited actions are refused.
- 8
4. Escalate
Hold Tier 3 actions and route them to an authenticated approver with full context.
- 9
5. Execute or refuse
Run only approved actions, or return a refusal result to the model.
- 10
6. Write the record
Store the decision before the loop continues.
How the computer use action loop works
Claude's computer use tool lets a model propose actions inside a desktop environment: clicking, typing, running commands and taking screenshots. The model does not act on the desktop itself. Your client application receives each proposed action, executes it in the environment, and returns the outcome, usually a screenshot, so the model can choose the next step. The loop repeats until the model stops requesting actions.
This shape is the same whether you call Claude through the Anthropic API or through Amazon Bedrock. Request transport, authentication and configuration differ by provider, but the responsibility does not: your code stands between a proposed action and its execution.
That gap is where an approval checkpoint belongs. Insert it after the tool-use request is parsed and before the action is passed to the environment. If approval is instead implemented inside each application, or reviewed from logs afterward, the action has already run by the time anyone decides. Approval is a runtime enforcement point in the execution path, not a review after the fact.
Classify actions by risk tier
Not every action needs a human. Requiring approval for clicks and screenshots would make the agent unusable and train approvers to click through. The tiers below are a recommended starting point, not a sourced standard. Adjust them to your data, your applications and your regulatory obligations.
Two cautions apply. Action type alone is not enough: typing text into a search box differs from typing into a payment form, so policy should consider the target application, domain and content. And a single step may look benign while a sequence does not. NIST's draft guidance on computer-use agents notes that harm can arise from a trajectory of individually benign actions, so policy should be able to use session context, such as a new domain visited shortly before a file upload.
- Tier 0: Observe: Screenshots, scrolling and pointer movement within approved applications. Allow and record.
- Tier 1: Routine interaction: Clicks and key presses inside approved applications and domains. Allow, with rate limits.
- Tier 2: Data entry: Typing text, particularly anything resembling credentials or regulated data. Redact or escalate based on content and target.
- Tier 3: Consequential: Form submission, shell commands, file creation, deletion or upload, and navigation to a domain not previously approved. Escalate for human approval.
- Tier 4: Prohibited: Actions outside the permitted scope, such as reaching credential stores or disabling security tooling. Block.
Constrain the environment and distrust the screen
Approval is one control among several. A federal request for information on AI agent security, published in January 2026, lists human oversight controls such as approvals for consequential actions alongside management of sensitive and untrusted data and network access permissions. It is a request for input, not a binding rule, as of November 2026.
In practice, run the agent in an isolated environment with no standing access to production credentials, a restricted network allow-list, and only the files the task needs. NIST's draft guidance describes computer-use agents as having broad access to the operating system, files and accounts, so narrowing that surface reduces what an approver must catch.
Treat everything rendered on screen as untrusted. The same draft observes that because the agent perceives the rendered interface, adversaries can inject instructions visually, for example through text on a web page. An action that follows a screen change the user did not initiate, such as a command suddenly appearing after a page loads, should raise the escalation threshold. NIST's guidance is voluntary, but its direction is clear: constrain and monitor agent actions against policy set by the deployer.
What each decision should record
An approval that cannot be proven did not happen from an auditor's point of view. Write one record per evaluated action, including those allowed automatically, since the absence of a hold is also a decision. Each record should contain the proposed action in full, the policy and rule matched, the risk tier, the outcome (allowed, redacted, blocked, escalated), the approver's identity where a human was involved, their decision, a timestamp for each stage, and the session identifier that ties records together.
Store records outside the agent's environment, so the agent cannot alter them, and set retention and data residency to match your obligations. Redact sensitive values in the record itself when the policy requires it. Frameworks such as NIST AI RMF, HIPAA and the EU AI Act involve human oversight and accountability themes, so confirm with your compliance team how these records map to specific control requirements instead of assuming a mapping.
Enforcing this with Trussed
One way to implement the checkpoint is to enforce policy in the execution path, which is what Trussed does. Trussed enforces policy on individual interactions and tool calls across models, agents, tools and MCP servers: allow, redact, block, rate limit, or escalate for human approval. Because enforcement happens at runtime rather than being reviewed after the fact, a computer use action can be held before it reaches the environment. One policy plane covers multiple models, so the same rules apply to Claude on the Anthropic API and on Bedrock.
Enforcement generates audit-ready evidence continuously, mapped to HIPAA, NAIC, NYDFS, the EU AI Act and NIST. Trussed deploys self-managed in the customer cloud, with configurable retention and data residency. Its scope is the individual tool call; it does not provide transaction-level governance or end-to-end tracing of agentic workflows, so session context in your policy should be designed accordingly.
The design in this guide works without Trussed. The requirement is that approval is enforced where actions execute, consistently, and leaves a record you can show.
Approval checkpoint in the computer use loop
Model proposes
Claude returns a tool-use request such as a click, keystroke, command or screenshot.
Policy evaluates
The proposed action is normalized and matched to a risk tier before anything executes.
Human decides
Consequential actions are held until an approver allows or rejects them.
Client executes
Only permitted actions run in the sandboxed environment, and the result returns to the model.
Evidence is written
Each decision is recorded with the action, policy, approver, outcome and time.
Put approval in the execution path
See how policy enforcement on individual tool calls holds consequential computer use actions for human approval and produces audit-ready evidence.
Explore Agent and Tool-Call EnforcementHow does your AI governance program compare?
See where your program has gaps in less than 2 minutes.