Agent Node

An autonomous AI agent that can stack nodes inside it and automatically access all data from the workflow without manual variable wiring.

Overview

The Agent node is a container node — similar to the Model node but with a key difference: you can stack other nodes inside it, and the selected model automatically has access to extract and use all data from those inner nodes without you having to set up variable mappings manually.

Think of it as giving an LLM full autonomy over a set of tools. You drop nodes inside the Agent (MCP Servers, HTTP Requests, Database queries, etc.), pick a model, and the agent decides when and how to use each tool to accomplish the task.

Configuration

Advanced Options

Under Model Settings:

Scheduled Tasks

With Scheduled Tasks on, people can ask the agent in the chat to do something later or on a schedule, for example "every morning at 9, check our prices". Each person sees and manages their own tasks, and every run reports back in the conversation where it was asked.

Calling Other Agents

With Can call other agents on, the agent can ask other agents in the same workspace for help. Only agents that have Other agents can call this one turned on in their Flow Start can be called. Called agents work for the same person, with that person's accounts.

How It Works

1. Drag an Agent node onto the canvas.
2. Select a model (same providers as the Model node).
3. Drop tool nodes inside the Agent container — these become the agent's available tools.
4. Write a system prompt and user prompt describing the task.
5. The agent autonomously decides which inner nodes to call, in what order, and how to combine their results.

The agent loops through a reason → act → observe cycle:

• Reason: The model analyzes the task and decides what to do next.
• Act: It invokes one of the inner nodes (tools) with the appropriate arguments.
• Observe: It reads the result and decides whether to continue or return a final answer.

Inner Nodes (Tools)

Any node you place inside the Agent container becomes a tool the agent can invoke. The agent automatically sees:

• The node's name and description
• Its input schema (what arguments it accepts)
• Its output data (the result after execution)

No manual variable wiring needed — the agent handles data flow between inner nodes on its own.

Supported Inner Nodes

Attach a node by double-clicking inside the Agent container and picking it from the list.

Agents from the Agents page

Agents created on the Agents page start from a capability level, which you can change later in the builder:

Example: Research Agent

Stack a Web Scraper and Model inside the Agent to create a research assistant:

Flow Start → [Agent]
                 ├── Web Scraper (search the web)
                 ├── HTTP Request (fetch APIs)
                 └── (agent reasons over results)
             → Simple Output

Example: Customer Support Agent

Give the agent access to your CRM and knowledge base:

Flow Start → [Agent]
                 ├── MCP Server (CRM — lookup customer)
                 ├── Database (knowledge base search)
                 ├── MCP Server (ticketing — create ticket)
                 └── (agent handles the conversation)
             → Simple Output

Example: Data Pipeline Agent

Let the agent orchestrate a multi-step data extraction:

HTTP Request (get raw data) → [Agent]
                                  ├── Code (parse & clean)
                                  ├── Database (enrich with lookups)
                                  ├── Code (transform to target schema)
                                  └── (agent chains steps automatically)
                              → Write Data

Agent vs Model Node

Best Practices

• Write clear system instructions that define the agent's role, boundaries, and expected output format
• Only place nodes inside the Agent that are relevant to the task — fewer tools means faster, more focused reasoning
• Attach only the tools the task needs; every extra tool is one more thing the model has to choose between
• Use lower Temperature (0.2-0.5) for deterministic tasks like data extraction, higher (0.7-1.0) for creative tasks
• Test the agent with simple tasks first, then add more tools incrementally
• Store sensitive credentials in the Vault — the agent inherits access to vault variables just like any other node