Pipelines

The visual pipeline editor for Agents — draw deterministic execution graphs node by node.

The pipeline is what makes an Agent an Agent (not an Assistant). It's a React Flow graph drawn in the Flow tab of the agent's modal, describing exactly how the agent executes each turn.

When to use a pipeline

Use a pipeline when you want determinism:

Same shape of execution every time, regardless of how the LLM is feeling.
Inspectable graph — you can see (and review with teammates) every step.
Mid-graph branching, looping, and variable assignment.
Explicit tool invocations and explicit sub-agent delegations.

If you don't need any of that, stay with an Assistant. The LLM is good at deciding when to call a tool.

Anatomy

A pipeline is a directed acyclic graph (DAG) of typed nodes. New agents start with just a Start node. You build out from there with the palette.

Node categories

Execution — Prompt, Process, Tool Call, Delegate, Response
Integration — REST API Request, Webhook, Code
Flow control — Condition, Loop, Wait, Change Variable
Config (inline) — Model, Identity, Sandbox, Tools, Sub-agents
Shared — Start, Note

Every edge has a label you can edit by double-clicking. Mid-edge + buttons let you insert a node between two existing ones without rewiring. Leaf nodes show a tail + Add an action button below them.

Persistence

Nodes and edges save to pipeline_nodes and pipeline_edges (both JSONB on the agents row). The Flow tab loads them on open and the editor auto-saves with debounce.

Building a pipeline

A typical flow:

Start node fires when the agent receives a turn.
A Prompt node calls the LLM with the system prompt and the user's message.
The LLM's response includes a tool intent → a Tool Call node fires the tool.
A Condition node branches based on the tool's result.
The True branch goes to a Delegate node that hands off to a sub-agent.
The False branch goes to a Response node that returns directly.

Variables and binding

Pipeline-level variables live in pipeline_variables. They have name, folder, type, description, default and current value, and visibility toggles.

Most node inputs are bindable: click the ƒ icon to open the InputBindingModal, which has three tabs:

Actions — upstream node outputs + their test results
Variables — workflow vars and built-in stores
Functions — formula functions in 7 categories: OPERATORS, CONDITIONAL, MATH, TEXT, ARRAY, OBJECT, TYPE (defined in src/components/canvas/shared/InputBindingModal.jsx, FUNCTION_CATEGORIES array). Hover any function for inline help.

The formula editor renders {{refs}} as colored badges and function calls as purple pills.

Testing nodes

Every node has a Play icon (test). Clicking runs just that node with its current inputs and shows results in the Logs panel on the left:

Status (green / red / gray)
Full request/response for HTTP nodes
JSON-tree preview for structured outputs
Search and status filters on the log

This is the fastest way to debug a pipeline — fix one node at a time.

Pipeline vs Automation

The Automation editor uses the same canvas tech and palette. The only real difference:

Pipeline — runs per-turn when this agent handles a chat or delegation.
Automation — runs standalone when its trigger fires (schedule, webhook, sub-agent call).

Many users build a complex behavior as an Automation first, then wrap it in an Agent if they want it conversation-facing.