Nodes are the building blocks of Retell conversation flows. Learn every node type, how edges connect them, and how transition conditions advance calls.
A conversation flow is a graph of nodes connected by edges. Each node handles one step of the call — talking with the user, running a tool, branching on data, transferring, or ending the call. Each edge carries a transition condition that decides when the agent moves to the next node.Breaking the conversation into nodes lets you control, fine-tune, and debug each step independently — you can change one part of the flow without touching the rest.
Conversation Node: Pure dialogue with the user — no tool calling. The agent can hold a multi-turn conversation within a single node, so you don’t need a new node for every line. Supports two instruction modes: Prompt (the LLM generates responses dynamically) and Static Sentence (the agent says a fixed line first, then continues dynamically if the conversation stays in the node). Transitions are evaluated after each user response.
Subagent Node: Dialogue where the agent can also call tools/functions based on context. Unlike a function node (which executes deterministically on entry), the LLM decides whether and when to invoke each tool from what the user says. Supports multiple tools per node and stays active across multiple turns and tool calls before transitioning. Use a function node instead when a tool must always run at that step.
Extract DV Node: Extracts information from the conversation so far and stores it as dynamic variables on entry — not for dialogue. The LLM analyzes the full conversation to capture each value you define by name, description, and type (Text, Number, Enum, or Boolean). Useful for structured data that downstream nodes or post-call analysis need.
Function Node: Executes a single tool/function deterministically on node entry — not for dialogue. Turn on Wait for Result when the next hop depends on the return value, then branch on the outcome directly from this node. The agent can optionally speak while it runs (e.g. “Let me check that for you”).
Code Node: Runs JavaScript in Retell’s sandbox on entry — no external server needed. Best for data transformation, calculations, formatting, and simple read-only lookups via fetch(). Has access to dynamic variables and call metadata, and can store return values into dynamic variables. For anything needing secrets, authentication, or writes, use a custom function instead.
SMS Node: Sends an SMS during an active phone call, to the caller or another number. Requires an SMS-enabled or SMS-approved Retell number. Transitions once the SMS succeeds or fails. (Voice agents only.)
MCP Node: Calls a tool on an external MCP (Model Context Protocol) server on entry. Connect your server, select a tool, and optionally extract response values into dynamic variables for later nodes. The agent can speak while it runs.
Call Transfer Node: Transfers the call to another phone number or SIP URI. The agent doesn’t speak in this node — put a conversation node with Skip Response before it for a line like “Let me transfer you.” Supports cold, warm (with human detection, whisper/three-way messages), and agentic warm transfer. Use this node — not a conversation node — whenever the agent should transfer to a human. (Voice agents only.)
Transfer Agent Node: Hands the conversation to a different Retell agent mid-call. Near-instant (no new phone call), the destination agent inherits the full conversation history, and no separate phone number is needed. Preferred over call transfer when routing between AI agents (e.g. front-desk → booking, or language-based routing).
Press Digit Node: Navigates IVR menus by sending DTMF tones. The agent doesn’t speak — it listens to IVR prompts and infers which digit to press from your instruction, evaluating on each IVR utterance. Give clear guidance on which options to choose and which to avoid. (Voice agents only.)
End Node: Ends the call. Enable Speak During Execution with an instruction so the agent gives a closing message before hanging up; otherwise the call ends abruptly.
Logic Split Node: Evaluates conditions and branches the flow immediately on entry — the agent doesn’t speak. Useful for splitting on dynamic variables or conditions without stacking everything onto the previous node. Always has an else destination as a fallback so the flow never gets stuck.
Subflow: Packages a reusable subflow (a group of nodes) that appears as a single node on the main canvas. Subflows can be local to one agent or shared across agents in a library; they run their internal nodes and return control to the main flow via an exit node. Tools defined inside a subflow stay scoped to it.
Every node except the end node moves the call forward through edges. A node can have several kinds:
Regular edges each carry a transition condition — a prompt the LLM evaluates, or an equation over dynamic variables — plus a destination node.
Else edge is the fallback: it fires when no other condition matches, so the flow never gets stuck.
Always edge transitions unconditionally after the user responds.
Skip Response edge appears when the node’s Skip Response setting is on: the node transitions as soon as the agent finishes speaking, without waiting for a reply.
How conditions are written, and the exact order they’re evaluated in, is covered in transition conditions.
