> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hubtalk.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# 01. Dialog model

> Nodes, transitions, one turn: who decides what the agent says next.

# Dialog model: nodes, transitions, one turn

> [!NOTE]
>
> **Module goal:** explain in your own words who decides what the agent says next — and why it is not decided by "the neural network in general".

An agent in Conversation Flow is a **directed graph**. A node is one step of the conversation: greet the caller, ask for a date, call the CRM, transfer to a human. A transition is the rule by which the dialog moves on from a node. The conversation is always in exactly one node, and this is the main difference from "just a prompt": the agent's behavior is predictable and can be fixed precisely where it goes wrong.

One dialog turn in the main `rigid` mode looks like this:

```mermaid theme={null}
flowchart LR
    A["Customer utterance<br/>ASR or chat"] --> B["Classifier<br/>which transition fired"]
    B -->|a transition matched| C["Move to the new node<br/>it speaks / works"]
    B -->|nothing matched| D["Reply from the current node<br/>stay in place"]
    C --> E(["Next turn"])
    D --> E
```

The key rule: **in one turn the agent either transitions or replies**. The transition is chosen by a separate fast classifier model — it sees only the conditions of the node's outgoing transitions, not your whole prompt.

## Two kinds of nodes

* **Dialog-leading** — only `Conversation`. The only type that asks the customer a question and waits for an answer.
* **Working** — `Logic Split`, `Extract Variables`, `Function`, `Code`, `MCP Tool`, `Override Settings`. They compute, extract, call external systems or change call settings, and move on right away. `Function` and `MCP Tool` can say a short phrase while the call is running (**Speak during**), but they don't wait for an answer.
* **Call-controlling** — `End` (finish, with a farewell phrase) and `Transfer` (transfer to a human; can say a phrase before the transfer).
* `Begin` — the start marker, and `Component` — a link to a ready-made reusable block.

> [!NOTE]
>
> **Why this way and not one prompt**
>
> One big instruction like "talk to the customer about the appointment" breaks in three ways: it can't be checked step by step, it forgets the mandatory questions, and it can't be debugged precisely. The graph gives what a prompt lacks: a node that shows exactly where the conversation goes wrong; variables that are guaranteed to be filled; and a record of "where the call was" in the history of every conversation.

![Editor canvas: the agent's dialog map of 17 nodes](https://mintcdn.com/hubtalk/UuNkjJ26eB-xpPwv/images/tutorial/tut-01-canvas-overview_en.webp?fit=max\&auto=format\&n=UuNkjJ26eB-xpPwv\&q=85\&s=e919a5ca4a44fdebcd1e1c6acd5342ef)

The course result. The agent you will build: visit confirmation, rescheduling via the CRM, questions answered from the knowledge base, transfer to the front desk, an SMS reminder and three different endings. 17 nodes is a normal size for a production agent.

> [!TIP]
>
> **Check yourself**
>
> Answer without looking: 1) who chooses the transition — the execution model or the classifier? 2) which node type leads the dialog — asks and waits for an answer? 3) what happens if no transition condition matched?


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.