Steps

A call is always on exactly one step. The step decides what the caller hears next: the AI writes a reply, a fixed line plays, or, on a branch, nothing is said and the call moves straight on. This page goes through what each kind is for and everything you can set on one.

Three kinds of step

AI reply is the step you will use most. The AI talks with the caller, following the step's instructions on top of the briefing. It is the only kind of step that can answer from a knowledge base, use a tool, end the call with a reply of its own, or hand the call to a person.

Fixed line says the same words every time, in the caller's language. Use it when the wording matters more than the conversation: a disclosure, a consent question, a confirmation. It has its own page.

Branch never speaks. It checks its paths the moment the call arrives and sends the call on, in the same turn, so the caller hears the step it lands on. Use it to sort calls, by the data you sent or by what the caller has said. See Branch steps.

Change a step's kind with Type in its panel. What can carry over does: a fixed line's words become an AI reply's sample replies and the other way round. Settings the new kind can't have are dropped. A branch, for example, keeps no instructions, line, model, tool, silence repeat or interruption setting, and only an AI reply keeps a knowledge base. Undo brings back anything a switch removed.

The step panel

Select a step on the canvas to open its panel. Under the step's kind and badge, it has three parts, and a ⋯ menu at the top right.

The ⋯ menu

• Make first step makes this the step every call starts on. On the current first step it reads Already the first step.
• Duplicate adds a copy with the same settings and the same paths out, titled with "(copy)" and given an ID ending in _copy. Nothing leads to the copy until you join it, and it is never the first step.
• Delete step asks first, then removes the step and every path leading to it. Deleting the first step makes another step the first. Undo brings it all back.

What this step does

Title is the step's name on the canvas and in lists. On a branch the field is called What it decides, because that text is what the decision model reads as the branch's goal.

Step ID is what paths, the first step and tool limits point to. It is made from the title when the step is created and doesn't follow later title changes. An ID uses letters, digits and _, doesn't start with a digit, and is up to 48 characters; a space you type turns into _. If you rename a step to an ID another step already has, the panel adds a number for you (greet_2) and tells you before you commit. Renaming updates every path that leads to the step, the first step and any tool limited to it.

Type is AI reply, Fixed line or Branch.

Then what the step says. On an AI reply:

• Instructions: what the AI does on this step, for example Ask which day this week suits them for a 20-minute demo. Write {variable} for details the call carries. See Writing instructions.
• Sample replies: how the agent might put it, once per language, chosen with the language tabs above the box. Optional. The sample in the call's language is given to the AI as an example, which steers tone and wording. A language with nothing written yet is marked with a dot.

On a Fixed line: What it says, once per language, and Hang up after this line. Both are described in Fixed lines.

A branch has neither.

Where it goes next

The step's paths, each with where it leads and when it is taken. Add path, beside the heading, lists every step; choose one and a path to it is added, starting as AI decides with no condition yet. Click a path to open it, or use its bin icon to delete it. A step with no paths keeps the call where it is, unless it ends the call. Everything about paths is in Paths and decisions.

Fine-tune this step

Folded until you open it. Its summary line reads Same as the agent until you change something, then names what this step does its own way. Every setting here follows the agent until you set it.

Under the panel's parts, any problem the builder found on this step or its paths is listed: red for one that stops a save, amber for a warning.

AI reply steps

What the AI reads before it speaks

Each time an AI reply step answers, its reply model reads, in this order:

1. the briefing;
2. the step's instructions;
3. an instruction to reply only in the language the call is in now, with the step's sample reply for that language as an example, when it has one;
4. on a step that ends the call, a note that this is the last thing it will say, so it gives its closing message without asking anything;
5. the conversation so far, up to its last 50 messages, tool requests and results included;
6. passages from the knowledge base that match the caller's latest words, when the step or the agent has one.

Variables are filled into the briefing and instructions first. The date and time values are filled in as they were when the call started, so the text stays the same from turn to turn; values collected or received during the call are filled in as soon as they arrive.

This step's own model

By default a step replies on the agent's model with the agent's settings. The This step's own model box, in Fine-tune this step, lets one step differ, setting by setting. Anything left empty stays as the agent has it.

Each setting is independent. A step that sets only Max tokens still uses the agent's model, temperature and effort. Choosing a GPT-5 model sets the step's temperature to 1, and choosing a model that takes no reasoning effort clears the step's effort. If a step leaves the effort to the agent but uses a model that takes none, the agent's effort is simply not applied there.

A typical use: the agent replies on a fast model, and the one step that has to explain something tricky uses a stronger one.

Writing instructions

Instructions work best when they read like a short brief to a colleague who handles one part of the call.

• Say what the step is for and when it is done. "Get a day and time for the demo, and confirm it back" gives the step's paths something clear to match.
• Leave the moving on to paths. Don't write "if they agree, go to booking"; give the step a path with that condition. Instructions shape what is said, paths decide where the call goes.
• Plan for the usual detours. Say what to do with a question, a "not now" or an unclear answer, or give the likely ones their own path.
• Spell out how to say things aloud. Dates, amounts, phone numbers and codes: say how they should sound ("say amounts in words, rupees first").
• Keep shared facts in the briefing. If every step needs it, it belongs there once; a step's instructions should be about that step.
• One aim per step. A step that has to get two separate answers is easier to follow as two steps, or as one step whose path collects both.

For example, the Find a time step of a demo-booking flow:

Find a time this week for a 20-minute demo with {first_name}.
Offer weekday slots between 10 am and 5 pm in the caller's own time.
If they ask what the demo covers, answer in one sentence and come back to the time.
Once they pick one, repeat the day and time back and ask them to confirm.
Say times the way people say them ("Thursday at three in the afternoon").

Branch steps

A branch sorts calls. It has no instructions and no line: when the call arrives, it picks a path and the call moves on in the same turn. The caller never knows it was there.

On arrival, a branch looks at its paths in three stages:

1. Rules first, lowest order first. The first rule that holds is taken, with no model involved.
2. Then the decision model, if the branch has paths the AI decides and no rule held. It reads the branch's What it decides text, what the caller said, and each path's condition, and picks one. The branch's Always path is offered to it as the default, so it never leaves the call on the branch.
3. Then the Always path, when no rule held and the decision model picked nothing.

If the branch leads to another branch, that one does the same, and so on until the call reaches a step that speaks. Every branch on the way that has to ask the decision model adds one decision to what the caller waits for, so put the rules you can decide without a model first.

The builder holds every branch to four rules, and a flow that breaks one can't be saved:

• it has an Always path, so the call can always move on;
• it has no instructions and no line;
• it doesn't wait for an event, because a call never rests on a branch;
• branches don't lead to each other in a circle, so a chain of them always ends at a step that speaks.

A branch can be the first step. It then sorts the call on the caller's first words, using the data the call was sent, and the step it chooses answers those words directly.

For example, a branch titled Who should run the demo? placed after a caller agrees to a demo:

[Who should run the demo?]   Branch
 ├─ Rule: recipient_data.team_size is at least 50        ─► [Book with sales]
 ├─ AI decides: "The caller would rather watch a recording."  ─► [Send a recording]
 └─ Always                                               ─► [Find a time]

Large teams go to sales without a model being asked. Everyone else is checked for a preference for a recording, and the rest go on to pick a time. A team_size sent as text, such as "75", is still compared as a number here (see How a rule compares values).

Next: Paths and decisions.