Voice Agent Node

Configures an agent that talks to people out loud. HostWebhook does not carry the audio: it provisions the agent on ElevenLabs, and then becomes the part that matters — the tools the agent can call, the knowledge it can look things up in, and the record of what was said.

Where the work actually happens

Worth understanding before you configure anything, because it explains why some settings live here and some live at the provider.

textProvision and proxy

Person speaks
  → provider (ElevenLabs)                      ← audio, turn-taking, latency
      → agent decides to call a tool
        → HostWebhook webhook                 ← your flow runs here
          → nodes: query a database, book a slot, send an email
        ← result goes back
  ← agent speaks the answer

The provider owns the microphone, the voice and the sub-second turn-taking — problems already solved, and not where HostWebhook adds anything. What you get here is that the agent's tools are your flows, its knowledge base is your Vector Stores, and every call leaves a transcript and a tool trace you can audit.

ℹThis node is the whole agent: there is no separate trigger to add. The agent's tools call your nodes directly (see Tools), and every call is kept as a voice session.

Get started

From nothing to an agent you can talk to. Each step links to the section that explains it in detail.

Create an ElevenLabs API key. In ElevenLabs, go to Developers → API keys and create one with ElevenLabs Agents (write) and Voices (read). An unrestricted key works too. ElevenLabs only connects with an API key.
Save it in HostWebhook. In Settings → Credentials, click New, choose ElevenLabs and paste the key.
Add the agent. In Flows, open the node palette and click Voice Agent under Sources, then open the node.
Configure it on the Config tab: the credential, then the system prompt, the first message, the voice and the languages (see Config). If you already have an agent in ElevenLabs, use Import your agent instead of typing it again.
Give it tools on the Tools tab — your flows, an API or your own server (see Tools). Google tools can't be used by a voice agent.
Sync. On Sync & Webhook, press Sync to ElevenLabs. Until you do, nothing you set exists at ElevenLabs.
Talk to it. Press Test agent on the same tab, or open Test call from the node on the canvas. Its tools run for real.
Put it where people are. On your website, with the voice widget: pick the agent under Voice mode in a Chat Trigger, then copy the snippet from the agent's Embed tab. On the phone: HostWebhook doesn't sell numbers — add or import a number in your ElevenLabs account and assign it to this agent there.

Config

Provider and credential

Voice agents run on ElevenLabs, with an ElevenLabs credential. The provider is what HostWebhook talks to when it creates and updates the agent. Vapi and Retell appear in the picker as Coming soon and can't be selected yet.

Import an agent you already have

Connect an ElevenLabs credential and an Import your agent button appears under it. It lists the agents already in that account and pulls one of them into this node — prompt, voice, languages, LLM settings, knowledge base and every Advanced setting, rather than retyping them. The node syncs as soon as the import finishes.

There are two ways to bring it in, and they differ in what happens to the agent already sitting in ElevenLabs:

Import and sync (the default) copies its configuration. The agent you picked is left untouched; the copy goes into the agent this node already manages, or into a new one if the node doesn't have one yet.
Import, manage and sync also takes over that agent: HostWebhook syncs update it in place, so its phone numbers and its embedded widget keep working. If the node already managed a different agent, that one stays in your account but stops being updated from here.

Managing it has one consequence worth knowing before you tick the box, and the dialog spells it out for the agent you picked: HostWebhook becomes the source of truth for that agent's tools, so any it had in ElevenLabs get detached from it when you import — they stay in your workspace, they just stop being attached to that agent. Its knowledge base, workflow, procedures and phone numbers are left alone.

Tools are the one thing an import never brings across, in either mode: here a flow tool runs one of your nodes, and that has no meaning on the other side. The knowledge base does come across — by reference, see Documents already in ElevenLabs.

LLM, system prompt, first message

LLM — the model behind the conversation, from the list the provider supports.
System prompt — who the agent is and what it must not do. On a voice agent this matters more than in chat: nobody reads a disclaimer out loud, so the rules have to be in the prompt and in the tools you do not give it.
First message — what it says before the person says anything. Empty means the agent waits, which on a phone call reads as a dead line.

Voice and languages

The voice comes from the provider's catalogue, fetched with your credential. Languages is a list, not one value — an agent that expects Spanish and English will not stumble when a caller switches mid-sentence.

The gear on the selected voice opens its settings, starting with the TTS model. v3 Conversational is the most expressive and speaks 70+ languages; with it, Expressive mode (on by default) adapts the tone to the caller and follows audio tags such as [laughs], [whispers] or [sighs] in the agent's replies. Flash and Turbo v2.5 favour latency, Multilingual v2 quality; Turbo v2 and Flash v2 only speak English.

With v3 and Expressive mode on, Suggested audio tags lists up to 20 tags the agent should prefer, each with an optional note on when to use it — laughs, “when the caller makes a joke”. The agent can still use other tags. Brackets are removed for you, and removing every tag clears them on ElevenLabs too at the next sync.

Tool timeout

How long the agent waits for one of your flows to answer. This is a conversational number, not a technical one: a person on a call tolerates about a second of silence. A tool that needs eight seconds needs the agent to say something first.

It counts between 5 and 60 seconds: a smaller or larger value is saved, but the agent uses the nearest of the two. The provider is told the same number, and HostWebhook waits for your flow a second and a half less, so the answer reaches the provider before it gives up. Changing it counts as a change to sync, like the prompt or the tools.

Tools

The tools are what turn a voice into a colleague. Besides the built-in tools the provider ships — ending the call, transferring it — you add your own, grouped by where they come from. Pick a source under Add tools from and it becomes a section. Add as many API and tunnel sections as you need — once you have one, the card says Add another tunnel or Add another API; there is one HostWebhook flow section.

A HostWebhook flow — the tools of the nodes you pick for the agent: AI Nodes, and nodes with their AI toolkit on. See Tools from a HostWebhook flow.
An API by URL — HostWebhook calls your API for the agent. The section holds the base URL and the headers every tool in it sends (put the API key there once); each tool adds a method, a path, and its parameters.
Your server via a tunnel — a local server exposed with hostwh expose http://localhost:3000 --id my-app. The section holds the tunnel and shows whether it is online and which local URL it forwards to. HostWebhook calls it for the agent. The tunnel picker marks a tunnel another section already uses.

Every API or tunnel tool is a method, a path, headers, and three kinds of parameter: path parameters that fill the {placeholders} in the path, query parameters appended as ?name=value, and body parameters sent as JSON on POST, PUT and PATCH.

Every tool call is authenticated

The provider never calls your API or your tunnel itself: it calls each tool at its own URL on HostWebhook, with the agent's secret, and HostWebhook runs the flow or calls the API or tunnel with the headers you set here. Your API keys and tunnel ids stay in HostWebhook — the tunnel id is also its key.

Sync sets it up for you: on ElevenLabs it creates a connection named HostWebhook · your agent's name, and every tool uses it under Authentication. A call without the agent's secret is rejected before anything runs. Changing a section's tunnel, base URL or headers works on the next call, without syncing again.

Your ElevenLabs API key doesn't need the Workspace → Write permission for this. With it, sync uses that connection; without it, it stores the agent's secret as a secret in your ElevenLabs workspace, with the same name, and every tool sends it in its Authorization header. Both work the same, and an agent keeps the one it started with.

Tools from a HostWebhook flow

First turn on the AI toolkit of the nodes the agent should use (Slack, MongoDB, HTTP, Notion…). Then, in the flow section, pick them with Add an AI Node, or a node with its AI toolkit on — only those are listed. There is nothing to connect on the canvas: the Voice Agent node has no +, and the × on a node in the section removes it from the agent.

Each node you pick gives the agent all its tools by itself — the same list it offers an AI Node or an MCP server, with nothing to write. What you block in the node (“Block these tool calls”) is gone for the voice agent too. Tools that only read start on, and so does the one that does what the node is already set up to do — a Slack node set to Send message can send straight away (unless that operation deletes something). The rest of those that change data start off, and a line under the node turns them on one by one. A value the node already has, like a Slack default channel, is one the agent uses without asking. If a node's toolkit is turned off later, the section asks you to turn it back on.

An AI Node you pick gives the agent one tool that answers in one go. Its name and description come from the node, and what the agent fills in is what the node's prompt reads — each {{payload.…}} in its system prompt or prompt template, the same arguments it offers as an MCP prompt. It starts on. It only works without the AI Node's own tools and memory — the voice agent already talks, remembers and calls tools, and an agent inside it would be too slow for a call. With either on, the section says which to turn off and the node gives no tool; turning one on after syncing stops the tool on its next call.

To change a toolkit tool for this agent only, open its ⋯ menu: Customize for this agent renames it or rewrites the description the agent reads, Turn off for this agent hides it, and Reset to the node's undoes both. The parameters stay the node's — it reads them by name. When two nodes offer a tool with the same name, each one gets its node's name in front. The agent can't swap the operation a tool runs: the tool's own always wins.

A tool whose node was removed from the agent or is no longer in the mode it needs is flagged in the section, and syncing lists every such problem at once. If you turn a node's AI toolkit off after syncing, its tools stop running right away — the node would otherwise run its own configured operation — and the section tells you the nodes changed since the last sync. If the node finishes within about 6 seconds, the agent hears what it returned (a Mongo lookup's document, an AI Node's answer); if not, it hears that the call was received and the flow keeps running. Keys that start with _ are left out, and a failed step is reported as “couldn't be done” without its error — the agent may read the answer aloud.

ℹDeleting a node removes it from every agent that used it — the link and any tools tied to it. The agent shows a notice naming what was removed, and its card on the canvas shows a ⚠, until you click Got it. If the agent was synced with those tools, ElevenLabs keeps offering them until you Sync again; the notice says so and has the button.

⚠No Google tools. A voice agent can't use Gmail, Sheets, Drive, Docs, Calendar, Google Contacts or Google Analytics nodes — not as tools, and not further down a flow its tools run. Voice providers may use what they receive to improve their models, and Google's rules don't allow its users' data to go there. Saving an agent that has one fails with "Voice agents can't use Google tools (…)" naming what to remove. An agent that already had one keeps it, but the tool doesn't run, and Monitoring → Logs says why.

Discover a tunnel's endpoints

In a tunnel section, Discover endpoints reads your server through the tunnel and lists what it finds, ready to become tools:

An OpenAPI 3 or Swagger 2 spec at the paths the common frameworks publish it — /openapi.json (FastAPI), /api-docs-json (NestJS), /v3/api-docs (Spring), /swagger/v1/swagger.json (ASP.NET) and a few more. Names, descriptions and parameters come from the spec.
A json-server: every resource gets list, get, create, update (PATCH) and delete, with the fields of an item as body parameters. List fields are left out and named in the description — they can't travel as a single parameter.

Endpoints that only read start ticked; the ones that change data start unticked. If nothing is found, paste the spec (JSON), or add the endpoint by hand — adding by hand is always available.

⚠The description is the whole interface. The model decides whether to call a tool from its name and description alone — there is no schema it can inspect and no docs it can read. “Looks up an order by its number and returns its status and delivery date” gets called; “order endpoint” does not. Review the descriptions discovery writes for you.

Knowledge base

Pick one or more Vector Stores and their content is pushed to the provider as the agent's knowledge base — one provider document per source document. This is what lets the agent answer “what is your returns policy” without a tool call and without you writing the policy into the prompt.

When the agent inherits from an AI Node, its stores come from that node's Vector Store tools — and so does each tool's fixed filter. Only the chunks the AI Node could find with that filter are pushed: a tool limited to {"tenant": "acme"} gives the agent acme's documents, not the whole store. A tool without a filter pushes the whole store.

⚠The sync is manual. Ingesting into a Vector Store does not push it to the agent — you press Sync. A store that gained twenty documents this morning is still the old corpus to the agent until someone does. Re-syncing purges what it sent before, so the agent never ends up with two copies.

RAG tuning controls how much of the retrieved material reaches the model. On a voice agent, less is usually better: every retrieved passage is prompt the model has to read before it can start speaking, and the caller hears that as a pause.

Documents already in ElevenLabs

On ElevenLabs, a knowledge base can also use documents that live in your ElevenLabs account. They arrive when you import an agent, or you add them with Add a document from ElevenLabs. They are used by reference: nothing is copied into HostWebhook, the agent uses the very same documents, and a URL document keeps refreshing on ElevenLabs' side the way it always did. Each one keeps its usage mode — always in the prompt or looked up when relevant.

Remove detaches the document from this agent. It stays in your ElevenLabs account, where other agents may be using it.
Delete also deletes it from your ElevenLabs account. If another agent still uses it, ElevenLabs refuses, the document stays, and the sync tells you why.

Both apply on your next sync, and until then a deleted document can be brought back with Undo. If a document was deleted in ElevenLabs directly, the next sync drops it from the list and says so, instead of failing.

Advanced

Setting	What it decides
Conversation behavior	How the agent handles interruptions and silence.
Turn detection	When it decides you have finished speaking. Too eager and it talks over people; too patient and it feels slow. Turn model picks the detector: v3 by default, v2 if v3 cuts callers off in your language.
ASR keywords	Words the recogniser should expect — product names, surnames, SKUs. The cheapest fix for “it never understands our brand name”.
Dynamic variables	Values injected per call — the caller's name, their plan — so one agent serves everyone without a prompt per customer.
LLM extras	Provider-specific model options.
Post-call evaluation	Judges the transcript after hanging up — did it resolve the issue, was the tone right.
Privacy & safety	What is recorded and retained.
Limits & alerts	Concurrent conversations (how many calls at once) and Conversations per day (a hard daily cap — the cheapest insurance against a loop on the other side), and Allow bursting (on by default), which lets calls go up to 3× your ElevenLabs workspace limit when it is hit, the extra ones billed at double rate — turn it off for a predictable bill. Alert these webhooks picks which of your webhooks hear about problems, and Auto-resolve after closes an alert that stays quiet. `-1` means no maximum.
Max call duration	Seconds before the call is cut. The backstop against a loop that talks to itself all night at per-minute rates.

The agent can live on your site as a microphone button in the chat widget. Widget styling is the look; access & security is who may open it; and Web widget embed hands you the snippet with the agent already wired in.

The agent slug is the public name the widget uses, so it appears in the page source — pick something you are happy for anyone to read.

Sync and webhook

Provider sync is the button that makes the configuration on this page real: it creates or updates the agent at the provider. Until you press it, everything here is a draft.

A synced agent goes back to Unsynced only when something the provider receives changes: the prompt, the first message, the voice, the model, the name, the languages, the maximum duration, text-only mode, the dynamic variables, the access settings, the knowledge base or a tool. Renaming a section of the Tools tab, removing an empty one or pausing the agent doesn't, because none of that reaches the provider.

Tools base URL — each tool lives at its own URL under it.
Tool secret — what the provider sends with every tool call (see Every tool call is authenticated). Rotate it if it leaks: the old one stops working right away, and a synced agent's provider gets the new one at the same moment — no need to sync.

Talk to the agent from the canvas

Click the Voice Agent node on the canvas and open Test call in its panel to talk to the agent with your microphone, without leaving the flow — the same test as Test agent on this page. Its tools run for real.

When a tool call doesn't run

Anything that stops a tool call before its flow runs shows up in Monitoring → Logs under the agent's node, with what to do: a call without the agent's secret (for example tools synced before they used HostWebhook's authentication — sync the agent again), a paused agent, a tool the agent no longer has, a node that is no longer picked, an AI Node with tools or memory, an AI toolkit turned off, or a tunnel or API that didn't answer. A call without the secret is logged at most once a minute per agent, because anyone who knows the URL can knock.

When the server behind an API or tunnel tool doesn't answer — it can't be reached, it runs past the Tool timeout, or whatever sits in front of it answers 502 or 504 — the tool answers the provider 503 with { ok: false, error, code, message }. error and message carry the same sentence, short enough for the agent to say: The tool's server didn't answer. (tool_server_unreachable), The tool's server took too long to answer. (tool_server_timeout) or The tool's server failed to answer. (tool_server_failed). The URL and the network error stay out of it. Monitoring → Logs shows the call under the agent, with what happened: no answer, a timeout, or the 502/504. Any other answer from your server — a 404, a 500, the tunnel's own 503 — reaches the provider as it came.

Voice sessions

Every call your agent takes is kept with its transcript, like the sessions of a chat. Find them in Settings → Voice Sessions, or open Sessions in the node's panel on the canvas for the latest ones.

What a session shows — ElevenLabs' title and summary of the call, its duration and outcome, the caller's number on phone calls, and the transcript turn by turn with the tools the agent called in each one. A tool call that failed is marked.
When it shows up — a few minutes after the call ends. Opening an agent's sessions, or pressing Refresh, brings in finished calls right away. Calls still in progress appear once they end.
Audio — it stays at ElevenLabs. Press Load audio to play it from there; HostWebhook doesn't store a copy. If ElevenLabs didn't keep audio for a call, the session says so.
How long they're kept — as long as your plan keeps chat sessions, counted from the start of the call. Then they're deleted here; ElevenLabs keeps its own copy.

Deleting a session asks where: Delete here removes it from HostWebhook only, and it won't come back, even though ElevenLabs still has it. Also delete at ElevenLabs removes it there too, with its audio. Bulk delete (older than 7, 30 or 90 days, or all) only deletes here.

Through the API: GET /api/voice-call-sessions/:agentId lists an agent's sessions (and brings in new ones first), GET /api/voice-call-sessions/:agentId/:sessionId returns one with its transcript, and DELETE on it deletes it — add ?atProvider=true to delete it at ElevenLabs too.

Deleting the node

Deleting a voice agent node that has an agent in ElevenLabs asks what to do with that agent — from the node page, and from the canvas (the quick access button, the Delete key or a multiple selection):

Delete in HostWebhook only — the agent stays in ElevenLabs and keeps working, with its knowledge base. The tools that called your HostWebhook flows are removed from it, because without the node they would only fail mid-call.
Also delete in ElevenLabs — the agent is deleted there too, with its knowledge base and tools. Anything another of your agents still uses is kept, and HostWebhook tells you which.

Deleting through the API or MCP without choosing does the first one: a call that never saw the question keeps the agent. Add ?deleteInProvider=true to DELETE /api/voice-agents/:id for the second. A node that never created its agent has nothing to keep in ElevenLabs, so it is deleted without asking.

Plans and costs

Every plan, Free included, can have voice agents, with no limit on how many.
The minutes are ElevenLabs'. Calls are billed by ElevenLabs on your ElevenLabs account, at their prices.
The tools are events. Each step a tool runs in your flow counts toward your plan's weekly events, like any other run.
Sessions are kept as long as your plan keeps chat sessions: 30 days on Free, 90 on Starter, 180 on Pro and 360 on Enterprise.

Gotchas

Editing without syncing changes nothing. The agent answering the phone is the last version that was pushed.
The provider bills the minutes, you bill the tools. A call is metered by the provider; the flows its tools trigger are events on your side. A chatty agent is expensive twice.
Voice has no undo. A tool that deletes something will be called on a mishearing sooner or later. Give the agent read tools freely and write tools deliberately.
A knowledge base is not memory. It is the same corpus for every caller. What one person said earlier in the call belongs to the conversation, not the store.