Tools

Tools extend your AI Agent's capabilities by letting it interact with external services. Connect any supported node to the agent's tools handle and the agent will automatically know how to call it.

Tools are optional

Unlike memory, tools are not required. An AI Agent without any connected tools will still function as a conversational assistant using only the built-in get_current_time and calculate tools.

Two Patterns

NodeLoom offers two ways to give your agent access to tools. Choose the one that fits your use case:

Pattern	Complexity	When to Use
Direct Connection	Simple	You want one tool per node with automatically derived name, description, and schema.
Agent Tool Wrapper	Advanced	You need custom tool names, descriptions, schemas, or want to expose multiple tools from a single node.

Direct Connection

The simplest way to add tools. Drag an edge from a supported action node directly into the AI Agent's tools handle. NodeLoom automatically derives the tool's name, description, and input schema from the connected node's type and configuration.

How Auto-Derivation Works

Name -- generated from the node type, e.g. a Gmail node becomes send_gmail, a Slack node becomes send_slack_message.
Description -- a human-readable summary of what the tool does, derived from the node's purpose and configured operation.
Input schema -- a JSON schema describing the parameters the LLM should provide when calling the tool. Only required fields from the node's config that are not already pre-filled are included in the schema.

Supported Nodes

The following nodes can be directly connected to an AI Agent's tools handle:

Node	Auto-Derived Tool Name	Schema Includes
Gmail	`send_gmail`	to, subject, body, cc (optional), bcc (optional)
Slack	`send_slack_message`	channel, message, thread_ts (optional)
Discord	`send_discord_message`	channel_id, content, embed (optional)
Google Sheets	`google_sheets_operation`	spreadsheet_id, range, values (for write), operation type
Google Calendar	`google_calendar_event`	summary, start_time, end_time, description (optional), attendees (optional)
Google Drive	`google_drive_operation`	operation, file_id or folder_id, name (optional)
Google Docs	`google_docs_operation`	document_id, content, operation type
HTTP Request	`http_request`	url, method, headers (optional), body (optional)
Database	`database_query`	query, parameters (optional)

Pre-filled fields are hidden

If you have already configured a Gmail node with a recipient address, that field will not appear in the tool's input schema -- the agent will use the pre-filled value automatically.

Agent Tool Wrapper

The Agent Tool Wrapper is a special node that wraps any action node and gives you full control over how it is presented to the agent. Use it when:

You want a custom tool name that is more descriptive than the auto-derived one (e.g. lookup_customer_order instead of http_request).
You want a custom description that gives the LLM better instructions on when and how to use the tool.
You want a custom input schema that exposes only specific parameters or renames them for clarity.
You want to expose multiple tools from the same underlying node (e.g. one HTTP Request node configured as both "search_products" and "get_product_details").

Configuration

Field	Required	Description
`Tool Name`	Yes	The name the LLM sees. Use snake_case, be descriptive, and keep it under 64 characters.
`Tool Description`	Yes	A natural language description of what the tool does. The better the description, the more reliably the agent will use it correctly.
`Input Schema`	No	A JSON Schema object describing the parameters. If omitted, the auto-derived schema from the target node is used.
`Target Node`	Yes	The action node this wrapper delegates to. Connected via the wrapper's output handle.

Credential Inheritance

The Agent Tool Wrapper inherits credentials from its target node. You do not need to configure credentials on the wrapper itself -- when the agent invokes the tool, NodeLoom resolves the credentials from the target node's configuration. This ensures a single source of truth for credential management.

Wrapper configuration example

// Example: Agent Tool Wrapper configuration
{
  "toolName": "search_customer_orders",
  "toolDescription": "Search for customer orders by email address or order ID. Returns order status, items, and tracking info.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Customer email address or order ID to search for"
      }
    },
    "required": ["query"]
  }
}

Subflow Nodes as Tools

Subflow nodes are fully compatible with the AI Agent's tools handle. This means you can build an entire multi-step workflow, package it as a subflow, and connect it as a tool. The agent sees it as a single tool and can invoke it like any other.

This is especially powerful for:

Complex operations that require multiple nodes (e.g. fetch data from an API, transform it, then write to a spreadsheet).
Reusable tool logic that you want to share across multiple agents.
Encapsulating error handling and retry logic inside the subflow.

Subflow schema

When connecting a subflow as a tool, NodeLoom derives the input schema from the subflow's input parameters. Use the Agent Tool Wrapper if you need to customize the schema.

Best Practices

Keep tool counts reasonable. Most LLMs perform best with 5-15 tools. Adding more can reduce accuracy of tool selection.
Write clear descriptions. The tool description is the primary signal the LLM uses to decide which tool to call. Describe the purpose, expected inputs, and what the tool returns.
Pre-fill what you can. If a field always has the same value (e.g. a specific Slack channel), set it in the node config so the agent does not have to guess.
Use wrappers for HTTP Request nodes. Generic tool names like http_request give the LLM little context. Wrapping them with descriptive names greatly improves reliability.
Test with the Agent Chat. Use the Agent Chat interface to test tool invocations interactively before deploying your workflow.

Memory

Agent Chat