Flow Node Reference

Agent Flow provides 13 nodes organized into 4 categories. Drag a node from the Node panel on the left onto the canvas, or click it to drop it at the center of the canvas. Use the Search nodes box at the top of the panel to filter by name or description.

Category	Nodes
General	Start, Output
Agents	Agent, Model, Supervisor
Logic & Data	Condition, Router, Merge, Transform, Iteration, Subflow
Control & Safety	Approval Gate, Guardrail

Every node takes input on the left and produces output on the right. Branching nodes — Condition, Router, Guardrail, Approval Gate — stack multiple output handles vertically on the right edge.

General

Start

Flow entry point. Receives user input as the input State key and passes it to the next node.

Output

Flow exit point. Returns the result of the previous node to the user. Choose Passthrough / Response / Error as the Action Type.

Agents

Agent

Runs a registered agent with all of its connected resources. KBSphere (enhanced RAG) and DBSphere (database) agents are supported.

Model

A lightweight direct LLM call without an agent. Good for summarization, translation, and classification.

Supervisor

Coordinates multiple worker agents. A supervisor model delegates round by round, reviews results, and composes the final answer.

Logic & Data

Condition

True / False branch. Supports 11 condition types.

Router

N-way routing. Picks one of several routes, rule-based or LLM-based.

Merge

Combines outputs from parallel paths. Three modes: concat / json / template.

Transform

Builds new text from State values using a Jinja2 template.

Iteration

Splits the input into items and processes them in parallel — template rendering or a per-item LLM call.

Subflow

Runs another flow as a sub-step and uses its final output as this node’s output.

Control & Safety

Approval Gate

Pauses for human approval. A human-in-the-loop gate that branches on approve / reject.

Guardrail

A safety filter that applies a guardrail and branches on pass / block.

Node Settings

Every node’s settings panel starts with a Label. It is both the name shown on the canvas and the name other nodes use to reference this node’s output ({Label.key}). Renaming a node changes the references that point at it, so check any existing references after a rename.

Start node

Flow entry point. The user message arrives as the input State key.The settings panel shows an Available State Keys list. It automatically collects the State keys produced by the other nodes in this flow and is read-only — each entry shows the key name, its source node, and its type.

The Start node has no field for defining variables. Values consumed downstream are passed as State keys produced by each node ({Label.key}).

Start is the only node without an “Error handling & retry” section.

Output node

Flow exit point. Returns the result of the previous node to the user.

Setting	Description
Action Type	`Passthrough` / `Response` / `Error`

Behavior by action type:

Type	Behavior
Passthrough	Returns the current output directly to the user
Response	Generates a polished response using the prompt and sources
Error	Returns an error message to indicate flow failure

Response additionally takes a Final Response Prompt and a Model for Response. The prompt can reference {'{{ input }}'} and State keys; clicking an Available State Keys chip inserts the reference at the cursor.Error takes an Error Message Template, where {'{{ input }}'} and {'{{ error }}'} are available.

The UI label is “Output”. The internal type name is flowOutput.

Agent node

Runs a registered agent. KBSphere / DBSphere agents are supported.

Setting	Description
Agent	The agent to run
Max Tokens	Response length cap (default 4096)
User Prompt	Prompt passed to the agent. Use `{input}` or `{Label.key}` to reference State values

KBSphere agents also return the sources of retrieved documents
DBSphere agents include SQL execution results

An Agent node inherits every knowledge base, tool, and guardrail attached to that agent.

Model node

Calls an LLM directly without an agent.

Setting	Description
Model	The LLM to use
System Prompt	System instructions for the model
User Prompt	Use `{input}` or `{Label.key}` to reference State values
Max Tokens	Response length cap (default 4096)
Structured Output (JSON)	Checking it reveals the Output Fields definitions below

With Structured Output (JSON) checked, output fields are defined by name · type · description, with types string, number, boolean, and array. Left unchecked, the response is plain text.

Supervisor node

One supervisor model delegates work to several worker agents and composes the result.

Setting	Description
Supervisor Model	The model that delegates, reviews, and writes the final answer (required)
Workers	Agents used as workers. Use Add Worker to add rows (at least one required)
Max Rounds	Delegation round limit (1–8)
Supervisor Instructions	Extra instructions for the supervisor model
Max Tokens	Response length cap

For each worker row pick an Agent and optionally add a description. Leaving the description empty falls back to the agent’s own description — since this text is what the supervisor uses to decide who to delegate to, fill it in whenever the agent name alone doesn’t convey the role.Behavior: the supervisor model delegates to workers round by round, reviews the results, and composes the final answer.

Leaving the supervisor model unselected, or having zero workers, is flagged as an error during validation.

Condition node

Branches the flow on a condition. It has two output handles on the right: true and false.

Setting	Description
State Key	The value to evaluate (`input` or an upstream node’s State key)
Condition Type	One of 11 condition types
Value	The value to compare against

Supported condition types (11):

Condition type	Internal code	Description
`Contains`	`contains`	Contains the given text
`Does not contain`	`not_contains`	Does not contain the given text
`Equals`	`equals`	Exact match
`Not equals`	`not_equals`	Not an exact match
`Starts with`	`starts_with`	Starts with the given text
`Ends with`	`ends_with`	Ends with the given text
`Greater than`	`greater_than`	Numeric comparison (greater)
`Less than`	`less_than`	Numeric comparison (less)
`Is empty`	`is_empty`	No value
`Is not empty`	`is_not_empty`	Has a value
`Regex match`	`regex`	Regular expression match

To build a loop exit, combine {Label.loop_count} with a Greater than condition. See the loop section in Agent Flow.

Router node

Multi-path routing. Each route you define gets its own output handle on the right.

Setting	Description
Routing Type	`Rule-based` (match conditions in order) or `LLM-based` (let AI choose the route)
Model	Model used for LLM-based routing. Leave empty for the default
State Key	The value evaluated in rule-based routing
Routes	Name and condition for each route
Default Route	Where to go when nothing matches. `None (error if no match)` raises an error instead

Route conditions in rule-based routing support the same 11 types as the Condition node.

Merge node

Combines several parallel outputs into one.

Setting	Description
Merge Type	`Concat` (join texts with separator) / `JSON` (merge as JSON object) / `Template` (custom Jinja2 template)
Separator	Separator for concat mode (default `\n\n`)
Template	Jinja2 template for template mode (e.g. `{'{{ NodeA_response }}'}`)

Behavior by mode:

Mode	Result	Use when
`concat`	A single text joined by the separator	Collecting several agent outputs into one answer
`json`	A JSON string of key: value pairs	Handing structured data to a downstream system
`template`	The rendered Jinja2 output	Formatting the output as an email or report

Transform node

Builds new text from State values using a Jinja2 template.

Setting	Description
Jinja2 Template	The template to render. Defaults to `{'{{ input }}'}`

Available in the template:

{'{{ input }}'} — the current input
{'{{ Label_key }}'} — a State key. Dots and spaces become underscores (Summary node.response → {'{{ Summary_node_response }}'})

Clicking a State key chip below the field inserts the correct form at the cursor, so there is no need to memorize the substitution rule.

The Extract Field / Format Text mode selector, the Output Key field, and the “Use Jinja2 Template” toggle under Advanced Settings described in earlier guides no longer exist. The Transform node is now a single Jinja2 template.

Iteration node

Splits the input into items and processes each item in parallel.

Setting	Description
Iteration Mode	`Template` (render a Jinja2 template per item) or `LLM` (run an LLM call per item)
Items Source	State key holding the items. Leave empty to parse the current input
Separator	Separator used to join item results
Concurrency	Number of items processed in parallel (1–8)
Max Items	Items beyond this count are skipped

The input is parsed as a JSON array or one item per line.Template mode — in Item Template, use {'{{ item }}'} (current item), {'{{ index }}'} (item index), and {'{{ input }}'} (original input).LLM mode — set a Model (required) and a User Prompt that references {item}, {index}, and {input}. Max Tokens is also available.

LLM mode without a selected model is flagged as an error during validation.

Subflow node

Runs another flow as a sub-step and uses its final output as this node’s output.

Setting	Description
Flow	The flow to run

The picker lists every flow except the current one; when there are none it shows “No other flows available”.

Referencing itself is flagged as an error during validation. Leaving the flow unselected is an error as well.

Extract repeated preprocessing (guardrail check → glossary enrichment, etc.) into its own flow and call it as a subflow from several flows — then there is only one place to change.

Approval Gate node

Pauses the flow until a person approves. It has two output handles on the right: Approve (upper) and Reject (lower).

Setting	Description
Approval Message	Text shown to the approver. Can reference `{input}` and `{Label.key}`
On Reject	`Stop the flow` or `Take the reject branch`

Behavior: the flow stops at this node and raises an approval request. Approve continues down the approve branch; Reject either stops the flow or takes the reject branch depending on the setting. A note can be added with either decision.During a test run an Approval required card appears in the test drawer, and pressing Approve / Reject there resumes execution from that point.

Guardrail node

Applies a guardrail to validate the input. It has two output handles on the right: Pass (upper) and Block (lower).

Setting	Description
Guardrail	The guardrail to apply
Block Action	`Stop` (stop the flow immediately) / `Message` (replace output with the blocked message, default) / `Continue` (keep original text and take the false branch)
Blocked Message	Message shown when blocked

When execution takes the block branch, State includes guardrail_type (block category) and guardrail_reason (reason).

Leaving the guardrail unselected is flagged as an error during validation.

Shared setting — Error handling & retry

Every node except Start has a collapsible Error handling & retry section at the bottom of its settings panel.

Setting	Description
On error	`Stop the flow` / `Skip and continue` / `Use default value`
Default value	The substitute value used with `Use default value`
Max retries	Number of retries on failure
Retry interval (s)	Wait time between retries
Timeout (seconds, 0 = none)	Node execution time limit

The Error Handler node described in earlier guides does not exist. Fallback behavior on error is configured per node in this shared section.

Nodes not in the palette

The following types are recognized by the runner and the validator but cannot be added from the node palette.

Type	Status
Knowledge (`knowledge`)	Not in the palette. Starting from the Knowledge Base Q&A template creates a flow that already contains it, and its panel exposes Knowledge Base · Top K · Reranker Threshold
Glossary (`glossary`)	Not in the palette. Runs and configures normally if present in an imported flow
Tool (`tool`)	Runner-internal executor. Validation treats this type as an unsupported node type, so an imported legacy flow containing it will fail validation

The Aggregator, Human Input, Error Handler, and Notification nodes that earlier guides listed as “coming in a future release” do not exist in the product. Subflow, listed alongside them, is already available in the palette.

Data flow between nodes (State)

Flows pass data between nodes through a shared State object.

State key	Description
`input`	The user message (filled by the Start node)
`current_output`	Output of the previous node (updated along the chain)
`{Label.key}`	Output fields produced by each node, where `Label` is the node’s display name

The reference syntax depends on where you write it.

Location	Syntax	Example
Prompts, conditions, approval messages	Single braces	`{input}`, `{Summary node.response}`
Jinja2 templates (Transform, Merge, Iteration)	Double braces, dots and spaces become underscores	`{'{{ input }}'}`, `{'{{ Summary_node_response }}'}`

Instead of memorizing the syntax, click a State key chip in the settings panel — it inserts the form appropriate for that field at the cursor. To see which keys are live, click the Start node and read the Available State Keys list.

Workspace

AI Agents

Knowledge & Data

Safety

Customization

General

Start

Output

Agents

Agent

Model

Supervisor

Logic & Data

Condition

Router

Merge

Transform

Iteration

Subflow

Control & Safety

Approval Gate

Guardrail

Node Settings

Shared setting — Error handling & retry

Nodes not in the palette

Data flow between nodes (State)

​General

Start

Output

​Agents

Agent

Model

Supervisor

​Logic & Data

Condition

Router

Merge

Transform

Iteration

Subflow

​Control & Safety

Approval Gate

Guardrail

​Node Settings

​Shared setting — Error handling & retry

​Nodes not in the palette

​Data flow between nodes (State)

General

Agents

Logic & Data

Control & Safety

Node Settings

Shared setting — Error handling & retry

Nodes not in the palette

Data flow between nodes (State)