All nodes/AI/Agents

AI Agent

Autonomous agent with tool support. Receives a message, calls the connected tools and returns a response. Takes its model from the Model port. Optional: memory (conversation history), skills/extensions (tools).

AI Agent▶▦

ModelModel reply

MessageAgent extension

Memory

Agent extensions

Type in the graph: ai_agent

ExecSubgraph

An error output can be enabled to handle failures on their own path.

Ports can be split into separate execution and data handles.

Try it

Minimal working scenario

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 Agent extensions port, conversation memory into the Memory port, the model into the Model port. 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 (Subagent)” and fill in “Tool name” — the usual output is replaced by an Agent extension port that plugs into another agent’s Agent extensions port. By default a subagent uses its parent’s model; to give it its own, switch “Model source” to external and connect a separate LLM node.

Common mistakes

Connecting a tool with an execution edge. Tools go into the Agent 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 scenario with the WF tool node; several tools can be grouped with Toolset.

Inputs

Port	Wire	Payload	Notes
Model`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
Agent extensions`extensions`	Extension`link_extension`	—	accepts many edges

Outputs

Port	Wire	Payload	Notes
Model reply`output`	Execute + Data + Streaming`execute_data_streaming`	`object`	shown when is_subagent = false
Agent extension`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 «Expose as Tool (Subagent)» = yes
Model source`llm_source`	`string`	`from_parent`	Where a sub-agent takes its model from: the agent that calls it, or its own model wired into the Model port. Options: `from_parent` — From parent agent, `external` — Its own model shown when «Expose as Tool (Subagent)» = yes
Tool name`subagent_name`	`string`	`""`	Function name used when this agent is called as a tool shown when «Expose as Tool (Subagent)» = yes
Thinking step`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 «Thinking step» = yes
De-identify sensitive data`mask_sensitive_data`	`string`	`""`	Replace recognised personal data with markers in the text sent to the model, and restore the originals in its answer. Does not cover attachments, knowledge bases, web search or HTTP node calls. Recognition is not guaranteed to be complete. Options: — Workspace default, `on` — De-identify, `off` — Do not de-identify

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.