Skip to main content

Free tool · AI agent safety

Before your AI agent takes action, know what it should never do alone.

Configure a real agent scenario, and get a deterministic, explainable policy for every action it can take: run automatically, require human approval, or block outright - with the exact reason and safeguard for each.

Map Your Agent

Step 1 of 3

Choose your agent's job

Step 2 of 3

Configure what the agent can do

Payment verified

Has the agent independently confirmed the payment actually succeeded (not just trusted the customer's claim)?

Same tenant / customer

Does the ticket, payment and account the agent is touching all belong to the same customer?

Refund amount ($)

The dollar amount of the refund being considered.

Refund already processed

Does an idempotency key for this exact refund already show a completed transaction?

Authorized reviewer available

Is someone who can approve a pending action available right now? (Affects the simulation's audit trail, not the policy itself.)

Step 3 of 3

Your action-approval policy

4AUTO
2HUMAN APPROVAL
0BLOCK

Action Safety Blueprint

Business consequence

No actions are blocked under this configuration, but 2 still require human approval before executing: Issue a refund, Send a customer confirmation email. These carry real consequence (financial, customer-facing, or irreversible) even though the preconditions for running them are currently met.

Permission boundaries

  • 4 action(s) run autonomously: Read customer support ticket, Look up payment status, Check subscription and entitlement status, Grant missing subscription access.
  • 2 action(s) require a named human approver before executing.
  • 0 action(s) are blocked outright and routed to a separate process the agent cannot self-authorize.
  • An approval or AUTO permission for one specific action and its exact parameters never implies permission for a different action, a different amount, or a different record - this policy is evaluated per request, not cached.

Approval workflow

  • Issue a refund: approver reviews — "A $49 refund is a real financial and customer-facing action. Under the default policy, every refund requires human approval regardless of amount - this one is below the escalation ceiling, so a standard reviewer can approve it." — and confirms before execution; approval is tied to this exact request's parameters, expires if unused, and can't be replayed against a different request.
  • Send a customer confirmation email: approver reviews — "Any customer-facing message is reviewed before sending by default - a wrong tone, wrong amount, or wrong recipient is a real brand and trust risk, not just an internal mistake." — and confirms before execution; approval is tied to this exact request's parameters, expires if unused, and can't be replayed against a different request.

Audit and monitoring requirements

  • Log every evaluated action (not just the ones that executed) with its verdict, the reason, and the exact context values that produced it - a BLOCK or APPROVAL decision is itself security-relevant evidence.
  • Alert on repeated BLOCK results for the same action/actor combination - that pattern often means either a bug in the calling system or a deliberate attempt to find a gap in the policy.
  • Record the approver's identity and timestamp against every APPROVAL execution, tied to the specific request id it approved.

Failure recovery safeguards

  • Tenant-scoped row-level security on every read.
  • Query the payment processor directly - never trust a customer-supplied screenshot or claim.
  • Idempotency key on the grant so a retry can't double-provision.
  • Write is limited to the entitlement field, not the whole account record.
  • Approval must be tied to this exact refund amount and order id - approving one refund never implies permission for a different one.
  • Record the approver's identity and timestamp in the audit log.
  • Template the message with the exact verified amount/ticket id substituted, not freely generated text.
  • Any AUTO action should still be reversible or idempotent even though no human reviews it before it runs - autonomy is only safe when the blast radius of being wrong is already bounded.

Suggested first seven implementation steps

  1. 1. Enumerate every real action your agent can actually take - not the actions you intend it to take, the ones its tool access technically permits.
  2. 2. For each action, classify it against this policy's three verdicts (AUTO / APPROVAL / BLOCK) using the same precedence this map uses: explicit deny or failed security gate first, then approval gates, then AUTO only if every condition is met.
  3. 3. Implement authorization checks server-side, independent of the agent's own reasoning - the agent proposing an action is never the same thing as the system authorizing it.
  4. 4. Add idempotency keys to every action with a real-world duplicate-effect risk - a retried request must be provably safe to repeat, not just unlikely to repeat.
  5. 5. Build the approval workflow so an approval is cryptographically or structurally tied to the exact action and parameters reviewed - never a standing grant.
  6. 6. Instrument audit logging before launch, not after an incident - every evaluated decision, not just executed ones.
  7. 7. Write and test a rollback or recovery path for every action that's allowed to run at all, including the AUTO ones - 'it's automated' is not the same as 'it's safe to be wrong.'

Every export above is free and complete - nothing is held back or gated behind an email.

Failure simulation (1 of 2)

The agent attempts to refund the same order twice

A network retry or a duplicate webhook delivery causes the support agent to attempt the same $49 refund a second time, seconds after the first one already completed.

Your agent has a plan. Can your existing system enforce it?

An approval policy is only useful when permissions, execution controls, retries and recovery are correctly implemented. Tech Mitrise helps SaaS teams make those boundaries real.

This map tells you what your policy should be. Tech Mitrise helps you make it real — enforced in code, not just on paper: the server-side authorization checks, idempotency keys, audit logging, and tested rollback paths that turn a document like this one into something your agent actually can't violate.

The map above, and every export of it, is free and complete — nothing here is held back behind this form. This is about the separate work of implementing real enforcement in your own system, specifically.

Book a free 20-minute triage →

Review My Agent Workflow

Why teams building AI agents need this

AI agents are increasingly given real write access into SaaS billing, CRM and production systems - not just read access and a chat window. The common SaaS use cases where this matters most: a support agent that can issue refunds or change account contact details, a CRM agent that can export or delete customer records, and a DevOps agent that can retry jobs, restart services or deploy code. In every one of these, the question isn't whether the agent is smart enough to decide - it's whether the system around it enforces what it's allowed to decide alone.

A real incident this maps to

In April 2026, PocketOS founder Jer Crane publicly disclosed that a Cursor coding agent running on Claude Opus 4.6 deleted his company's production database and its backups in about nine seconds. The agent had been fixing an unrelated credential error; on its own, it decided the fix involved deleting a cloud storage volume, assumed that volume was scoped to a staging environment, and never independently verified that assumption before executing. It wasn't. The outage lasted roughly 30 hours.

Run the "An agent deletes production data it assumed was scoped to staging" failure simulation above (Production Operations Agent scenario) to see how this maps to the three verdicts: this site's own policy for deleting production database records is an unconditional BLOCK for any production environment, regardless of what the agent believes about scope - not because the agent can't be trusted to check, but because no check performed by the agent itself is a safeguard for an action this irreversible. The policy's own note on this action: it shouldn't be in an agent's available action set for production at all, rather than relying on a rule to catch it correctly every single time.

Sources: Decrypt, ITPro. Accounts vary on exactly how much data was ultimately recovered; we don't repeat a specific figure here because we can't verify which account is accurate.

Frequently asked

What is an AI agent action-approval map?
A deterministic policy that classifies every action an AI agent can take into one of three outcomes: it runs automatically, it requires a human to approve it first, or it's blocked outright. It replaces a vague "is this risky" judgment call with an explainable, testable rule for each specific action.
When does an agent need human approval instead of running automatically?
Whenever an action has real consequence that's hard or impossible to undo cheaply: money moving, a customer-facing message going out, a sensitive field changing, or a production system being touched. Read-only actions with no side effect are the ones safe to automate.
Why is authorization different from approval?
Approval is a human saying yes to a specific proposed action. Authorization is the system independently checking, at execution time, that the actor actually has permission to do that exact thing. An agent that merely asked nicely and got a human's yes still needs the system itself to verify the request before executing it - approval without server-side authorization is just a conversation, not a control.
How do you prevent an AI agent from taking an unsafe autonomous action?
Fail-closed defaults (block unless explicitly permitted), tenant isolation on every read and write, idempotency keys on anything with a duplicate-effect risk, approvals tied to the exact parameters reviewed (never a standing grant), and audit logging on every evaluated decision - not just the ones that executed.

If you already know your agent has unsafe write access somewhere, that's exactly what a Tech Mitrise X-Ray is built to find, and what a free 20-minute triage can scope in one call. For how we think about access and data boundaries generally, see Security and access.