Intelligent Pathing = Intelligent Conversations

We built a voice agent for a debt collection agency in Hamilton. 12 staff, 400 outbound calls a day. The brief? Confirm a debt, offer a payment plan, transfer to a human if the debtor pushed back.

The first version used a single LLM prompt. It worked, until it didn't. A debtor said "I already paid that." The agent improvised. It apologised, offered a discount, and promised to close the account.

None of that was authorised. Your compliance team would have the same reaction ours did.

We rebuilt it with conversation flows. Every path mapped. Every condition explicit.

That agent has handled 14,000 calls since. Zero compliance incidents.

Why Structure Beats Cleverness

Your voice agent has two modes. You choose one or the other.

Single-prompt agents give your LLM a set of instructions and let it figure out the conversation. Real conversations are flexible and unpredictable.

Good for open-ended chats where you don't care about exact wording.

Conversation flow agents map every path visually. Each node handles one job. Transitions between nodes fire on specific conditions. You control what your agent says, when it says it, and what happens next.

For production deployments, where compliance matters, where your brand is on the line, where one wrong sentence costs you, conversation flows win. Every time.

Every path mapped. Every condition explicit.

The Node Types You'll Actually Use

Our conversation-flow builder gives you 11 node types across 4 categories. Here are the ones that matter for your deployments:

Conversation Nodes

Conversation Node. Your workhorse. Handles multi-turn dialogue within a single node. You write a prompt or a static sentence, and your agent follows it. Supports per-node LLM selection, use a cheaper model for simple routing, your premium model for complex reasoning.

Extract DV Node. Captures data from your caller without speaking. Pulls text, numbers, enums, or booleans into dynamic variables. Those variables drive your downstream logic.

Action Nodes

Function Node. Fires a webhook or pre-built function the moment your agent enters the node. No LLM decision needed. Check calendar availability, book an appointment, update your CRM. The "Wait for Result" toggle controls whether your agent pauses or moves on.

SMS Node. Sends a text mid-call. Confirmation codes, appointment details, payment links. Your agent stays silent for roughly 2 seconds while the SMS fires, then transitions automatically.

Call Control Nodes

Call Transfer Node. Routes your caller to a human or another system. Cold transfers hand off immediately. Warm transfers detect whether a human answers, play hold music, and support whisper messages so your recipient knows the context before they speak.

Transfer Agent Node. Hands off to a different AI agent instantly. No new phone call. Full conversation history carries over.

Build specialised agents for different tasks and chain them together. See our guide on agent-to-agent transfer with full context.

End Node. Terminates the call. Supports an optional farewell message. You can place multiple end nodes throughout your flow for different outcomes.

Logic Nodes

Logic Split Node. Pure routing. No speech, no delay. Evaluates your conditions the instant your agent enters the node and branches accordingly. Always includes a default "else" path.

The Three-Layer Architecture

We build every agent at Waboom AI with three layers. Miss one and your agent breaks under real-world pressure.

Layer 1: Global Nodes

Global nodes activate from anywhere in your conversation. No explicit connections needed. Set a trigger like "caller wants to speak to a human" and the node fires wherever your caller is in the flow.

The real power? The "Return to Previous Node" toggle. Your agent handles the interruption, then picks up exactly where your caller left off. No lost context.

We use global nodes for 4 scenarios:

Pro tip: enable "Prevent Immediate Re-Trigger" with a 3-step buffer. Without it, your agent can loop if your caller keeps phrasing things in ways that match the trigger.

Layer 2: Sequential Logic

Your main conversation path. Introduction, discovery, qualification, close. Each step is a conversation node with clear entry and exit conditions.

This is where most of your caller interactions live. 80% of calls follow the happy path. Build this layer first, test it with batch simulation testing, then add complexity.

Layer 3: Branching Logic

This is where your agent gets smart. Conditional routing based on what your caller says, what data you've collected, and what your business rules require.

Two types of conditions drive your branches:

Prompt-based conditions. Your LLM interprets the conversation and decides. "Did the caller express interest in premium?" Flexible but less predictable.

Equation-based conditions. Deterministic. Hard logic. Variables and operators. These evaluate before prompt conditions, top to bottom.

First match wins.

Your equation toolkit includes comparison operators, string matching (CONTAINS, NOT CONTAINS), existence checks, and AND/OR logic. Real examples from our deployments:

Reusable Components: Build Once, Deploy Everywhere

The component system lets you package a group of nodes into a reusable block. We build components for patterns that repeat across your agents:

Library components share across all your agents. Edit once, and every agent using that component updates automatically. Agent components stay scoped to a single agent.

One constraint worth knowing: components can't nest inside other components. Keep your components focused on one task and you won't hit this limit.

Node Design: The Rules That Save You

After building 40+ conversation flow agents, here's what we've learned:

One job per node. If your node handles greeting AND qualification AND booking, it will fail at all three when pressure hits. Split them.

Specific conditions over vague ones. "Caller seems interested" breaks. "Caller confirmed they want to book" works. Your conditions should leave zero room for interpretation.

Test your edge transitions. The happy path works. It always works. What breaks is the transition between your third objection handler and your rescheduling node at 9pm on a Friday. Test those paths with batch simulation before your callers find them.

When to Use Flows vs Prompts

Not every agent needs a conversation flow. Here's how we decide:

Use conversation flows when:

Use single-prompt agents when:

Most of our production agents use conversation flows. The upfront investment in structure pays back in reliability every single day.

Frequently Asked Questions

What's the difference between conversation flow and single-prompt agents?

Single-prompt agents give your LLM instructions and let it improvise. Conversation flow agents map every path visually with nodes and conditions.

Flows give you control over exactly what your agent says and when. For production deployments where compliance and consistency matter, conversation flows are the better choice.

How do global nodes work?

Global nodes activate from anywhere in your conversation without explicit connections. You set a trigger condition, and when your caller matches it, the agent jumps to that node.

The "Return to Previous Node" feature lets your agent handle the interruption and then resume where the conversation left off. Use them for objection handling, escalation requests, and universal FAQ responses.

Can I reuse conversation flows across agents?

Yes. The component system lets you package a group of nodes into a reusable block. Library components share across all your agents, edit once, and every agent updates automatically.

Agent components stay scoped to one agent. Components can't nest inside other components, so keep each one focused on a single task.

How do I decide when a conversation needs branching logic?

Add branching when your caller's response changes what should happen next. If "yes" and "no" lead to different outcomes, you need a branch.

Use equation-based conditions for deterministic routing (checking variable values) and prompt-based conditions when your LLM needs to interpret intent. Start with your happy path, then add branches for the 3-4 most common deviations.