Getting Started with Flow Builder

What is Flow Builder?

Flow Builder is a visual, drag-and-drop editor for creating conversational AI experiences. Instead of writing monolithic prompts, you design conversations as a series of connected nodes on a canvas — each node handling a specific part of the interaction. The result is a structured, maintainable flow that powers voice agents and chat assistants.

Think of it as a state machine for AI conversations. Each node is a state, each connection (edge) is a transition, and the AI engine moves through the flow based on what the caller or user says.

Core Concepts

Nodes

Nodes are the building blocks of every flow. Each node has a specific purpose — talking to the user, calling an API, extracting data, branching on conditions, and more. You place nodes on the canvas and configure them individually.

Edges

Edges are the connections between nodes. They define the path the conversation can take. When a transition condition is met (e.g., the user confirms their appointment), the engine follows the edge to the next node.

The Start Node

Every flow must have exactly one Start Node. This is the Conversation node where every interaction begins — the first thing the AI says when a call connects or a chat opens. You designate any Conversation node as the start node in its settings.

The 9 Node Types

Node	Purpose	Uses LLM?
Conversation	The core node — talks to the user via prompt or static text	Yes (prompt mode)
Tool / Function	Executes an external tool or API with parameter mapping	Optional (filler)
Extraction	Extracts structured data from the conversation into variables	Yes
Variable	Sets or maps variables with literal values or substitution	No
Logic	Conditional branching based on variable values	No
Request (API Call)	Makes HTTP requests to external APIs with full control	No
End	Terminates the conversation, optionally fires a webhook	No
Frame	Visual grouping container for organizing the canvas	No
Sticky Note	Canvas annotations and documentation notes	No

How a Flow Executes

When a user sends a message (or a call connects), the engine processes the current node:

1. If it's a Conversation node, the LLM generates a response using the node's prompt and the conversation history.
2. If the LLM detects a transition condition is met, it fires a tool call and the engine moves to the connected node.
3. Non-conversation nodes (Variable, Logic, Extraction, Function, Request) execute silently and automatically — the engine chains through them until it reaches another Conversation or End node.
4. The user hears only the response from Conversation nodes. Everything else happens behind the scenes.

Key insight: Transitions and responses happen in a single LLM call. When the AI decides to transition, the destination node generates the response — not the source node. This keeps latency low, which is critical for voice.

Creating Your First Flow

1. Open Flow Builder — Open the Flow Builder and create a new flow.
2. Add a Conversation node — This will be your start node. Write a greeting prompt like: You are a friendly receptionist for Acme Corp. Greet the caller and ask how you can help.
3. Mark it as Start — In the node settings, designate this as the start node.
4. Add transitions — Create conditions like "User wants to book an appointment" or "User wants to speak to a human."
5. Connect more nodes — Drag edges from transition handles to new Conversation nodes that handle each path.
6. Add an End node — Connect it where the conversation should terminate (e.g., after booking is confirmed).
7. Test your flow — Use the built-in tester to simulate a conversation and verify the transitions work.

Canvas Tips

• Use Frames to visually group related nodes (e.g., "Booking Flow," "FAQ Handling").
• Use Sticky Notes to document decision points or leave notes for your team.
• Keep flows readable — avoid crossing edges where possible.
• Use Global Nodes for transitions that should be available everywhere (e.g., "Transfer to Human").