Skip to content

Approve an agent’s action before it happens

Add human approval to specific agent actions with digest-bound, single-use authorization and cooperative SDK checkpoints.

An approval should name the exact action it allows

For consequential operations, a broad instruction to proceed is not enough. Integrate a guarded action so the runner requests a decision tied to the exact operation it intends to perform.

GitHub tools is waitingApprove a tool call?Held
github__merge_pull_request

The arguments stay on your machine. This approval covers this one call only.

Maya R.Engineering lead
Deny Approve
Approved by Maya R. The call ran once.
Illustration with sample data
  1. Bind the request to the action

    The compatible runner submits a safe title, a digest of its local action snapshot and, if it chooses, redacted fields from that snapshot. Review the proposed operation against that local record before approving it.

  2. Consume authorization once

    A compatible runner consumes the approved authorization before executing that guarded operation. Changed parameters require the corresponding authorization; an approval is not a blanket permission slip.

  3. Pause at a real checkpoint

    Pause, resume, and cancellation are cooperative. Your runner needs compatible checkpoints to receive and handle the decision. Requested and acknowledged states mean different things.

Approve the exact action, not a vague intent

A useful approval names precisely what it allows. “The agent may send the invoice” is too broad; “send invoice 1042 to Acme for $4,280” is what a reviewer can actually check. Toolcaise approvals are bound to the exact action your code is about to perform.

  1. Your code describes the action as JSON: every parameter that matters for execution.
  2. The SDK sends Toolcaise a safe title and a digest of that JSON, never the whole action: only the fields you choose to show, redacted.
  3. A person approves or denies it in the dashboard, seeing the title and those fields as reported by the agent. If the agent’s last decided request in the past 30 days with the same title and destination had other parameters, the dashboard says so.
  4. Your code receives a frozen copy of the approved action and executes exactly that. The approval is consumed once and cannot be reused.

Add it to your code

def send(action):
    return billing.send_invoice(action["invoice"], action["to"])

client.guarded_action(
    "Send invoice 1042 to Acme",
    {"invoice": 1042, "to": "acme", "amount_usd": 4280},
    send,
    show_fields=["invoice", "to", "amount_usd"],
)
Python, inside a run. Node.js has the same call.

If the person denies it, the approval expires, or Toolcaise cannot be reached to confirm the decision, the call raises and your function never runs. Approvals fail closed in every mode.

Pause, resume and cancel

Beyond single actions, a run can be paused, resumed or canceled from the dashboard. Through the SDKs these are cooperative: your code calls checkpoint() between safe steps, where it waits while paused and stops cleanly when canceled. For a stop that does not depend on the agent’s cooperation, run it under Toolcaise Connect, which can end the whole process tree.

Rules for MCP tool calls

If your agent works through MCP tools, put Toolcaise Connect’s gateway in front of the MCP server to allow or deny tools by name and cap how many calls a session makes. With --remote-control, the dashboard can also change those rules and hold a specific tool call for a person’s approval.

Who can approve, and what gets recorded

Workspace owners and admins decide approvals. Each decision records who made it, when and any note they left, and the workspace shows the approver’s email address.

  • An approval that nobody decides expires. It never quietly turns into a yes.
  • If the run that asked for it ends, a pending approval lapses and can no longer be granted.
  • A denial stays a denial; it cannot be reversed into an approval for the same action.

Where approvals stop

An approval proves a person allowed an action. It does not prove the action happened or that the destination received it: the external system is the only source of that. Approvals also only guard code that goes through the integration, so an action your agent performs another way is not covered.

Frequently asked questions

How do I add human approval to an AI agent?

Wrap the consequential call in the SDK’s guarded_action with a title and the exact parameters. The agent waits until a person approves it in Toolcaise, then runs the approved action once. Denials, expiry and loss of contact with Toolcaise all stop the action instead of letting it through.

What happens if nobody responds to an approval?

It expires and the action does not run. If the run that requested it has ended, the approval lapses immediately. Nothing is ever approved by default.

Can an approval be reused for a similar action?

No. It is bound to a digest of the exact action and consumed on first use. If any execution-relevant parameter changes, the code has to request a new approval. When your agent’s last decided request with the same title and destination, made in the 30 days before, had other parameters, the dashboard says so and shows which of the fields it shared changed, so keep the title the same for the same action and share what can change as fields.

Does approval work with MCP tools?

Yes. The Toolcaise Connect MCP gateway allows or denies tools by name and caps calls per session, and with --remote-control and --require-approval it holds a matching call until a person approves it in the dashboard. The approver sees the tool name; the arguments stay on the machine.

Connect your first agent

Create a free workspace, connect the agent you already run, and watch its next run arrive. Free covers 3 agents, with no card required.