Node types

Input

The Input node is the workflow's entry point. It defines what the workflow accepts — a chat message, or a structured object whose fields you define. Everything downstream reads from it. A workflow has exactly one Input.

→ Input component

Output

The Output node is the workflow's result. It assembles the final value from the steps you wire into it — a single value, or an object with named keys. A workflow has exactly one Output.

→ Output component

Agent

The Agent node is an AI step. It works like the standalone agent builder: its card holds the Connection (the model it thinks with), its Inputs, its System Instructions, its Tools, and its Configuration — sampling, reasoning, the harness, conversation history, approval for all tool calls, batching, and an Output Structure for returning a typed object. Use it anywhere a step needs judgment rather than fixed logic.

An Agent node can also reference a prebuilt agent from Studio → Agents instead of being configured in place: pick it under Agent, and the node runs that agent as-is (Switch to inline agent goes back).

An agent node has an extra Tools handle for the tools it may call — see Tools on the canvas. When its input resolves to a list, it can batch: run once per item, in parallel, with an ordered list of results — see Batching over a list.

Prompt

The Prompt node renders a text template. Write text with {{name}} placeholders, bind each one to a value, and the node outputs the filled-in text — a lightweight way to build a message or an input without involving a model.

→ Prompt component

Embeddings

The Embeddings node turns text into vectors with an embedding model — splitting a document into chunks first — for vector pipelines you build yourself.

→ Embeddings component

Dataset

The Dataset node searches a dataset, or adds and removes its documents. Pick the dataset and an action; search returns the top matching passages, ready to bind into a Prompt or an agent's input.

→ Dataset component

Workflow

The Workflow node runs another workflow as a step. Pick a workflow from the project and bind its inputs; its output flows on like any other node. This is how you reuse a workflow inside a larger one. See Composing workflows.

Processing nodes are deterministic building blocks for documents and data — no model reasoning involved, so they behave the same way every time.

• Document Splitter — split a PDF into page chunks, so a long document can fan out across many agent calls.
• Document Parser — read a document's text — PDF, Word, Excel, or text — using OCR for scanned pages.

A processing node that can do more than one thing has an Action to choose, just like an integration.

An Integration node calls a connected service. Every integration type appears in the palette — built-in ones and your project's custom OpenAPI integrations — whether or not you've connected it yet. To configure one you:

• pick the Connection to run through,
• choose an Action (the specific operation to perform),
• and bind the action's inputs to values from earlier steps.

Some inputs offer choices right on the card — for example, a Postgres node lists your tables. The connection you pick here is the default; a deployment can point a live workflow at a different connection without editing it.

Besides running as steps, some nodes can be attached to an agent as tools the agent calls when it chooses:

• Integrations — Postgres, S3, and custom integrations (not Qdrant).
• Processing nodes — Document Splitter and Document Parser.
• Dataset nodes, once a dataset is picked.
• Workflow nodes, once a workflow is picked.
• Agent nodes that reference a prebuilt agent.