Node Types

Complete reference for all available workflow nodes including triggers, agents, actions, logic, and utilities.

Overview

Nodes are the building blocks of workflows. Each node type serves a specific purpose - from triggering your workflow to processing data with AI, calling external APIs, or controlling execution flow.

This reference covers every available node type, organized by category. Use it to understand what each node does and when to use it in your workflows.

New to workflows? Start with Core Concepts to understand how nodes work together, then come back to this reference when building.

Trigger Nodes

Every workflow starts with exactly one trigger. The trigger determines when and how your workflow executes - on a schedule, via a form submission, through an API call, or from an integration event.

• Manual Trigger — Run workflows on-demand with a button click

• Form Trigger — Start workflows from custom form submissions

• Webhook Trigger — Receive HTTP requests to trigger workflows

• Scheduled Trigger — Run workflows on a recurring schedule

• Integration Trigger — Start from events in connected applications

Manual Trigger

Run the workflow manually with a button click.

Use cases:

• On-demand data processing
• Testing and debugging workflows
• Workflows triggered by users in your interface

Configuration:

• No configuration required
• Can accept optional input data

Form Trigger

Start the workflow when a user submits a custom form.

Use cases:

• Intake forms (customer requests, feedback, applications)
• Data collection workflows
• Self-service automation requests

Configuration:

• Define form fields (text, number, email, dropdown, etc.)
• Set required/optional fields
• Make form public or internal-only
• Customize form title and description

Form Features:

• Generate a unique URL for your form
• Validate input before workflow starts
• Form submissions are queued and processed reliably

Public Forms: You can make forms publicly accessible for customers or partners to submit without a Odeus account.

Webhook Trigger

Receive HTTP POST requests to trigger the workflow.

Use cases:

• Integration with external systems
• Real-time event processing
• Connecting to services that support webhooks

Configuration:

• Get a unique webhook URL
• Copy the URL or use the generated curl snippet

Webhook Features:

• Receives JSON payloads
• Returns immediate response
• Processes requests asynchronously

Scheduled Trigger

Run the workflow on a recurring schedule.

Use cases:

• Daily reports and summaries
• Periodic data synchronization
• Scheduled maintenance tasks
• Recurring data analysis

Configuration:

• Select from predefined schedules (every hour, daily at 9 AM, weekdays, etc.)
• Or type a natural language description and AI generates the cron expression
• Schedules run in UTC (your local timezone is shown for reference)

Schedule Examples:

• Every day at 9 AM
• Every Monday at 8:30 AM
• First day of each month
• Every 6 hours

Integration Trigger

Start the workflow when events occur in connected applications.

Use cases:

• New Slack or Microsoft Teams message in a channel
• Email received in Gmail or Outlook inbox
• Calendar event created or starting soon
• New file or folder added to Google Drive
• New lead in Salesforce or deal in HubSpot
• New issue or pull request in Jira or GitHub

Configuration:

• Select the integration
• Choose the trigger event type
• Configure trigger parameters (channel, folder, etc.)
• Connect your account

Available Integrations:

The available triggers depend on which integrations you have enabled in your workspace.

Testing Integration Triggers: Click the play button on the trigger node to open the Test panel. You can:

• Find events: Browse recent events from your connected integration (new emails, Slack messages, etc.)
• Wait for event: Listen for the next incoming event in real-time
• Select any event to test your workflow with that actual data

---

AI Agent Nodes

The power of intelligent automation. Agent nodes use AI to analyze data, make decisions, generate content, or extract information. These are the nodes that make your workflows truly intelligent.

Agent Node

Execute an AI agent to process data with natural language instructions.

Use cases:

• Analyze and categorize content
• Extract structured data from text
• Generate summaries or reports
• Make decisions based on criteria
• Answer questions about data

Configuration:

• Select Agent: Choose an existing agent or create a new one
• Instructions: Provide context and instructions
• Input Variables: Pass data from previous nodes
• Model Selection: Choose the AI model
• Tools: Enable web search, code execution, or integrations
• Output Schema: Define structured output format (JSON)

Agent Features:

• Access to all your agents
• Can use integrated tools and actions
• Structured outputs for reliable data extraction
• View full conversation in the Messages tab

Example Agent Instructions:

Analyze the customer feedback in {{trigger.output.message}} and categorize it as:
- Product issue
- Feature request
- Billing question
- General inquiry

Also extract the sentiment (positive, neutral, negative) and provide a brief summary.

Pro tip: Use structured outputs to get reliable JSON data that you can easily use in subsequent nodes.

---

Action Nodes

Connect to your tools. Action nodes execute operations in connected applications - send emails, create tickets, update databases, post to Slack, and more.

Action Node

Perform actions in connected applications like creating tasks, sending emails, or updating records.

Use cases:

• Create tickets in support systems
• Send messages in Slack or Teams
• Add rows to spreadsheets
• Create calendar events
• Update CRM records
• Send emails

Configuration:

• Select the integration
• Choose the action type
• Select your connection (required for integrations that need authentication)
• Map input fields from previous nodes
• Configure action-specific settings

Available Actions:

Actions depend on your enabled integrations. Common actions include:

• Slack: Send message, create channel
• Google Sheets: Add row, update cell
• Gmail: Send email
• Notion: Create page, update database
• Jira: Create issue, update status

Field Mapping:

Use variables to populate action fields:

Title:
{{trigger.output.subject}}
Description: Summary:
{{agent.output.structured.summary}}

Priority:
{{condition.output.priority_level}}

---

Logic Nodes

Control the flow. Logic nodes add branching, loops, and conditional execution to your workflows. They're essential for building sophisticated, decision-driven automations.

Condition Node

Route execution down different paths based on conditions.

Use cases:

• Approval workflows (if priority is high, notify manager)
• Data routing (route to different teams based on category)
• Validation (check if required data is present)
• Multi-path workflows

Configuration:

• Define multiple conditions
• Each condition evaluates to true/false
• Execution follows the first matching condition
• Add a "default" condition for unmatched cases

Condition Modes:

• Manual: Write a condition expression
• AI-powered: Let an agent evaluate the condition with natural language

Manual Condition Examples:

{{trigger.output.amount > 1000 }}
{{agent.output.sentiment === "negative" }}
{{trigger.output.role === "admin" && trigger.output.urgent === true }}

AI-powered Conditions:

Determine if this customer message requires urgent attention based on:
- Mentioned keywords like "urgent", "emergency", "asap"
- Angry or frustrated tone
- High-value customer status

Multiple Conditions: By default, conditions are evaluated in order and the workflow follows the first condition that matches. Enable "Allow multiple conditions" to execute all matching paths simultaneously.

Loop Node

Iterate over an array and execute nodes for each item.

Use cases:

• Process multiple items from a list
• Batch operations on records
• Generate individual reports for each item

Configuration:

• Input Array: The array to iterate over (e.g., {{trigger.output.items }} or [1, 2, 3])
• Parallel Execution: Enable to run all iterations simultaneously instead of sequentially
• Max Iterations: Safety limit to prevent runaway loops (default: 200, max: 2000)

Inside the Loop:

The loop node's slug becomes your variable name. Access the current item and iteration info:

{{ my_loop.output.currentItem }}        // The current item being processed
{{ my_loop.output.currentItem.name }}   // Access properties on the item
{{ my_loop.output.currentIndex }}       // Current iteration index (0-based)
{{ my_loop.output.total }}              // Total number of items

Loop Example:

If you have an array of customer records from a trigger:

[
  { "name": "Alice", "email": "[email protected]" },
  { "name": "Bob", "email": "[email protected]" }
]

With a loop node named customer, access fields like:

{{ customer.output.currentItem.name }}
{{ customer.output.currentItem.email }}

Cost Management: Loops can consume significant credits if processing many items with AI agents. Set appropriate iteration limits and consider enabling parallel execution for independent operations.

---

Utility Nodes

Extra capabilities. Utility nodes extend your workflows with code execution, web searches, HTTP requests, and notifications. Use these for custom transformations and specialized tasks.

Code Node

Execute custom JavaScript or Python code for data transformation.

Use cases:

• Complex data transformations
• Mathematical calculations
• Custom business logic
• Data formatting and cleaning

Configuration:

• Write your code in JavaScript or Python
• Access previous node outputs as variables
• Return data with return statement

Example:

// Access data from previous nodes
const email = trigger.output.email;
const items = api_response.output.items || [];

// Transform data
const total = items.reduce((sum, item) => sum + item.price, 0);

return {
  customer_email: email,
  total_amount: total,
  item_count: items.length,
};

Available Variables:

All previous node outputs are available as variables. Access them using the node slug:

trigger.output          // Trigger node output
agent.output            // Agent node output
api_response.output     // HTTP Request node output

Web Search Node

Search the web and retrieve relevant information.

Use cases:

• Fact-checking and verification
• Market research
• Current events and news
• Finding specific information

Configuration:

• Query: Define the search query
• Mode: Automatic (AI generates query) or Manual (you specify)
• Number of Results: How many results to return

Query Modes:

• Automatic: AI generates the search query based on context
• Manual: You specify the exact search terms
• Prompt: Write instructions for AI to generate the query

Output:

Returns search results with:

• Title and URL
• Snippet/description
• Relevance score

HTTP Request Node

Make HTTP requests to external APIs.

Use cases:

• Fetch data from your own APIs
• Integrate with services without native integration
• Custom webhooks and API calls

Configuration:

• Method: GET, POST, PUT, DELETE, PATCH
• URL: The endpoint URL (can include variables)
• Headers: Add custom headers (authentication, content-type)
• Query Parameters: Add URL parameters
• Body: Request payload for POST/PUT (JSON)

Authentication:

Add authentication headers:

Authorization: Bearer {{ your_api_token }}

URL with Variables:

https://api.example.com/users/{{trigger.output.user_id}}/orders

Request Body Example:

{
  "title": "{{agent.output.summary }}",
  "description": "{{trigger.output.content }}",
  "status": "open"
}

Send Notification Node

Send in-app notifications to your Odeus inbox.

Use cases:

• Workflow completion notifications
• Error alerts requiring attention
• Status updates and summaries
• Personal reminders from automated workflows

Recipients:

• Manual/Form triggered workflows → User who triggered the workflow
• Scheduled/Webhook/Integration triggered workflows → Workflow owner

Configuration:

• Message: Notification content (supports variables and markdown)

Message Example:

New high-priority support ticket received: Customer:
{{trigger.output.customer_name}}
Issue:
{{agent.output.structured.category}}
Summary:
{{agent.output.structured.summary}}

View ticket:
{{action.output.ticket_url}}

Image Generation Node

Generate images from text prompts using AI models.

Use cases:

• Marketing visual creation
• Product image generation
• Dynamic content imagery
• Report visuals

• Image Generation — Full configuration guide for AI image generation

Guardrails Node

Validate AI outputs and workflow data with automated safety checks.

Use cases:

• Content moderation
• PII detection
• Hallucination detection
• Jailbreak prevention
• Custom validation rules

• Guardrails — Full configuration guide for content validation

File Search Node

Search your folders to retrieve relevant information.

Use cases:

• Knowledge base queries
• RAG (Retrieval Augmented Generation)
• Document search
• Context enrichment

• File Search — Full configuration guide for folder search

Delay Node

Pause workflow execution for a specified duration.

Use cases:

• API rate limiting
• Polling with backoff
• Waiting for external processes
• Retry delays

• Delay — Full configuration guide for workflow delays

---

Quick Reference

Node Type	Purpose	Common Use Cases
Manual Trigger	On-demand execution	Testing, ad-hoc processing
Form Trigger	Form submissions	Data collection, intake forms
Webhook Trigger	HTTP requests	Integration events, API calls
Scheduled Trigger	Time-based execution	Reports, data syncs, maintenance
Integration Trigger	App event listeners	Slack events, calendar, email triggers
Agent Node	AI analysis & generation	Categorization, summarization, decisions
Action Node	Integration operations	CRM updates, notifications, data storage
Condition Node	Branching logic	Routing, validation, approval flows
Loop Node	Array iteration	Batch processing, multi-item operations
Code Node	Custom transformations	Data formatting, calculations
Web Search Node	Internet queries	Research, fact-checking, current events
HTTP Request Node	API calls	Custom integrations, data fetching
Send Notification	Team alerts	Status updates, failure alerts
Image Generation	AI image creation	Marketing visuals, dynamic imagery
Guardrails	Content validation	Moderation, PII detection, compliance
File Search	Knowledge retrieval	RAG, document search, context enrichment
Delay	Execution pause	Rate limiting, polling, retry delays

Next Steps

Now that you understand all available nodes, start building:

• Getting Started Guide — Build your first workflow in 15 minutes

• Use Cases — See real-world workflow examples

• Getting Started — Build your first workflow

• Core Concepts — Learn how nodes work together