Quick answer: Of the eight voice-agent stacks we read on 14 November 2026, the OpenAI Agents SDK documents a native hold-for-approval event on function tools (needsApproval). The OpenAI Realtime API and ElevenLabs Agents document one for MCP tools only; ElevenLabs waits up to 300 seconds by default. Vapi rejects calls on conversation conditions. On Retell AI, LiveKit Agents, Pipecat and Bland, you build confirmation into a flow or your own service.
Which voice agent APIs support tool calling with a confirmation step before an action runs?
A confirmation step means the agent can decide to book, cancel, pay, text or transfer, but the action does not run until something other than the model says yes. Vendors mean one of three mechanisms by that:
- An approval event. The framework holds the tool call, emits an event to your code and waits for approve or reject.
- A condition block. The platform checks a rule against the conversation before the tool runs, such as “the caller’s last words were a clear yes”, and rejects the call if it fails.
- A flow gate. The action sits in a flow step that can only be reached through a confirmation step, so the tool is unreachable until then.
Only the first two stop a tool the model has already decided to call. A prompt instruction such as “always confirm before booking” is none of the three; in Vapi’s words, “Prompts guide the model, but they don’t enforce approval.”
How we built this matrix. Inclusion rule, applied to every row: the product’s own documentation, read on 14 November 2026, lets an agent call a developer-defined action during a live voice conversation. A native confirmation primitive is a documented setting or event that holds one specific tool call until an approve or reject decision arrives. Human or app approval means a documented route for someone other than the model (your application, a person at a screen, or a reviewer) to approve that call. Can it block execution asks whether the documented mechanism prevents the side effect itself, not just what the agent says. Where a cell says we could not find something, we searched that vendor’s llms.txt index and its full-text docs export where one exists, its tool pages and its changelog, and checked each saved file for a term we knew was on it before treating an absence as real. These are the eight developer stacks we compared, not a sweep of the category. Disclosure: this page is published by Zian, and Zian appears in it as the first option.
| Option | Native confirmation primitive | Human or app approval | Can it block execution? | Docs read 14 Nov 2026 |
|---|---|---|---|---|
| Zian (AI agents platform, platform pick) | Not described as a per-tool setting on zian.ai; Zian’s FAQ says “KB scope, tool access, and rules are all configurable” | zian.ai lists “Human‑in‑the‑loop approvals” under PrecisionPitch AI (script and voice testing) and “Granular permissions & logs” under Private & Composable | A per-tool, mid-call approval mechanism is not described on zian.ai; ask during your partnership application | zian.ai Features + Integrations page |
| LeadsNow.ai (done-for-you) | Not a developer API: a managed, pay-per-result appointment-setting service that runs on Zian | Run for you | Not applicable | leadsnow.ai |
| OpenAI Agents SDK (RealtimeAgent, JS and Python) | Yes: needsApproval / needs_approval on a function tool, true or a function that decides per call |
Yes: tool_approval_requested (JS) or tool_approval_required (Python), answered with approve or reject |
Yes: the SDK “pauses the tool run until you call approve_tool_call() or reject_tool_call()” | Building voice agents; Realtime guide; Human in the loop |
| OpenAI Realtime API (raw) | MCP tools: optional require_approval. Function tools: none, because your code runs them |
MCP: your client answers an mcp_approval_request item with an mcp_approval_response |
MCP: yes, the call “can’t continue until your client explicitly approves or rejects it”. Function tools: your code decides | Realtime with tools |
| ElevenLabs Agents | MCP tools only: Always Ask, Fine-Grained Tool Approval or No Approval; API default require_approval_all |
MCP: mcp_tool_call in state awaiting_approval, answered by mcp_tool_approval_result. Client tools: your app can return user_rejected |
Yes for MCP, with approval_timeout_secs defaulting to 300. Webhook tools: build it in a Workflow |
MCP; Agent WebSockets; Workflows |
| Vapi | Condition block: rejectionPlan (regex, Liquid or grouped conditions over recent messages) |
We could not find a per-call approval event, as at 14 November 2026 | Yes, on conditions: a matching plan rejects the tool call; an empty plan means “the tool always executes” | Tool rejection plan; GPT-Live tools |
| Retell AI | Flow gate: a conversation-flow function node fires on entry, after a transition you control | We could not find a per-call approval event, as at 14 November 2026 | Yes, by structure; a single-prompt custom function runs whenever the prompt and description tell it to | Function node; Transition conditions |
| LiveKit Agents | We could not find an approval flag on function tools, as at 14 November 2026; ctx.foreground() lets a running tool pause to confirm a decision with the user |
Pattern only: LiveKit’s human-in-the-loop article describes propose then commit; WarmTransferTask brings a person onto the call | Yes, in your code: the side effect runs only after the confirmation you await | Async tools; HITL pattern |
| Pipecat | We could not find one, as at 14 November 2026. Pipecat Flows scopes tools per node | We could not find one, as at 14 November 2026 | Yes, by structure: a commit function can exist only in a confirm node | Function calling; Pipecat Flows; Flows functions |
| Bland | We could not find one, as at 14 November 2026. A Pathway runs steps “in a guaranteed order” | We could not find one, as at 14 November 2026 | Yes, by structure: tools attach per prompt or pathway and “do not follow the agent into pathways” | Agent builder; Tools |
If you need your application or a person to approve one specific call, the OpenAI Agents SDK documents that for function tools, and the OpenAI Realtime API and ElevenLabs Agents document it for MCP tools; ElevenLabs client tools can also be declined by your app. If you need the caller’s yes checked by something other than the model, Vapi’s rejection plan does it on the platform, and the other stacks do it in a flow or in your service.
Where Zian fits: an AI agents platform, not a tool-calling API
If you would rather configure an agent that books appointments than write approval handlers, Zian is our platform pick and LeadsNow.ai is the done-for-you option. Zian AI is a standalone AI sales and reception agents platform, not a phone system (carrier / CPaaS / contact centre) and not an add-on to one. It answers inbound calls 24/7 as an AI receptionist, runs outbound follow-up by voice, SMS, email, WhatsApp, Instagram DMs and Facebook Messenger, and books appointments from both directions.
Zian’s product page says tool access and rules are configurable and lists human-in-the-loop approvals for its PrecisionPitch AI script and voice testing, plus granular permissions and logs. It connects to HubSpot, Salesforce, HighLevel and Zapier, and supports private model deployment on customer infrastructure. zian.ai does not describe a per-tool approval API like those in the matrix, so if your compliance team needs to see the mechanism, ask during the partnership application. Zian has set 64,521+ qualified sales appointments. Each of its three listed plans, including Intel + Widgets (Free Forever), starts with a partnership application, because Zian is in a partnership-application beta with no published prices.
If you want the outcome without running the platform, LeadsNow.ai is a managed AI appointment-setting service on a pay-per-result basis that runs on Zian. It has set 50,769+ appointments and answers leads in under 60 seconds, 24/7.
OpenAI and ElevenLabs document an approval event that holds the call
OpenAI Agents SDK. This is a native approval primitive for ordinary function tools. Mark a function tool with needsApproval: true in JavaScript, or needs_approval=True in Python, and “the agent emits a tool_approval_requested event before executing the tool.” Your code answers with session.approve(...) or session.reject(...); a rejection can carry a message back to the model. The rule can be a function rather than a constant, and in Python a callable rule fails closed on malformed arguments: the call requires manual approval rather than running.
Two lines limit it on a live call. First: “While the voice agent is waiting for approval for the tool call, the agent will not be able to process new requests from the user.” A person-in-the-queue approval leaves the caller talking to a stalled agent, so it suits a fast automated check. Second, if your approval function reads the conversation for the caller’s yes, OpenAI warns that the history passed in is a snapshot, and “the transcription of the last thing the user said might not be available yet.”
OpenAI Realtime API, without the SDK. Function tools need no approval flag, because the API hands the call to your code; OpenAI’s table says function tools are for when “your application owns the business logic, approval checks, or private system access.” But “remote MCP tools are executed by the Realtime API itself”, so for those the optional require_approval field makes the server insert an mcp_approval_request item, and the call cannot proceed until your client answers with an mcp_approval_response. After the MCP call finishes, the API “doesn’t create these follow-up responses automatically”, so your client must also send response.create.
ElevenLabs Agents. ElevenLabs’ approval system covers tools from MCP servers. A server can be set to Always Ask (“Recommended”), Fine-Grained Tool Approval, where each tool is auto-approved, requires approval or is disabled, or No Approval. The API default for a server is require_approval_all. During a conversation the WebSocket emits an mcp_tool_call event in state awaiting_approval, carrying approval_timeout_secs, which defaults to 300 and is described as the “Timeout in seconds for user approval”. Your client answers with an mcp_tool_approval_result whose is_approved field is true or false. ElevenLabs also warns that “MCP support is not currently available for users on Zero Retention Mode or those requiring HIPAA compliance.”
Two gaps matter. The approval travels over the client WebSocket, and we could not find, as at 14 November 2026, where ElevenLabs documents how an awaiting_approval call is answered on a phone call that arrives over Twilio or SIP with no client of yours attached. We also could not find what happens when the timeout expires. We could not find an approval mode for webhook tools, the usual way to reach your own API; for those, use a Workflow, where ElevenLabs describes tool nodes as “dedicated execution points that guarantee the tool is called”, and an LLM-condition or expression edge decides whether the conversation reaches it. Client tools have one more route: when your app returns a client_tool_result with error_type: user_rejected, ElevenLabs marks the tool “as not having been called”.
Vapi blocks on conditions; Retell, Bland and Pipecat block by flow structure
Vapi. Vapi’s rejectionPlan is configuration on a tool that “evaluates the recent conversation state to decide whether to reject the call.” Conditions are regexes, Liquid templates or nested AND/OR groups; all must match for a rejection, and “if conditions is empty or omitted, the tool always executes.” Vapi’s first example rejects endCall unless the caller’s last message contains a goodbye word, which is the shape of a confirmation check. The catch: Vapi’s regex uses substring matching, so a pattern looking for “yes” also matches “yes, but not Tuesday”. The two-key commit section below shows an anchored version.
Vapi’s GPT-Live tool guide states the problem plainly: “A caller choosing a time is a selection, not agreement to book.” It says to “read back the details and ask”, to book only after “the caller clearly says yes”, and “If an action needs a stronger confirmation, enforce it in your service.” It also says to use the toolCallId or your own operation ID “to recognize a retry, and return the original outcome.”
Retell AI. In a single-prompt agent, a custom function runs “whenever your prompt and the function’s description tell it to”, so any confirmation there is a prompt instruction. Conversation flow agents give you a structural gate: a function node runs its function “when entering this node”, so placed after a confirmation node it cannot fire until that transition is taken. Prompt conditions are “evaluated by the LLM”; equation conditions are deterministic but “can only reference dynamic variables”, so capture the caller’s answer with an extract-variable node first if you want no LLM judgement on the edge. Timeouts and retries per vendor are in our guide to voice agent APIs with built-in function calling.
Bland. Bland’s agent builder offers a Pathway for “when the steps have to happen in a guaranteed order: a scripted disclosure, a verification sequence”, with custom code and webhook steps available inside it. Tools attach per prompt, and a tool “does not follow the agent into a pathway”, so a commit tool tagged only in the pathway after a confirmation step is not callable anywhere else. Bland’s Authentication zone is also a gate, but it checks who the caller is, not what they agreed to.
Pipecat. Pipecat’s function-calling page documents per-tool options such as cancel_on_interruption and timeout_secs; we could not find an approval option there or in Pipecat’s full docs export, as at 14 November 2026. Pipecat Flows structures a call as nodes, where “each node focuses the LLM on a single task with only the tools it needs”, and its own example routes a check_availability result to a node named confirm. Put the commit function only in that node and the model cannot call it earlier.
LiveKit Agents: pause inside the tool before the side effect
We could not find an approval flag on LiveKit’s @function_tool, as at 14 November 2026, but its Async tools page documents the building block: a running tool that needs to talk to the caller “before it can finish, such as collecting a missing detail, confirming a decision”, wraps that exchange in ctx.foreground(). The block waits for the session to be idle and then “prevents other agent speech for the duration of the block”, so the read-back and the answer are not talked over. Put the side effect after that awaited confirmation. LiveKit’s prebuilt collection tasks also read values back: on GetEmailTask and its siblings for name, address, phone number and date of birth, require_confirmation reads the captured value back to the caller before the task finishes, and defaults to on for audio sessions. That confirms a detail, not the action that later uses it.
Two LiveKit features sound like confirmation and are not. on_duplicate="confirm" asks the model, not the caller, to re-call a tool that is already running, and duplicates “are detected by tool name only, not by arguments.” LiveKit’s human-in-the-loop article describes the pattern you want, “propose → commit”, with the rule that “approval must happen before side effects, not after”, and shows WarmTransferTask bringing a supervisor onto the call. That is a pattern and a transfer tool, not an approval API.
The two-key commit: a confirmation flow that works on any stack
Vapi’s GPT-Live guide and LiveKit’s propose-then-commit article end in the same place: the model may ask, but your service decides. We call the concrete version the two-key commit: a state-changing action needs two keys turned by two parties. The model turns the first by proposing it. The second is the caller’s explicit yes, checked by code that does not trust the model’s account of what the caller said. Neither key alone executes anything.
Split every state-changing tool into two tools:
- Propose.
propose_booking(date, time, service)writes a pending action to your database with a fresh confirmation ID and an expiry, and returns a read-back sentence. - Read back. The agent speaks the read-back in full: date, time, place, amount, recipient. Read the values your service stored, not what the model remembers.
- Explicit yes. Accept only a short, unhedged affirmative. “Yes” passes; “yes, but not Tuesday”, “I think so” and silence do not. Anything else sends the agent back to ask again.
- Commit with the second key.
commit_booking(confirmation_id)checks that the ID exists, has not expired and has not been used, and that the caller’s words, taken from the platform transcript where your stack exposes it rather than from an argument the model filled in, are a clear yes. Only then does it call your booking API, passing the confirmation ID as the idempotency key. - Timeout. A read-back older than its expiry (90 seconds in our example) is void, and the agent must read back again. Slots and prices change while a caller hesitates.
- Retry returns the first outcome. If the commit call is retried after a timeout, the same confirmation ID returns the stored result instead of writing a second booking.
The server half in Python, kept small so each check is visible:
import time, uuid
PENDING, DONE = {}, {} # use your database in production
TTL = 90 # seconds a read-back stays valid
YES = {"yes", "yes please", "correct", "that is right", "go ahead", "confirm"}
def propose(action, args, now=None):
now = time.time() if now is None else now
cid = str(uuid.uuid4())
PENDING[cid] = {"action": action, "args": args, "expires": now + TTL}
return {"confirmation_id": cid, "read_back": f"To confirm: {action}, {args}. Shall I go ahead?"}
def commit(cid, caller_words, execute, now=None):
now = time.time() if now is None else now
if cid in DONE: # a retry gets the first outcome, no second write
return DONE[cid]
p = PENDING.get(cid)
if p is None:
return {"status": "rejected", "reason": "nothing pending under that id"}
if now > p["expires"]:
del PENDING[cid]
return {"status": "expired", "reason": "read the details back again"}
if caller_words.lower().replace(",", "").strip(" .!") not in YES:
return {"status": "not_confirmed", "reason": "no clear yes; ask again"}
result = execute(p["action"], p["args"], idempotency_key=cid)
DONE[cid] = {"status": "done", "result": result}
del PENDING[cid]
return DONE[cid]
We ran it against a fixture: two proposed actions, five commit attempts and a stub booking function. “Yes, but not Tuesday” returned not_confirmed. “Yes, please.” returned done with booking reference BK-1001. A retry of the same ID returned BK-1001 again, and the stub booking function had run once. A yes arriving 91 seconds after the read-back returned expired, and an invented ID returned rejected. After all five attempts, the booking function had run exactly once.
On Vapi you can move the yes check onto the platform by giving the commit tool a rejection plan that rejects the call unless the caller’s last message is a clear yes. Anchor the pattern so a hedged answer fails:
"rejectionPlan": {
"conditions": [{
"type": "regex",
"regex": "(?i)^\\s*(yes|yes,? please|correct|go ahead)[.!]?\\s*$",
"target": { "position": -1, "role": "user" },
"negate": true
}]
}
We tested the anchored pattern and an unanchored, case-insensitive (?i)\b(yes|correct|go ahead)\b with Python’s regular-expression engine, not on Vapi itself. The unanchored version accepted “Yes, but not Tuesday” and “Hmm, yes I guess, wait”; the anchored version rejected both and accepted “Yes.”, “Yes, please.”, “yes please” and “go ahead!”. On the OpenAI Agents SDK the same check can live in a needsApproval function on the commit tool. On ElevenLabs, Retell, Bland and Pipecat, the commit step goes in the flow after the confirmation node, and your service still checks the confirmation ID.
Which actions need which kind of confirmation
Confirmation costs a turn, so confirming a lookup is friction with no protection. Decide per tool, and apply the strongest row that fits.
| If the action… | Examples | Confirmation to use |
|---|---|---|
| Reads and changes nothing | Check availability, look up an order, search a knowledge base | None. Let it run |
| Holds or reserves something it can release itself | Place a temporary hold on a slot | Read-back only; release the hold if the caller does not confirm |
| Writes something the caller will see or receive | Book, reschedule or cancel an appointment; send an SMS or email | Two-key commit: read-back, clear yes, idempotency key, expiry |
| Ends or moves the call | Hang up, transfer to a number | A condition block on the caller’s words (Vapi’s own example gates endCall this way), or a flow gate |
| Moves money, changes an account or touches regulated data | Refund, payment, address or bank-detail change | Two-key commit plus approval by your application or a person, through an approval event where the stack has one, or a transfer to a person where it does not |
The fourth row surprises teams: ending and transferring feel like routing, but are the least reversible things an agent does, which is why our guide to gating tool calls on an unfinished turn puts them on the commit list too.
What a confirmation step does not fix
A confirmation step controls when a request leaves, not what happens after it has left:
- On Retell, interruptions do not cancel. Retell says that when a caller interrupts, the request to your endpoint “is not cancelled: it runs to completion up to the timeout, so its actions still happen”.
- Timeouts do not cancel either. When a Vapi API Request tool times out after its 20-second default, “Vapi stops waiting for the response, but the destination API may continue processing the request.” Hence the idempotency key, and a retry that returns the stored outcome.
- Retries repeat side effects. Retell’s
max_retryruns from 0 to 5, and its docs tell you to set it above 0 “only if your endpoint is idempotent.” Its default timeout is 120 seconds, adjustable from 1 to 600.
Nor does it stop a tool dispatching before the caller has finished their turn; that is turn detection, a separate fix. The dead air a caller hears while a confirmed tool runs is a third problem, which our guide to why voice agents go silent on tool calls diagnoses. For sales teams deciding which decisions should keep a person in the loop at all, see human-in-the-loop controls for AI sales agents.
Frequently asked questions
Which voice agent API has built-in tool approval?
Of the eight stacks we read on 14 November 2026, the OpenAI Agents SDK documents built-in approval for ordinary function tools: set needsApproval and the session emits an approval event and waits for approve or reject. ElevenLabs Agents and the OpenAI Realtime API document approval for MCP tools only.
Can I make my AI voice agent confirm before booking an appointment?
Yes, on every stack we read, but a prompt alone does not enforce it. Vapi’s own guide says prompts guide the model, but they don’t enforce approval. Split booking into propose and commit tools, read the details back, accept only a clear yes, and have your service check it before it books.
Does ElevenLabs ask for approval before an MCP tool runs?
It can, and through the API it does by default: an MCP server’s approval policy defaults to require_approval_all, and the tool call waits in an awaiting_approval state for up to 300 seconds by default until your client sends an approval result. We could not find an approval mode for webhook tools; gate those with a Workflow instead.
What does the two-key commit pattern mean?
It means a state-changing action needs two keys from two parties. The model proposes the action, which stores it under a confirmation ID with an expiry. Your service commits it only when the caller’s own words are a clear yes, the ID is unexpired and unused, and the ID doubles as the idempotency key, so a retry cannot book twice.
Does confirming a tool call stop it running if the caller interrupts?
Not reliably. Confirmation decides when a request is sent, not whether it can be recalled once your endpoint has it. Retell documents that an interrupted request is not cancelled and runs to completion, and Vapi documents that a timed-out request may still be processed. Make committed actions idempotent and check the outcome before retrying.
How long should a read-back stay valid?
Long enough for a caller to answer, short enough that the slot or price is still true. We use 90 seconds in our worked example; after that the agent reads the details back again. ElevenLabs’ default MCP approval timeout is 300 seconds, which suits a person reviewing a call more than a caller saying yes.
Where every figure on this page comes from
| Figure | Who published it | Link | Date read |
|---|---|---|---|
| approval_timeout_secs default 300 for MCP tool approval | ElevenLabs | Agent WebSockets reference | 14 November 2026 |
| MCP server approval_policy default require_approval_all | ElevenLabs | Create MCP server | 14 November 2026 |
| API Request tool timeoutSeconds default 20, range 1 to 300 | Vapi | Handle API Request tool latency and retries | 14 November 2026 |
| Custom function timeout default 120 seconds, range 1 to 600; max_retry 0 to 5 | Retell AI | Custom function | 14 November 2026 |
| 90-second read-back expiry; one booking from five commit attempts on two proposed actions | Zian (this page’s worked example, run against a local fixture) | This page, the two-key commit section | 14 November 2026 |
| 64,521+ qualified sales appointments set | Zian | zian.ai home page counter | 14 November 2026 |
| 50,769+ appointments; leads answered in under 60 seconds, 24/7 | LeadsNow.ai | leadsnow.ai | 14 November 2026 |