Workflows (Agent Builder)

The Agent Builder is where you design what your voice agent says, asks, and does on every call. You build a conversation as a visual flow of connected "nodes" — a start, one or more talking steps, and an end — then test it live in your browser and publish it when it's ready. This guide walks through every part of the builder, from creating your first agent to fine-tuning each node, branching the conversation, attaching tools, testing, and reviewing past calls.

In this guide

• Getting started — where agents live, the two ways to create one, and the Blank Canvas vs. Agent Builder (AI) choice
• The editor at a glance — the top toolbar, the canvas, and the test panel
• Node types — what each block on the canvas does (Start Call, Agent, End Call, Global, API Trigger, Webhook, QA Analysis, Tuner)
• Building a flow — adding nodes, connecting them, and arranging the canvas
• Editing a node — prompts, settings, and resources, with a full field reference
• Branching and conditions — making the agent take different paths
• Attaching tools and documents — letting the agent take actions and look things up
• Testing — the Test panel (audio and chat), Test Call, and what to watch for
• Saving, drafts, publishing, and version history
• Workflow Settings — every setting page for the agent (language, voice, behaviour, and more)
• Run history — reviewing every call the agent has handled
• Step-by-step recipes — build a workflow from scratch, and edit an existing one
• Tips and troubleshooting

---

Getting started

Where agents live

Every voice agent you build is a workflow. You'll find them all on the Agents page in your Voice AI hub (the sidebar item labelled "Agents"). The Agents page lists each agent with its name, the phone number assigned to it (if any), when it was created, and how many calls (runs) it has handled.

From the Agents list you can:

• Open an agent — click any row to jump straight into the editor.
• Search and filter — find agents by name.
• Test Call — hover a row and click the Call button to talk to the agent without leaving the list.
• Row menu (⋯) — Edit agent, Settings, Duplicate, Archive, or Delete.

Two ways to create an agent

Click New Agent on the Agents page. A full-screen window asks "How would you like to start?" with two options:

Both options create a draft — nothing goes live or starts taking calls until you deploy it.

If you choose Blank Canvas, a second screen asks you to "Choose your default view":

You can switch between Workflow and Simple view at any time inside the editor, so this choice only sets your starting point.

The guided Agent Builder (AI) wizard

If you pick Agent Builder, you'll move through a guided, multi-step setup titled "Create Voice Agent". A progress bar across the top shows where you are. The steps are:

When you finish, the system assembles a comprehensive multi-stage workflow for you — greeting, qualification, main handling, objection resolution, and closing — with your business profile and services baked in. A success screen confirms it's ready, then you click Open and Test Agent to land in the editor, where you can refine anything.

The wizard is a head start, not a cage. Everything it generates is an ordinary workflow you can open in Workflow View and edit node by node.

---

The editor at a glance

When you open an agent in Workflow View, the screen has three parts: a top toolbar, the canvas in the middle, and the test panel on the right.

The top toolbar

From left to right, the toolbar contains:

• Sysevo logo and a breadcrumb back to Agents.
• Agent name — click it (or the pencil) to rename the agent inline. Press Enter to save, Escape to cancel.
• View toggle: Workflow / Simple — switch between the node canvas and the simple form view.
• Version history (clock icon) — opens the version history panel; shows the current version label (e.g. v4 (Draft)).
• Unsaved changes indicator — a yellow pill appears whenever you have edits that aren't saved yet.
• Validation errors — a red pill appears if the workflow has problems; click it to see the list.
• Test — toggles the test panel on the right open or closed.
• Test Call — appears only when a phone number is assigned to the agent; starts a real phone call.
• Save — saves your changes as a draft (only enabled when there are unsaved changes).
• Publish — makes the saved draft live (appears once a draft exists).
• Language (globe) — switch the interface language (English / Español).
• More options (⋯) — Phone Call, View Runs, Duplicate Workflow, Download Workflow, and Copy Agent UUID.

The canvas

The middle is an infinite, pannable canvas with a subtle dot grid. Your agent's steps appear as cards (nodes) connected by lines (edges). You can:

• Pan by dragging empty space, zoom with the scroll wheel or the bottom-left controls.
• Add a node with the white + Add node button (top-right).
• Open Workflow Settings with the gear icon next to it.
• Use the bottom-left control cluster: Zoom in, Zoom out, Fit view, and Tidy up (auto-arranges nodes neatly).
• Double-click empty canvas to fit everything back into view.

The test panel

The right-hand panel lets you try the agent immediately, with two tabs — Test Audio and Test Chat. It's covered in full under Testing. You can hide it with the Test toolbar button to give the canvas more room.

---

Node types

Each card on the canvas is a node. Nodes come in a few categories, and the Add Node panel groups them under Triggers, Agent Nodes, Global Nodes, and Integrations. Here's a quick map before the detail:

Here's what each one does in detail.

Start Call

This is where every call begins. Its prompt is the agent's opening instruction — usually a greeting and an invitation to help. The Start Call node also holds the first message (greeting) the agent speaks, and a few call-opening behaviours like whether the agent may be interrupted and whether the start is delayed.

Agent Node

The workhorse of a conversation. Each Agent Node is one stage of the call with its own instructions (prompt). You might have an Agent Node for qualifying the caller, another for handling objections, another for booking. You can attach tools and documents to an Agent Node so it can take actions and look things up. Most multi-step flows are mainly a chain of Agent Nodes.

End Call

Closes the conversation. Its prompt tells the agent how to wrap up — thank the caller, summarise, say goodbye — and then the call hangs up.

Global Node

The Global Node holds rules and context that apply to the entire call, no matter which step the agent is on — things like overall persona, tone, hard rules ("keep responses to 1–2 sentences"), and the documents available across the whole agent. Because its guidance is shared everywhere, it doesn't need connecting lines. Knowledge Base documents you assign to the agent are stored on the Global Node behind the scenes.

API Trigger

An API Trigger gives your agent a web address (URL) that other apps can call to start a conversation automatically — no phone line required. Paste the URL into a tool like Zapier or Make, or your own system, and a call begins. Each trigger has a friendly Active toggle (turn it off to pause without deleting), a URL path (auto-generated, or set something memorable), and shows you both a Live and a Test URL you can copy.

Webhook

A Webhook step sends call data to another app when the workflow reaches it — perfect for updating your CRM, triggering an automation, or logging results. You set the Destination URL, the Request method (POST works for almost everything), optional Headers (for an API key), and the Data to send. The data can include live call values using {{variable}} placeholders. The node's editor lists the available variables, including:

QA Analysis

A QA Analysis node automatically scores or evaluates calls after they finish, against criteria you define. Use it to grade whether the agent followed the script, captured the right details, or hit its goal. QA results can be sent on via a Webhook ({{annotations.qa_SCORE}}) and reviewed in run history.

Tuner

A specialised node used for fine-tuning agent behaviour. It's an advanced building block — most agents won't need one — and like every node, you configure it by opening it and filling in its fields.

The exact set of nodes available in your Add Node panel comes from the platform, so you'll always see the current options grouped by category. Start Call, Agent, End Call, and Global cover the vast majority of agents.

---

Building a flow

Adding a node

1. Click + Add node (top-right of the canvas).
2. The Add Node panel slides in from the right, with nodes grouped by category.
3. Click the node type you want.
4. The new node appears on the canvas near the centre of your current view, in a free spot that doesn't overlap anything.

If you had a node selected when you added the new one, and the new node can accept an incoming connection, the editor auto-connects them for you — so adding nodes in sequence naturally chains them together.

New nodes start with sensible defaults (a name and any default field values), ready for you to open and edit.

Connecting nodes (edges)

Connections — called edges — define the order the agent moves through steps. Each node card has small round handles: a connector at the bottom (outgoing) and/or at the top (incoming), depending on the node type.

To connect two nodes:

1. Hover the bottom handle of the source node until it highlights.
2. Click and drag to the top handle of the target node.
3. Release to create the line.

A few rules are enforced automatically:

• You can't drag a connection out of an End Call node (nothing comes after it).
• You can't drag a connection into a Start Call node (nothing comes before it).
• Start Call, Agent, and End nodes that aren't explicitly wired will be auto-chained left-to-right when the workflow loads, so a brand-new agent already has a working start → agent → end path.

To remove an edge: click it to select it, then press Backspace.

Arranging the canvas

• Drag any node to reposition it. Your layout is saved with the workflow.
• Tidy up (bottom-left, grid icon) auto-arranges all nodes into a clean top-to-bottom layout and re-centres the view. This is the quickest way to make a messy canvas readable again.
• Fit view (expand icon) zooms so everything fits on screen.
• Zoom in / out buttons, the scroll wheel, and double-clicking empty canvas all adjust zoom.

The starter (blank) workflow

When you create a Blank Canvas agent, you don't start with a truly empty screen — you get a ready-to-run starter:

1. A Global Node with an overall goal and basic rules ("Keep responses to 1–2 sentences", "Never repeat the same phrase twice in a row", "Accept natural speech variations").
2. A Start Call node that greets the caller and asks how it can help.
3. An Agent Node ("Main Agent") that handles the caller's request.
4. An End Call node that thanks the caller and says goodbye.

The Start → Agent and Agent → End connections are already in place, each with a plain-language condition ("caller has been greeted", "conversation complete"). From here you edit the prompts, add more Agent Nodes, and branch as needed.

---

Editing a node

To edit a node, double-click it, or hover it and click the pencil icon. A panel slides in from the right with the node's settings. Hover a node to also reveal a trash icon to delete it (every node except Start Call can be deleted).

The editing panel organises fields into up to three tabs, shown only when relevant:

Press ⌘S / Ctrl+S to save the panel, or click Save. Press Escape (or click the dimmed backdrop) to close; if you have unsaved edits you'll be asked before discarding.

Writing prompts (the Prompt tab)

A node's prompt is the instruction you give the agent for that step, written in plain English. The starter prompts use simple headings to keep the agent focused — and you can follow the same style:

## MAIN ACTION POINT Greet the caller warmly and introduce yourself. Ask how you can help today. ## RULES - Keep your opening statement to one sentence - Be warm and professional

Tips for good prompts:

• One job per node. Give each Agent Node a single, clear objective. Use separate nodes for separate stages.
• Be specific about rules. Short sentences, no jargon, and explicit do's and don'ts work best.
• Use the Global Node for shared rules (persona, tone, "keep it short") so you don't repeat them in every node.
• Insert live data with variables. Write {{variable_name}} anywhere in a prompt to drop in a value — for example a caller's name or a template variable you defined in Settings.

Long text fields have an expand button (bottom-right corner) so you can write comfortably, then collapse again.

The first message / greeting

On the Start Call node, you'll also set the first message (greeting) — the exact line the agent speaks when the call connects, e.g. "Hi, thanks for calling — how can I help you today?" This is separate from the prompt: the prompt guides the agent's reasoning, the greeting is the literal opening line.

Settings (the Settings tab)

The Settings tab holds the node's behavioural options. Which appear depends on the node type, but common ones include:

For the API Trigger and Webhook nodes, the Settings fields are written in plain language (e.g. Active, URL path, Destination URL, Request method, Headers, Data to send) with helpful descriptions, so you don't need technical knowledge to configure them.

Field types you'll encounter in the Settings tab:

• Text boxes and larger text areas (with an expand button).
• Numbers (with up/down steppers and sensible limits).
• Toggles for on/off options.
• Dropdowns for picking one option.
• Checklists for picking several options.
• Repeating rows — an "Add" button creates more entries (e.g. multiple custom headers).
• URL and JSON fields for integration nodes.

Resources (the Resources tab)

The Resources tab is where you attach things the node can use during the call — see Attaching tools and documents.

Data capture (extraction)

Many agents need to collect information from the caller — a name, email, budget, preferred date — and use it later in the call, in a webhook, or in reporting. Turn on Extraction enabled in a node's Settings tab to do this. You then provide:

• An extraction prompt describing what to capture and how.
• One or more extraction variables — the named fields to fill (e.g. first_name, email, budget).

Captured values are stored against the call's gathered context. You can reference them downstream — for example in a Webhook node with {{gathered_context.budget}}, or check them in run history. Captured fields also make great branch conditions (e.g. "budget is above the minimum").

Pre-call data fetch

On the Start Call node you can enable Pre-call data fetch to look up information about the caller before the conversation begins, from a URL you supply. This lets the agent open the call already knowing who it's talking to (for example, pulling a customer record by phone number), so the greeting and handling feel personalised from the first second.

Reading a node card at a glance

Without opening a node, its card on the canvas already tells you a lot:

• The type label and name at the top.
• A preview of the prompt or greeting text.
• Resource badges along the bottom showing how many tools and docs are attached.
• A red border and message if the node has a validation problem.
• API Trigger cards show the endpoint path; Webhook cards show the method and destination URL.

---

Branching and conditions

A workflow doesn't have to be a straight line. From one node you can draw several outgoing connections, each leading to a different next step, and label each one with a condition describing when the agent should take that path. This is how an agent decides, for example, to go to a booking node if the caller is interested, or a re-engage node if they object.

Editing a connection (condition)

Double-click any connection line to open the Edit Condition panel. It has three fields:

Save with ⌘S / Ctrl+S or the Save button.

How connections look on the canvas

• A connection with a label or condition shows it in an amber pill on the line.
• An empty connection shows as a small dot — hover it to expand, double-click to edit.
• Hovering a line highlights it; selecting it turns it blue. A line with a problem turns red.
• When a node has several outgoing connections, their labels are automatically spread apart so they don't overlap.

Looping back

You can connect a node back to an earlier node (even to itself) to create a loop — useful for "ask again" or "keep handling until done" patterns. Self-connections are drawn as a neat curved loop.

Tips for branching

• Name your conditions clearly. The label is what you'll read on the canvas and in logs.
• Cover the main outcomes from each decision point (interested / not interested / needs a human).
• Use Transition Speech to keep the call feeling natural when the agent switches gears.
• Keep branches shallow where you can — a few well-chosen paths are easier to maintain than a sprawling web.

---

Attaching tools and documents

Open a node and go to the Resources tab to give it extra abilities. (For the agent as a whole, documents are also managed from Workflow Settings → Knowledge Base, and tools are managed on your Tools page.)

Tools

Tools let the agent do something during the call — look up an order, check availability, transfer to a human, send details, and so on. In the Resources tab you'll see a checklist of the tools available to your account. Tick the ones this node should be able to use:

• Each tool shows its name and a short description.
• A counter confirms how many tools are enabled for the node.
• If you have no tools yet, you'll see a prompt with a link to your Tools page to create some.

Only enable the tools a node actually needs — that keeps the agent focused and predictable at each stage. (Creating and configuring tools themselves is covered in the dedicated Tools guide.)

Documents (Knowledge Base)

Attach documents so the agent can pull facts from them during the call (your price list, policies, FAQs). In the Resources tab you'll see your account's documents; tick the ones this node should reference:

• Only documents that have finished processing (ready) can be attached.
• Documents still processing or that failed are shown with a status badge.
• A counter confirms how many documents are attached.
• A link takes you to the Knowledge Base page to upload more.

You can also assign documents to the whole agent from Workflow Settings → Knowledge Base, where you toggle each document on or off and see which are global (always available across the account).

Recordings

Some nodes can reference a pre-recorded audio clip (for example, to play a fixed message). Where supported, you'll pick from a dropdown of your saved recordings, or enter a recording ID.

---

Testing

You should test an agent before you publish or put it on a phone number. The builder gives you three ways to do that.

The Test panel — Test Audio

Open the Test panel (toolbar button) and stay on the Test Audio tab. The idle state shows the agent's name, "Ready to call", and which Language Model and Voice it will use. Click Start Test Call to begin a live, browser-based voice conversation — you talk into your microphone and the agent talks back.

During a test call you'll see:

• A glowing orb that reacts to the agent's voice.
• A live transcript of both sides, plus small markers when the agent moves between nodes (so you can watch your branching work).
• A status line (Connecting…, Listening…, Agent speaking, Call ended).
• A microphone picker if you have more than one input device.
• Mute and End call controls.
• A New session button to start over.

You must save your changes before a test reflects them. If you have unsaved edits, the panel shows "Save changes before testing" and the start button is disabled.

The Test panel — Test Chat

Switch to the Test Chat tab to test the agent by typing instead of talking. Click Start Test Chat, then send messages and read the agent's replies in a familiar chat layout. This is handy for quickly checking wording and logic without using your microphone, and for testing in a quiet room. It shows only the Language Model the agent uses (no voice involved). Use Reset or New session to start fresh.

Test Call (real phone)

If the agent has a phone number assigned, a Test Call button appears in the toolbar (and a Phone Call option in the ⋯ menu). This places an actual phone call so you can hear exactly what a real caller experiences. You can also start a test call straight from the Agents list using the Call button on a row.

What to check while testing

• Does the greeting sound right and play at the right moment?
• Does the agent stay on task for each node and move between steps when it should?
• Do your conditions route the conversation correctly?
• Do tools fire and return useful results?
• Does the agent end the call cleanly?

---

Saving, drafts, publishing, and version history

The builder separates your working draft from what's live, so you can edit safely.

Saving a draft

• Whenever you make a change, an Unsaved changes pill appears and the Save button lights up.
• Click Save (or it's saved as you complete actions in some views) to store your work as a draft. You'll see "Workflow saved as draft".
• Saving does not affect live calls — drafts are private until you publish.

Publishing

• Once a draft exists, a Publish button appears.
• Publishing requires that you've saved first and that there are no validation errors — otherwise you'll be prompted to fix those.
• Click Publish to make the current saved version the live version your phone numbers and triggers use. You'll see "Workflow published successfully".

Version history

Click the clock / version icon in the toolbar to open the Version History panel. It lists each saved version, newest first, with:

• A version number (e.g. v4) and how long ago it was created or published.
• A status badge: Draft (amber), Published (green), or Archived.
• A "current" marker on the live version.

From here you can:

• View any version to preview it on the canvas in read-only mode (a blue "Read only" banner appears, with a Back to Draft button to return).
• Restore an older version — it's loaded back onto the canvas as new changes you can then save. You'll see "Restored to v… — save to keep these changes".
• Load more versions if you have a long history.

Viewing a historical version never changes your live agent. Restoring only takes effect once you Save (and Publish, if you want it live).

The More options (⋯) menu

The toolbar's ⋯ menu collects a few extra actions:

---

Workflow Settings

Click the gear icon on the canvas (top-right) or the toolbar's settings path to open Workflow Settings — a full-page set of sections for configuring the agent beyond the conversation flow. Each section saves independently. The settings are grouped in a left-hand menu:

General

Set the agent's name, its status (Active or Archived), and the language(s) it speaks. You can select multiple languages; the first is the primary. When you add two or more, a Multilingual Mode toggle appears, which lets the agent switch languages mid-call (this needs a multilingual-capable transcription model).

Language Model

Choose the Language Model (the agent's reasoning engine) and the Transcriber (STT) (speech-to-text for understanding callers). Leave either blank to use your account defaults. If your account supports it, a Realtime Mode toggle enables a faster speech-to-speech pipeline.

Voice

Pick the Voice Engine (text-to-speech provider/model) and a specific Voice — either from your voice library or, for some providers, a built-in voice. A Voice Tuning area lets you adjust voice characteristics, interruption sensitivity, and a silence timeout. A small strip confirms the selected engine.

Knowledge Base

Assign documents from your organisation's knowledge base to this agent. Each document shows its status (ready, processing, failed, or global). Use the link / unlink button to attach or remove a document, and retry a failed one. A stats bar shows how many are assigned, global, and ready. (These assignments are stored on the agent's Global Node.)

Memory

Turn on Memory so the agent remembers repeat callers — names, preferences, addresses, and past call history — and automatically uses that context at the start of future calls.

Call Behavior

Fine-tune how the agent handles the rhythm of a conversation:

Voicemail

For outbound calls, enable Voicemail Detection so the agent recognises when it's reached a voicemail system rather than a person, and acts accordingly. You can use the agent's own model or a custom one, edit the classification system prompt (it must answer "CONVERSATION" or "VOICEMAIL"), and set a speech cutoff timing.

Variables

Define Template Variables — named placeholders you reference in prompts with {{variable_name}}. Each has a name and a default value. Add them here, then use {{name}} anywhere in a node's prompt to inject the value at call time.

Dictionary

Add words the agent should listen for — company jargon, product names, people's names, industry terms — as a comma-separated list. This helps the transcriber hear unusual words correctly (it may add cost depending on your provider).

Call Dispositions

Define outcome codes the agent can assign at the end of a call (e.g. sale, not_interested, callback). Each is a code plus a description. Dispositions show up in run history and reporting so you can measure outcomes.

Widget

Publish the agent as an embeddable voice widget on your website. Toggle Published, choose a hosted (pre-built button/UI) or headless (your own UI) mode, and customise the theme colour, position, and button label. The page gives you a ready-made embed snippet to copy. A widget key is generated automatically and can be regenerated.

Agent UUID

A read-only, stable identifier for this agent. Click to copy it — it's used when connecting the agent to other systems.

---

Run history

Every conversation the agent handles is a run. Open run history from the toolbar ⋯ → View Runs, or by adding /runs to the agent's editor page. The page is titled Run History and shows a total count plus a refresh button.

Each row shows:

Use the pagination controls at the bottom to move through pages (20 runs per page), and the refresh button to pull the latest.

---

Step-by-step: build a workflow from scratch

1. Create the agent. On the Agents page, click New Agent → Blank Canvas → Workflow View. You land in the editor with a starter flow (Global, Start, Agent, End).
2. Name it. Click the name in the toolbar and type something clear, e.g. "Inbound Bookings". Press Enter.
3. Set the Global rules. Double-click the Global Node. In the Prompt tab, write the agent's persona and the rules that apply to the whole call (tone, "keep replies short", any do's and don'ts). Save.
4. Write the opening. Double-click the Start Call node. Set the prompt (how to greet and open) and the first message (the literal greeting line). Save.
5. Shape the main conversation. Double-click the Agent Node ("Main Agent"). Give it one clear job in the Prompt tab. If you need more stages, click + Add node → Agent Node for each (qualify, handle objections, book…), and connect them by dragging from each node's bottom handle to the next node's top handle.
6. Add conditions where the call can branch. Double-click a connection line and fill in the Condition Label and Condition (and Transition Speech if you want the agent to say something as it moves on). Save.
7. Attach tools and documents. Open any node that needs to do something or look something up, go to the Resources tab, and tick the tools and documents it should use.
8. Tidy the canvas. Click Tidy up (bottom-left) to arrange everything neatly.
9. Configure settings. Click the gear icon to open Workflow Settings. Set the language, choose a voice, and adjust call behaviour as needed.
10. Save. Click Save in the toolbar. The Unsaved changes pill disappears.
11. Test. Open the Test panel and run a Test Audio call (or Test Chat). Listen for the greeting, watch the node-transition markers, and confirm branching and tools behave.
12. Fix and re-test. Make edits, Save, and test again until it's right.
13. Publish. With no unsaved changes and no validation errors, click Publish. The agent's live version is now updated.

Step-by-step: edit an existing workflow

1. Open it. On the Agents page, click the agent row (or ⋯ → Edit agent).
2. Make your change. Edit a prompt, add a node, tweak a condition, or adjust settings. The Unsaved changes pill appears.
3. Test before publishing. Use the Test panel to confirm the change works. (Save first — tests use the saved draft.)
4. Save the draft. Click Save. Your live agent is unchanged until you publish.
5. Publish when ready. Click Publish to push the change live.
6. Roll back if needed. Open Version History, View an earlier version to compare, and Restore it if you want to revert — then Save and Publish.

Want a safe place to experiment? Use ⋯ → Duplicate Workflow to make a copy, change the copy freely, and leave the original untouched.

---

Workflow View vs. Simple View

The same agent can be edited two ways, and you switch any time with the Workflow / Simple toggle in the toolbar.

Both views edit the same underlying agent, so changes made in one show up in the other. Version history and the Test panel work in either view. Choose whichever matches how much control you need.

In Simple View, the most important fields are right at the top: the System Prompt (the agent's overall instructions and persona) and the First Message (the greeting it speaks when the call connects). Below those sit voice selection and a handful of behaviours.

---

Tips and troubleshooting

• "Save changes before testing." Tests run against your saved draft. Click Save, then start the test.
• Publish is greyed out. You either have unsaved changes (save first) or validation errors (open the red error pill in the toolbar and fix each one).
• The Start Call node won't delete. That's intentional — every workflow needs exactly one. You can edit it, just not remove it.
• A connection won't attach. You can't connect into a Start Call node or out of an End Call node. Check you're dragging from a bottom handle to a top handle.
• The canvas looks messy after importing or restoring. Click Tidy up to auto-arrange, then Fit view.
• No tools or documents show in a node's Resources tab. Create tools on the Tools page and upload documents on the Knowledge Base page first; they'll then appear to attach.
• The agent ignores a rule. Put shared rules in the Global Node and keep each Agent Node focused on one job — overloaded prompts are harder for the agent to follow.
• Branching goes the wrong way. Re-open the connection and make the Condition text describe the situation precisely; vague conditions lead to unpredictable routing.
• Keep a backup. Use ⋯ → Download Workflow to save a copy before a big change, and rely on Version History to roll back.
• Test on a real phone before going live. Browser tests are great, but a Test Call (when a number is assigned) is the closest match to a real caller's experience.

---

What the visual builder is for

The workflow canvas is a no-code visual builder for call logic that's more involved than a single prompt. Two patterns it handles especially well:

• Branching on caller intent — route the conversation down different paths depending on what the caller wants (e.g. "new booking" vs "existing booking" vs "complaint"), each path with its own instructions and tools.
• Sequential tool execution — chain several actions in order within a single turn, such as look up the caller → check availability → book the slot → send an SMS confirmation → update the CRM. In a well-built flow these can complete in a few seconds with zero human involvement.

Everything else an agent uses — voice, personality, memory, tools, and the AI model — is configured from the editor around this flow, so the canvas stays focused on what happens when during a call.