Voice Agent node
Answer a phone call with a realtime AI voice agent that can speak, listen, call your app actions mid-call, and hand a transcript to the rest of the workflow.
The Voice Agent node answers a phone call. A caller dials your number, the agent greets them, the two of them talk, and when the call ends the rest of the workflow runs with the transcript, a summary and any structured data the agent captured.
It is the only node that can answer a Twilio Phone Call trigger — and a Phone Call trigger is the only thing it can answer.
The Voice Agent and the Phone Call trigger are in beta and are enabled per environment. If you do not see "Voice Agent" in the Add Node panel, the lane is not turned on for your workspace yet.
What it does
- A call arrives on your Twilio number and the Phone Call trigger fires.
- Within 10 seconds, the Voice Agent answers and the caller is connected to the model.
- The agent speaks your greeting, then listens. The caller can interrupt it mid-sentence.
- When the agent needs something from one of your apps — an order status, a booking slot — it calls one of its tools, which is an ordinary app action.
- The call ends. The agent is asked your wrap-up question, and its answer, the transcript and (optionally) the recording land on the step output.
- The workflow continues with the steps after the Voice Agent.
Build one
Start from a Phone Call trigger
Add the Twilio Phone Call trigger and pick the number this workflow answers.
Add the Voice Agent
Add a Voice Agent node downstream of the trigger. Keep the path between them short — see The 10-second answer window.
Add your Gemini API key
The agent talks through Gemini Live on your own key. Create a key in Google AI Studio, then add it under AI → LLM keys with the provider Google Gemini. TaskJuice checks that Google accepts the key before saving it. The key's project also needs Live API access, which only the first call can confirm.
Attach a model
Drag from the Voice Agent's model port to add a Model sub-node, pick your Google Gemini key as the connection, and choose a model. Only realtime-capable models are listed here; a text-only model cannot hold a conversation over audio. Attach the key you added under AI → LLM keys: a key pasted straight into the node cannot be used for a call.
Write the system prompt
The System prompt field sits at the top of the Voice Agent's panel. Write who the agent is and what it is allowed to do, exactly as you would for an AI Agent. You can bind a prompt from the prompt library instead of typing it inline.
Attach tools (optional)
Drag from the tools port to add a Tool sub-node per app action the agent may call during the call. Each tool has its own approval risk level and its own Delivery setting.
Publish
Publishing points the number's voice URL at this workflow. Unpublishing restores whatever it pointed at before.
Fields
| Field | Type | Default | What it does |
|---|---|---|---|
| Greeting | text | none | Spoken first, before the caller says anything. Supports {{ }} references to the trigger, so you can greet a known caller. |
| Variables | key/value | none | Values resolved once when the call is answered and available to the model as {{ name }} inside the prompt. |
| Language | select | English (US) | The language the agent speaks and listens in. |
| Barge-in | toggle | on | Lets the caller interrupt the agent mid-sentence. Turning it off makes the agent finish every sentence before it listens. |
| Recording | toggle | off | Records the call audio and stores it with the run. |
| Max seconds | number | 900 | Hard ceiling on the call, 30–900 seconds. The call ends at this limit whatever is being said. |
| Wrap-up | text | none | Asked of the model after the caller hangs up; the answer lands in summary. |
The model, tools and memory are sub-nodes on the canvas, not fields in this panel — the same composition the AI Agent node uses.
Whether you may record a call, and whether you must announce it, depends on where the caller is. Announcing it is your responsibility — put it in the greeting.
Tools and Delivery
A Voice Agent's tools are app actions. Each Tool sub-node carries a Delivery setting, which decides what happens to the conversation while the action runs:
| Delivery | What the caller hears | Use it for |
|---|---|---|
| Let the agent keep talking (default) | The agent carries on; the result is spoken when it lands. | Anything the agent can talk around — "let me check that for you…". |
| Wait for result | The agent pauses until the action finishes, up to 8 seconds. | A short lookup whose answer is the next thing the agent must say. |
| Run after the call | Nothing — the action runs once the call has ended. | Work the caller does not need to wait for: a CRM note, a follow-up email. |
Every mid-call tool call becomes a real step on the run, with its own cost, audit trail and approval policy. A tool that needs approval is not silently skipped — the agent is told it could not run it.
Only app actions can be tools. A sub-workflow or a think tool is refused at publish.
The 10-second answer window
A telephony provider will not wait long for a workflow to answer. TaskJuice has about 10 seconds from the moment the call arrives to the moment the Voice Agent picks up, and everything between the trigger and the Voice Agent runs inside that window.
That is usually plenty — but an HTTP call to a slow API, or an AI step, can spend it. When the publish bar sees one of those on the path it warns you: "… runs before the Voice Agent and may take longer than the 10-second answer window. The caller hears an error if it does."
If you need to enrich the call with slow data, do it after the Voice Agent, or push it into a tool with Delivery set to Run after the call.
What the node outputs
The steps after the Voice Agent read its output as $steps.<node>.data:
| Field | Type | Description |
|---|---|---|
callSid | string | The provider's id for the call. |
from / to | string | The two numbers, in E.164. |
durationSec | number | How long the call lasted. |
outcome | string | How it ended — see below. |
transcript | array | The turns, each { role, text, at }. A long transcript is stored alongside the run and hydrated on demand. |
summary | string | The model's answer to your wrap-up question, when you set one. |
extracted | object | Structured data captured during the call, when the wrap-up asks for a shape. |
tools | array | One entry per mid-call tool call, with its status and duration. |
recordingRef | string | Where the recording is stored, when recording was on. |
Outcomes
outcome | Meaning |
|---|---|
caller_hung_up | The caller ended the call. The most common outcome. |
agent_hung_up | The agent ended the call, or an operator pressed Hang up in the run detail. |
completed | The conversation finished cleanly on both sides. |
timed_out | The call hit Max seconds. |
provider_error | The model or the telephony provider failed mid-call. |
gateway_lost | The call ended without a final record. The transcript is what was captured up to that point. |
no_transport | The node ran with no call attached — a node test, a manual Run now, or after the caller was answered elsewhere. |
refused_capacity | The workspace was already at its concurrent-call limit. The caller heard a busy message. |
A step that never placed a call still completes — no_transport and refused_capacity are outcomes, not failures — so the steps after it run and can react.
Watching a call
A run that answered a call shows two extra cards under Monitoring → Runs:
- The Call card on the run overview: from, to, duration, the call id, and a live "Call in progress" badge while the caller is still on the line. The call's spend is the run's BYOK cost on the metadata card above it, not a second figure here. While the call is live, a Hang up button sits beside Cancel. It asks the agent to say goodbye and end the call; the run then continues with the steps after the Voice Agent.
- The Call transcript card: the turns with visible speaker labels, the wrap-up summary, and the recording player when recording was on.
To find call runs specifically, open More filters on the runs list and set Trigger to Phone call.
Limits
- Inbound only. Placing a call is not available yet.
- 900 seconds is the hard ceiling on one call.
- Tools must be app actions. Sub-workflows and think tools are refused at publish.
- One response point. A Respond node between the trigger and the Voice Agent is refused — the Voice Agent must answer the call itself.
- Concurrent calls are capped per workspace. Past the cap, the caller hears a busy message and the run records
refused_capacity.