Nodes

Nodes are the building blocks of a flow. Each node represents a step in the flow and it can represent one of the following:

Input

Create a structured form to collect information (text, options, images). Input nodes are useful for collecting data like addresses or product selections. Before you can use an Input node, you must first create the variables that the node will collect and store.
To add a variable, click + under Flow variables. For each variable, enter a name and select a data type. The data type can be one of the following:

• Text
  • Number
  • Boolean
  • Enum
  • JSON
  • XML

You must define a variable for every input node you plan to collect at this stage. After adding the variables, specify a name for the input node. Then, select the variables in the order you want them to appear to the user when entering information. Once configured, click Update (or Save) to apply the changes to the node.

Collect

Use the Collect node to gather a specific piece of information and store it in a single variable. It's ideal for prompting users in a conversational, back-and-forth manner, asking one question at a time. For example, use this node to collect a name, email, phone number, or any other short response.

When you create a node, you can specify instructions to help the model interpret the user’s response accurately. These instructions guide the model in extracting the correct value from free-form or conversational replies. A good practice is to clearly state what you are asking for, and why, in the instructions. For example, ‘ask the user for their age, so that you can verify it’.

Actions

The Action node is used to perform backend operations during a flow. These operations can include calling APIs, triggering webhooks, or executing internal platform actions. Action nodes let your flow interact with external systems or services.

You can configure the following options using an action node:

• HTTP (API call) - make an API call to an endpoint during the flow. This enables your agent to fetch live data, trigger backend processes, or interact with third-party services in real time. The API call node requires the following inputs for it to work correctly:
  • Instructions that guide the model on how to call the API and what to extract from the response.
  • Parameters that are more like key-value pairs and not standard HTTP query or body parameters. Instead, they act as metadata the model uses to understand the purpose and context of the API call.
  • API tool or function that contains the endpoint URL, authentication method, and any other required configuration. For more information, see API functions.

You can add JSON variables to which the response is saved so that it can be used later.

• RAG (knowledge retrieval) - use this action to retrieve relevant information from a connected knowledge base or repository. Choose how the action is triggered: either automatically by the AI using predefined instructions, or manually using explicit inputs passed during the flow. The retrieved content and response can be stored in variables for later use. Ensure that you select your output variables accordingly. On the Options tab, you can configure:

  • The LLM to be used
  • Model parameters
  • The data sources the AI should reference during retrieval

• Utilities (random generator) - generate a random value, such as a number or string. You can use this action for creating unique IDs. Like other actions, store the value in a variable to use later in the flow.

• JSON extract - retrieve structured values from a block of text, usually a response from a model or API. You can use the action to pull out specific data points like a name, date, or item list when the response isn’t already formatted cleanly.
  After specifying the output variable, you must select an input and provide a jq expression on the Inputs tab. The input is the raw JSON you want to extract from. This can come from the response of a previous API call or a variable that holds JSON data. In the jq expression field, enter a query that tells the extractor what part of the JSON to retrieve.

  For instance if the JSON data looks like this:

{  
  "user":
   {
    "name": "Test",
    "email": "test@example.com"
  }
}

For retrieving just the email, your JQ expression would be:

.user.email

• AI extractor - use the model to extract specific information from user input or prior responses. Unlike the JSON Extractor, this doesn’t rely on strict formatting but instead uses natural language understanding to identify the correct values.

Message

Use the Message node to display a message as part of the flow. This could be a greeting, a status update, or any informative prompt. Key options you can configure for this node:

• Template - use this field to define a template for the message. You can also use variables to generate dynamic message content. For example, Hello {{user_name}}.
• Contextual awareness - toggle this setting to turn it on or off. When it is enabled, the model is instructed to make the message fit naturally into the conversation. When disabled, the message is displayed verbatim.

Generate

Use the Generate node when you want the AI to generate dynamic content based on pre-defined instructions. This node is ideal for tasks like generating summaries, recommendations, replies, or any open-ended content where AI creativity or inference is needed. In the options, choose which LLM to use and write detailed instructions to tailor the output. You can also use variables in your instructions.

Logic

The Logic node allows you to add conditional branching to your workflow. Use it to control which path the flow should follow based on a specific condition or input value. You can set up simple or complex logic using conditions and groups. You can create multiple branches in a Logic node and define conditions within each branch. The flow will follow the first branch where all the conditions are evaluated as true. If none match, it follows the Else branch by default.

Each condition compares a variable to a value using one of the following operators:

• Is set (to determine if a variable has been set)

• Is not set

• Same as (compare two variables to check if they contain the same value)

• Not same as

• Equal to

• Not equal to

• Contains

• Not contains

• AI

  📝 Note: The conditions vary based on the type of variable. For ENUM variables, you can use the logic operators to evaluate if the variable contains one of a set of choices. When you select AI as the operator, you will need to provide specific instructions so that the model is able to evaluate if the condition is true or false. Also, if a variable is set to null, 0, or an empty string, the ‘Is set’ condition will return TRUE.

Use grouping (AND/OR/NOT) to combine multiple conditions within a branch when needed.

For example, if you want to route users through different paths in your flow based on their subscription status and product preference, you'll likely need to define multiple branches in a Logic node. For this scenario, assume you’ve already defined two variables:

• subscription_status – can be "premium" or "free"

• selected_product – can hold product names or be empty if the user hasn’t selected anything

Branch 1: Premium users Interested in product A

Grouping AND

Variable	Operator	Value
subscription_status	Equal to	premium
selected_product	Equal to	A

Branch 2: Free plan users without any product preference

Grouping AND

Variable	Operator	Value
subscription_status	Equal to	free
selected_product	Equal to	empty

In this setup, the Else branch acts as the default path. It is followed when none of the specified conditions in the other branches are met.

Loop

The Loop Node allows you to repeat a set of steps for each item in a list or multi-value variable. It's useful when there are multiple options and you need to perform the same action for each one. For example, you can use a loop node when:

• You receive a list of results from an API call and want to perform a set of actions for each result.
• You want to apply the same logic or message to each item in a JSON array.

To use a loop node, you must specify an input variable that contains multiple values. The node iterates through each item in the variable. Each item is assigned to a Loop variable, which is only accessible inside the loop. The flow runs through the connected steps once for each item, using the loop variable.

Example/scenario

Let’s look at an example scenario that makes use of some of the above nodes.

A user selects multiple subscription services they’re interested in. The system should present a personalized offer for each selected subscription.

Step-by-Step Flow Structure

1. Input Node - select subscriptions

   • Variable: selected_subscription (create an enum variable)

   • Options: "Microsoft", "Google", "Adobe"

2. Loop Node – For Each Selected Service

   • Input Variable: selected_subscription

   • Loop Variable: current_subscription (define this loop variable for one subscription at a time)

3. Inside the Loop:
   a. Message Node

   • Text: “Let me check offers for the selected subscription.”

4. b. Action Node – API Call

   • Sends current_subscription to backend API to fetch available plans

   • Saves response in: current_offer

5. c. Generate Node

   • Prompt: Create a short, persuasive offer message based on this service: {{current\_subscription}} and the following details: {{current\_offer}}