Human approval before risky agent actions.

Some steps are hard to undo: a release, a payment, a deleted table. An agent that takes them on its own needs a clear yes from the right person first. Here is how to build that gate with an MCP tool, so that it works in any AI app and with nobody watching the chat.

For developers6 min readUpdated

Why “Allow this tool?” isn't enough

AI apps already ask before some tool calls. That prompt reaches the person at the keyboard, while the chat is open, and keeps nothing afterwards. A risky step in a background agent needs something else:

  • The right person, who may not be the one running the agent: the tech lead, finance, a client.
  • Time to decide, measured in hours, not in the seconds a chat waits.
  • Proof that the person who said yes is the one who was asked.
  • An end: no answer by a set time means no.
  • A record of who decided, when, how they proved it and why.

The pattern: ask, wait, act only on yes

  1. 1
    The agent prepares everythingIt does all the work that can be undone: builds the release, drafts the payment, lists what it would delete.
  2. 2
    It asks for approvalIt calls request_approval with what it will do, the details and how risky it is.
  3. 3
    The approver decidesThey get an email, open a private page, approve or reject, and confirm with a one-time code or a passkey.
  4. 4
    The agent reads the decisionAs an MCP task that completes, or from its inbox.
  5. 5
    It acts only on approvedRejected, expired or anything else means it stops and reports why.

The last rule matters most. The safe default is no: the agent acts only when the status is exactly approved.

Asking for approval

request_approval takes a few parameters. Only approvers and action are required.

ParameterWhat it is
approvers1 to 10 email addresses, or names of workspace members and contacts.
actionWhat the agent will do if approved, in plain words, as the approver will read it. Up to 200 characters.
detailsWhat changes, why, and how to undo it. Up to 4,000 characters.
risklow (default) or high. High is shown to the approver as a warning.
modeany (default): the first approver to decide settles it. all: every approver must approve, and one rejection rejects.
expires_in_hoursHow long the approval stays open: 24 hours by default, from 1 hour to 30 days.
log_decisiontrue to save the outcome as a team decision, with who decided and their notes.

A release agent asking its tech lead looks like this:

json
{
  "name": "request_approval",
  "arguments": {
    "approvers": ["sara@example.com"],
    "action": "Publish version 2.4.0 to production",
    "details": "All 412 tests pass. Changes: new billing page, faster search. To undo: redeploy 2.3.2 from the releases page.",
    "risk": "high",
    "expires_in_hours": 4,
    "log_decision": true
  }
}

The call charges one credit and returns at once with a request_id and the status pending. If nobody could receive the email, the credit is given back.

Write details for the approver, not for the agent: what will change, why now, and how to undo it. A clear request gets a faster yes, or a well-founded no.

What the approver sees

The approver gets an email that names who is asking, from which workspace and through which AI app or API key. It links to a private page with the action, the details and the risk.

On that page they choose approve or reject and can add a note. The choice counts only with a fresh proof that the address is theirs:

  • A one-time code: Guizzo emails a 6-digit code for that decision, valid for 10 minutes.
  • A passkey of their Guizzo account, if they have one.

A few safeguards keep the agent out of the decision. The private link goes only to the approver, never back to the agent. Opening the link isn't enough, so a forwarded email can't approve. And approvals are decided only on that page: the respond tool refuses them, so no AI can answer one, including the agent that asked.

Reading the decision

With the MCP Tasks extension, the call returns a task, and tasks/get completes with the decision. The guide on MCP tasks, linked at the end of this page, shows the polling. The completed result looks like this:

json
{
  "request_id": "req_01JD4A0C3E5G7J9K1M3P5R7T9V",
  "status": "approved",
  "expires_at": "2026-11-17T13:30:00.000Z",
  "approvers": ["sara@example.com"],
  "risk": "high",
  "mode": "any",
  "decisions": [
    {
      "by": "sara@example.com",
      "decision": "approve",
      "note": "Go ahead, support is staffed until 6.",
      "verified": "passkey",
      "at": "2026-11-17T10:02:17.940Z"
    }
  ],
  "log_decision": true,
  "decision_entry_id": "ent_01JD4A9X2B4D6F8H0K2M4N6Q8S"
}

Without tasks, the agent reads the same request from inbox: its status is pending, approved, rejected or expired, and each answer says how the approver proved it was them.

Whichever way it arrives, the check is the same:

ts
const approval = task.result.structuredContent;

if (approval.status === "approved") {
  await publish("2.4.0");
} else {
  // rejected, expired, or anything unexpected: do nothing risky
  const why = approval.decisions?.find((d) => d.note)?.note;
  report(`Not published: ${approval.status}${why ? ` (${why})` : ""}`);
}

More than one approver

With mode: "any", the first approver to decide settles it, approve or reject. With mode: "all", the approval is granted only once every approver has approved, and the first rejection rejects it. The plan sets whether an agent can wait for every approver.

In mode all, an approval that can't reach every approver isn't sent at all: if one address has stopped requests from your workspace or reached its daily limit, the call fails with no credit used. Otherwise the others' yes would be read as everyone's.

Keeping the record

With log_decision: true, the outcome is saved as a decision when the approval closes, approved or rejected, with the approvers who settled it and their notes. Any agent in the team finds it later with recall, and the completed result names it in decision_entry_id. An approval that expires saves nothing.

To make an agent ask by itself, add a line to its instructions, in CLAUDE.md, AGENTS.md or wherever it reads them:

markdown
- Before an action that is hard to undo (sending, paying, deleting,
  deploying), use the Guizzo `request_approval` tool and act only
  if the status is approved.

In an app with Guizzo connected, a plain sentence works too: “Before you publish to production, get Sara's approval.”

Questions

Good to know.

Can the agent approve its own request?

No. Approvals are decided only on their own web page, with a code or a passkey. The link never goes back to the agent, and the respond tool refuses approvals.

What happens if nobody decides?

The approval expires, after 24 hours unless the agent set another time, and its status becomes expired. Treat it as a no.

Does the approver need a Guizzo account?

No. They decide from the email's link and confirm with a code sent to that address. A passkey needs an account.

How much does an approval cost?

One credit from the workspace's monthly allowance. Deciding is always free for the approver, and the credit is given back if nobody could receive the request.

Free beta

Give your agent someone to ask.

Sign up with your email and create your workspace. We open Guizzo to new teams a few at a time: if every place is taken, you join the queue and we write when yours is ready.

Free during the beta. We send a code to sign in, no password. If every place is taken you join the queue, and we write when yours is ready. Privacy policy