Skip to content

Approval Flow

Agents increasingly take consequential actions, so they need a clean way to pause and ask a human — confirm, approve — and then continue. MCP’s URL-mode elicitation can push a native “open this link?” prompt to the host, but host support for it is inconsistent.

Write the approval skill once; the server adapts. Your skill always makes the same calls — elicit_approval, then elicit_await, then elicit_result. Underneath, the server pushes a URL-mode elicitation prompt only to hosts that advertise support for it; every host reaches the same outcome through the same long-poll.

Flowchart: elicit_approval checks whether the host advertises URL elicitation; if so it pushes a best-effort URL prompt. Either way the skill long-polls with elicit_await, which wakes when the reviewer decides in the review page, then elicit_result returns the decision and data.

Every approval request goes to you, the person whose agent asked. You can answer on any device, and everything is tied to your sign-in. That’s a deliberate design choice.

Elicitly adds a human-in-the-loop checkpoint to an otherwise AI-driven workflow. Before your agent writes to the CRM, sends the email, or spends the money, it stops and shows you exactly what it’s about to do. You approve it, change it, or stop it, and that decision is recorded with the exact data that runs. Your agent does the work; you keep the judgment.

The checkpoint is part of your workflow, so you can always step around it, for example by telling your agent to skip the step. For that reason, Elicitly doesn’t send requests to a second person: an approval the requester could route around would look like a control without being one. When a process must be enforced, such as separation of duties or a sign-off an auditor relies on, put that check in the system that performs the action, or in a custom agent whose code requires approval before it acts.

For the everyday work of keeping an agent honest, a checkpoint is the right tool: quick to add to any skill, and it works in every host.

elicit_approval takes either (or both) of two inputs, and the review page adapts:

  • JSON mode — pass context, a read-only payload. The reviewer sees it and approves or declines it as-is; elicit_result hands it back verbatim, so the human approves exactly what runs.
  • Form mode — pass a requestedSchema (the flat MCP elicitation subset: strings, numbers, booleans, single/multi-select enums). The review page renders a validated web form; the reviewer’s submission comes back as formSubmission. Use form mode to collect a decision and structured input — a rollback plan, an amount, sign-off initials — in one approval step. Form mode must not request secrets or credentials (per the MCP spec).

Pass both to show read-only context above a form. Whichever you use, the pause/resume flow below is identical.

Four tools drive the flow — each has its own reference page with exact input/output shapes:

  • elicit_approval — record the request and (best-effort) push a URL-mode prompt; always returns reviewUrl.
  • elicit_await — bounded long-poll until the request is decided or the wait bound elapses.
  • elicit_status — non-blocking status read.
  • elicit_result — fetch the reviewer’s decision plus the approved data (idempotent, every fetch recorded).
Sequence: the skill calls elicit_approval and gets an elicitation ID and review URL; if the host supports URL mode, the server pushes a prompt to open the review page. The skill waits with elicit_await, the reviewer approves, the wait wakes, and elicit_result returns the decision.

The skill’s column never changes. The URL push is the only capability-dependent step, and both paths converge on the same elicit_await wake.

elicit_await is bounded so it always returns before the host’s tool-call timeout. Two ways it returns:

  • A decision landed — the reviewer submitted or declined; the call wakes immediately with that status.
  • The bound elapsed — it returns "pending"; call elicit_await again to keep waiting.

That single loop works everywhere: on a URL-capable host the reviewer likely acts on the pushed prompt; on any other host they open reviewUrl — either way the same wake resolves the same loop.

Every request carries a TTL (expiresInSeconds, default 1 hour, clamped 60 seconds to 7 days). Once it passes, the request is expired — a terminal state. elicit_await and elicit_status both report "expired" at the deadline, and the review page refuses a late decision. Ask the agent to resend if that happens.