All nodes/AI/Agents

AI Agent

Autonomous agent with tool support. Receives a message, calls connected tools (tool_out) and returns a response. Requires an LLM node via link_llm. Optional: memory (conversation history), skills/extensions (tools).

AI Agent▶▦

LLMOutput

MessageAs Tool

Memory

Extensions

Type in the graph: ai_agent

ExecSubgraph

An error branch can be enabled (expose_error_output) to handle failures on their own path.

Ports can be split into separate execution and data handles.

Try it

Minimal working workflow

Entry

AI Agent▶▦

LLM▦

Buffer Memory▶S

Exit▶

Execute + Data
LLM
Memory
Execute + Data + Streaming

Press “Copy nodes”, open the editor and hit Ctrl+V on the canvas.

Runs as pasted

When to use it

Use an AI Agent when the model has to decide for itself what to do before answering: look something up in a knowledge base, call a tool, read the history — and only then reply. Tools go into the Extensions port, conversation memory into Memory, the model into LLM. If you need neither tools nor memory, LLM Response is simpler and more predictable.

How it works

The agent works in rounds. The model answers; if it asked for tools, every call in that round runs in parallel, the results go back into the conversation, and the next round begins. “Max Tool Iterations” (10 by default) bounds the rounds, not the calls: a single round can carry a dozen tool calls. To bound the work rather than the exchanges, set “Max Tool Calls”.

When a limit is reached the agent does not fail: tools are withdrawn and the model is told to answer from what it already has — the turn always ends with an answer.

Every round appears in the run log as its own “Call N” row: input, tool calls, result and tokens.

Subagents. Turn on “Expose as Tool” and fill in “Tool Name” — the usual output is replaced by an As Tool port that plugs into another agent’s Extensions. By default a subagent uses its parent’s model; to give it its own, switch “LLM Source” to external and connect a separate LLM node.

Common mistakes

Connecting a tool with an execution edge. Tools go into the Extensions port on their own edge type, and the model — not the graph — decides the order of calls. The port accepts any number of edges.
Leaving a subagent’s “Tool Name” empty. The node fails validation: that name is what the model calls the subagent by.
Writing nodes.<id>.output.text. What travels on the edge and into templates is the answer string itself: {{ nodes.<id>.output }}.
Piling everything onto one agent. When the tool list grows, split part of it into a subagent or plug in a whole workflow with the WF tool node; several tools can be grouped with Toolset.

Inputs

Port	Wire	Payload	Notes
LLM`llm`	LLM`link_llm`	—	LLM config from llm node (registry or workspace connection) shown when is_subagent = false or llm_source ≠ "from_parent"
Message`input`	Execute + Data`execute_data`	`message`	Run trigger and user message for the agent
Memory`memory`	Memory`link_memory`	—	Memory node providing conversation history
Extensions`extensions`	Extension`link_extension`	—	accepts many edges

Outputs

Port	Wire	Payload	Notes
Output`output`	Execute + Data + Streaming`execute_data_streaming`	`object`	shown when is_subagent = false
As Tool`tool_out`	Extension`link_extension`	—	shown when is_subagent = true

Configuration

Field	Type	Default	Description
Message Source`message_source`	`string`	`connected`	connected — from edge; template — from template text Options: `connected` — Connected input, `template` — Template
User Message Template`user_prompt_template`	`string`	`""`	Used when message source is template. Supports {{inputs.message}}, {{nodes.xxx.output.yyy}} supports templates shown when message_source = template
System Prompt`system_prompt`	`string`	`""`	System prompt for the agent supports templates
Advanced
Max Tool Iterations`max_iterations`	`integer`	`10`	Max tool iterations
Max Tool Calls`max_tool_calls`	`integer`	`null`	Maximum tool calls this agent may execute (null = run budget). Max Tool Iterations only bounds rounds — one round can carry dozens of calls.
Expose as Tool (Subagent)`is_subagent`	`boolean`	`false`	When enabled, this agent can be connected as a tool to other agents
Description`description`	`string`	`""`	What this agent does. Used as tool description when Subagent mode is enabled. shown when is_subagent = true
LLM Source`llm_source`	`string`	`from_parent`	from_parent uses parent agent LLM when subagent; external uses link_llm Options: `from_parent` — From parent agent, `external` — External (link_llm) shown when is_subagent = true
Tool Name`subagent_name`	`string`	`""`	Function name used when this agent is called as a tool shown when is_subagent = true
Enable Thinking`enable_thinking`	`boolean`	`false`	After each tool call round, inject a prompt to guide the model's reasoning before continuing
Thinking Prompt`thinking_prompt`	`string`	`Analyze the tool results and think about the next steps.`	Message injected after tool results to guide the model's reasoning supports templates shown when enable_thinking = true

Shared fields

Every node has these three — the platform adds them, not the node author.

expose_error_output — When enabled, show an execution output to connect nodes that run if this step fails.
split_ports_in — Show separate execution and data input handles instead of one combined port.
split_ports_out — Show separate execution and data output handles instead of one combined port.