Skip to main content
A Conversational Flow Agent in DialNexa uses a visual node-based canvas instead of a single system prompt. Each node is a conversation state with its own prompt, branching conditions, and optional actions. The agent moves from node to node based on what the caller says, following the explicit path you designed.
A flow agent is a map. If the map has a road to nowhere, the caller will eventually find it.

​
When To Use DialNexa Conversational Flow Agents

Choosing between a single prompt agent and a flow agent depends on how much structure your use case requires. Use a flow agent when:
  • The call has multiple clearly separated stages (greeting, qualification, objection handling, close)
  • Compliance requires specific disclosures at specific moments
  • Transfer handoffs need different context collection depending on the caller’s answers
  • Your team needs to review and approve the call logic visually before publishing
  • The conversation is long enough that a single prompt becomes hard to reason about
Use a single prompt agent when:
  • The call is focused and linear (reminder, survey, simple qualification)
  • You need fast iteration and the prompt is short enough to reason about easily
  • Callers may go off-script in ways that are hard to anticipate and define as branches

​
Canvas and Visual Builder

The flow builder opens a canvas where you place and connect nodes. The canvas is a directed graph: nodes are states, edges are transitions triggered by branch conditions. Canvas controls:
  • Drag nodes to reposition them on the canvas (positioning is cosmetic and does not affect logic)
  • Click a node to open its configuration panel on the right
  • Draw an edge from one node’s output port to another node’s input to connect them
  • Zoom and pan with trackpad gestures or the canvas controls
Arrange the canvas so the happy path flows left to right or top to bottom. This makes the flow easier to trace during reviews and debugging.

​
Node Types

The entry marker of the flow. Connect Start to the first conversation step. Set that step’s prompt in its inspector; set the agent’s welcome message in the main agent editor. Start is protected from deletion.
The primary building block. A conversation node holds:
  • A node-specific prompt telling the agent what to say and ask at this stage
  • One or more branches defining the conditions that move the caller to the next node
  • Optional transfer settings if this node can hand off to a human
  • An end-call flag if the call should end after this node
The agent stays in a conversation node until one of its branch conditions is satisfied.
Speaks the configured sentence exactly as written without asking the LLM to compose or rewrite it. Use this node for compliance disclosures, fixed confirmations, and other wording that must remain stable.Static sentence text can contain up to 1,000 characters. A single-brace variable such as {customer_name} is replaced when the sentence is spoken. If the value is missing, the placeholder becomes blank. This syntax is different from the {{variable_name}} template syntax used by prompts and integrations.Connect at least one output branch. The saved graph also supports an explicit end-call setting for a terminal static sentence, but the current builder requires a connected branch when it does not expose that setting. Call-transfer-only fields are not valid on this node.
Calls an external API mid-conversation. Use function nodes to look up data (customer record, availability, balance) or write data (log outcome, create ticket) before the flow continues to the next node.The function node does not speak to the caller. It executes silently and then the flow proceeds to the connected next node based on the function’s success or failure.
Transfers the call to a human agent or external number. Configure:
  • Transfer destination (phone number or SIP address)
  • Hunt mode (try multiple destinations in order)
  • Representative brief (text the agent speaks to the human before transferring)
  • Timeout behavior (what happens if no one picks up)
A transfer node ends the flow for the AI agent. The caller is handed off to the destination.
The protected End call marker terminates the call when a branch leads to it. Connect at least one transition to it, and review each intended terminal outcome so the call can end without getting stuck.
A routing node with no spoken content. It evaluates a condition against variable values or prior responses and directs the flow to different next nodes based on the result. Use logic splits to route based on data (e.g., account balance above a threshold goes one way, below another).
A node that can be reached from any other node in the flow without an explicit edge. Use global nodes for universal behaviors: for example, a “speak to a human” request that can happen at any point, or a compliance disclosure that must be delivered regardless of conversation state.Global nodes reduce the need to duplicate branches across every node.

​
How Flow Execution Works

When a call starts:
  1. The flow starts at the conversation step connected to Start. The agent uses its configured welcome message when the conversation starts with the agent.
  2. The caller responds. The transcriber converts speech to text. The LLM evaluates the response against the current node’s branch conditions.
  3. The matching branch condition is triggered, and the flow moves to the connected next node.
  4. The process repeats until the flow reaches an End Node or Transfer Node.
If no branch condition matches, the agent stays in the current node and prompts the caller again. Configure a fallback branch (“none of the above” condition) to handle unexpected responses and prevent the caller from being stuck.

​
Application Steps In Older Conversational Flows

The conversational-flow editor no longer offers new Application or WhatsApp steps. Existing Application steps can still load, but do not send their WhatsApp template during the call: they run as plain conversation steps. Select an existing step and change its type. Use a configured agent integration function for an action during a call, or a workflow Application node for a follow-up action.

​
How to Start Building a Flow Agent

1

Create a new agent and select Conversational Flow

On the Agents tab, click Create agent and select Conversational Flow Agent. Name the agent.
2

Configure the conversation stack

Set language, voice, LLM, and transcriber in the Stack tab before opening the canvas. These settings apply to the entire flow.
3

Open the flow canvas

Click the Flow tab. The canvas opens with a Start Node already placed.
4

Add and configure the first conversation step

Choose a Conversation step from Add step, connect Start to it, then select the step and write its prompt and branch conditions. Set the welcome message in the main agent editor.
5

Build out the full path

Add nodes for each stage of the conversation. Connect them with edges. Connect each terminal branch to End call.
6

Add Global Nodes for universal behaviors

Add a Global Node for “caller asks to speak to a human” or any other response that should be handled regardless of the current node.
7

Trace and review before publishing

Click through every path on the canvas. Confirm every branch leads somewhere and every path eventually reaches an End or Transfer node.
8

Publish

Use Save Flow to persist the graph, then reopen it to confirm the nodes and positions are saved. When the flow is complete and tested, click Publish and enter a descriptive version title.

​
Review a Flow Before Publishing

1

Trace from start to end

Follow every branch path from the Start Node to its terminal. Every path must reach an End Node, Transfer Node, or a Global Node that handles the call.
2

Read branch conditions literally

Branch conditions are evaluated by the LLM. Ambiguous conditions (“caller seems interested” vs. “caller explicitly said yes”) produce ambiguous routing. Make conditions specific.
3

Check transfer configuration

If any Transfer Node is in the flow, confirm: destination number, hunt mode settings, representative brief text, and timeout behavior.
4

Verify function node error handling

For each Function Node, check what happens if the API call fails. The flow should have a failure branch that handles the error gracefully.
5

Test both the happy path and failure paths

Do not only test the expected caller behavior. Test what happens when the caller goes off-script, says something unexpected, or asks for a human.

​
Limitations of Flow Agents

Compared to single prompt agents, flow agents have constraints you should plan for:
  • Every path must be defined. Callers can only go where the flow allows. Unexpected conversation turns require adding branches, not just editing a prompt.
  • Higher setup time. Building a well-tested flow takes more initial effort than writing a prompt.
  • No global memory across nodes by default. Each node prompt operates in the context of the conversation so far, but the LLM does not automatically carry forward information from one node unless it is designed into the branch conditions or variable passing.
  • Canvas complexity grows quickly. Large flows with many branches become hard to audit. Use Global Nodes to avoid repetition and keep the canvas manageable.

​
Flow-Specific Pitfalls

Visual node placement does not fix branch condition accuracy. A flow where every node connects to the next node in the right visual direction can still route incorrectly if branch conditions are ambiguous or missing. Read the node configuration, not just the canvas.
If a node has no fallback branch for unexpected responses, the caller can get stuck. Every conversation node should have a catch-all branch that either re-prompts or moves to a defined state.
Flow transfer nodes can use dynamic variables for destination numbers. If the variable has no value, the transfer fails. Set fallback defaults or test with explicit values before publishing.
A node with no end-call flag and no connected next node leaves the caller in an undefined state. Double-check that every terminal node either has end call enabled or connects to an End Node.
Draft edits to the flow are not live until published. If callers are experiencing old behavior, confirm the phone number or workflow is pointing to the latest published version, not an older one.

​
Recap

Use a Conversational Flow Agent when the call needs explicit branches and controlled outcomes. Connect every node, define failure and transfer paths, review the graph, and test each important route before publishing. Use Add step to choose a node type. Select a step to edit its fields in the inspector. Connect an output to an existing input, or drag an output onto empty canvas to choose and connect a new step. Use Undo and Redo to revise edits, and Tidy up to arrange the graph. Open the issues indicator to find incomplete steps and select an issue to focus its node. Find node, Go to start, Fit all, and the zoom percentage help navigate; they do not change the saved graph. Keyboard shortcuts work while the editor is focused: Ctrl/Cmd+Z for undo, Ctrl/Cmd+Shift+Z for redo, Ctrl/Cmd+D to duplicate selected steps, and Shift+1 to fit the graph. Text fields keep their normal typing shortcuts. Review connections and save the draft before publishing or activating.

Types Of Agents

Understand all agent types and how to choose between them.

Call Transfer

Configure transfer destinations and hunt mode.

Dynamic Variables

Supply values to flow nodes using dynamic variables.

Agent Versions and Publishing

Understand draft and published state for flow agents.

​
Delete A Conversational Flow Connection

Select a connection on the canvas and press Delete to remove it. The built-in Start and End nodes are protected from deletion. Reconnect any path that should continue, save the draft, and test each branch before publishing; every intended outcome must still reach a valid next step or an end. See agent versions and publishing for the final verification steps.