Workflow

Workflow Tools

Build tools visually with a no-code drag-and-drop interface.

---

Overview

Workflow tools enable process automation through a visual flow builder. Design multi-step workflows by connecting nodes—no coding required.

┌─────────┐    ┌──────────┐    ┌─────────────┐    ┌─────────┐
│  Start  │───▶│ Validate │───▶│  Call API   │───▶│   End   │
└─────────┘    └──────────┘    └─────────────┘    └─────────┘

---

When to Use

Workflow tools are ideal when:

• Business logic is well-defined and consistent
• You need visual traceability for debugging
• Non-developers need to build or maintain tools
• Processes involve multiple sequential steps
• You want built-in monitoring and audit logs

Good Fit Examples

Use Case	Why Workflow Works
Order status lookup	Clear input → API call → formatted output
Weather retrieval	Simple API integration with response mapping
Database queries	Structured data fetch with transformation
Notification sending	Multi-channel delivery with conditions

---

Visual Flow Builder

The workflow builder provides a node-based canvas where you design tool logic by connecting components.

Interface

┌─────────────────────────────────────────────────────────────┐
│  Workflow: get_order_status                    [Test] [Deploy]│
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────┐                                                │
│  │  START  │                                                │
│  └────┬────┘                                                │
│       │                                                      │
│       ▼                                                      │
│  ┌─────────────────┐                                        │
│  │  Validate Input │                                        │
│  └────────┬────────┘                                        │
│           │                                                  │
│       ┌───┴───┐                                             │
│       ▼       ▼                                             │
│  ┌────────┐ ┌────────┐                                      │
│  │ Valid  │ │Invalid │                                      │
│  └───┬────┘ └───┬────┘                                      │
│      │          │                                            │
│      ▼          ▼                                            │
│  ┌────────┐ ┌────────┐                                      │
│  │API Call│ │ Error  │                                      │
│  └───┬────┘ └───┬────┘                                      │
│      │          │                                            │
│      └────┬─────┘                                            │
│           ▼                                                  │
│      ┌─────────┐                                            │
│      │   END   │                                            │
│      └─────────┘                                            │
│                                                              │
└─────────────────────────────────────────────────────────────┘

---

Node Types

Control Nodes

Node	Purpose
Start	Entry point, receives input parameters
End	Exit point, returns output
Condition	Branching based on logic
Loop	Iterate over collections

Action Nodes

Node	Purpose
API	Make HTTP requests to external services
Function	Transform data with expressions
Integration	Connect to pre-built connectors
Human	Pause for human input/approval

AI Nodes

Node	Purpose
Text-to-Text	Generate text with LLM
Text-to-Image	Generate images
Audio-to-Text	Transcribe audio
Image-to-Text	Analyze images
DocSearch	Search knowledge bases

---

Building a Workflow

Step 1: Create the Tool

1. Navigate to Tools → + New Tool
2. Select Workflow Tool
3. Enter name and description:

name: get_weather
description: |
  Retrieves current weather conditions for a specified location.
  Returns temperature, conditions, and forecast summary.

Step 2: Define Input Parameters

Configure what the tool accepts:

parameters:
  location:
    type: string
    description: City name or coordinates
    required: true

  units:
    type: string
    enum: [celsius, fahrenheit]
    default: celsius

Step 3: Build the Flow

Drag nodes onto the canvas and connect them:

Start
  │
  ▼
┌─────────────────────────┐
│ API Node: Weather API   │
│ URL: api.weather.com    │
│ Method: GET             │
│ Params: location, units │
└───────────┬─────────────┘
            │
            ▼
┌─────────────────────────┐
│ Function: Format Output │
│ Transform response to   │
│ user-friendly format    │
└───────────┬─────────────┘
            │
            ▼
          End

Step 4: Configure Nodes

For each node, set properties:

API Node Example:

url: https://api.weather.com/v1/current
method: GET
headers:
  Authorization: Bearer {{env.WEATHER_API_KEY}}
query_params:
  q: "{{input.location}}"
  units: "{{input.units}}"

Function Node Example:

return {
  temperature: response.main.temp,
  condition: response.weather[0].description,
  humidity: response.main.humidity,
  location: response.name
}

Step 5: Define Output

Specify the return structure:

output:
  type: object
  properties:
    temperature:
      type: number
    condition:
      type: string
    humidity:
      type: number
    location:
      type: string

Step 6: Test

1. Click Test
2. Provide sample input:
   {
     "location": "Tokyo",
     "units": "celsius"
   }
   
3. Review execution trace
4. Verify output

Step 7: Deploy

Click Deploy to generate API endpoints.

---

Execution Modes

Synchronous

Default mode—request waits for completion.

Request → Execute all nodes → Return response

Timeout: Configurable, default 30 seconds.

Asynchronous

For long-running workflows.

execution:
  mode: async
  callback:
    url: https://your-app.com/webhook
    auth: Bearer {{env.WEBHOOK_TOKEN}}

---

Conditions and Branching

Use condition nodes for logic:

                    ┌─────────────┐
                    │  Condition  │
                    │ amount > 100│
                    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
         ┌────────┐   ┌────────┐   ┌────────┐
         │  True  │   │ False  │   │Default │
         └────────┘   └────────┘   └────────┘

Expression syntax:

// Comparisons
input.amount > 100
response.status === "success"

// Logical operators
input.priority === "high" && input.urgent === true

// String operations
input.email.includes("@company.com")

---

Loops

Iterate over arrays:

┌──────────────────────────────┐
│ Loop: for each item in list  │
├──────────────────────────────┤
│  ┌─────────────────────────┐ │
│  │  Process Item           │ │
│  └─────────────────────────┘ │
└──────────────────────────────┘

Configuration:

loop:
  collection: "{{response.items}}"
  item_variable: current_item
  max_iterations: 100

---

Error Handling

Configure fallbacks for failures:

error_handling:
  on_error: continue  # or: stop, retry
  retry:
    attempts: 3
    delay_ms: 1000
  fallback:
    node: error_handler

---

Environment Variables

Store sensitive data securely:

# Access in nodes
url: "{{env.API_BASE_URL}}/endpoint"
headers:
  Authorization: "Bearer {{env.API_KEY}}"

Setting variables:

1. Navigate to tool settings
2. Add environment variables
3. Mark sensitive values as secrets

---

Guardrails

Enable safety scanning for AI nodes:

guardrails:
  input_scanning: true
  output_scanning: true
  scanners:
    - toxicity
    - pii_detection
    - jailbreak_detection

---

Monitoring

Track workflow performance:

• Execution history — All runs with status
• Performance metrics — Response times, success rates
• Node-level traces — Debug individual steps
• Audit logs — Configuration changes

---

Best Practices

Keep Workflows Focused

One workflow = one capability. Don’t combine unrelated logic.

Use Meaningful Names

# Good
get_customer_orders
validate_shipping_address
process_refund_request

# Avoid
workflow_1
helper
do_stuff

Handle Errors Gracefully

Always include error paths and meaningful error messages.

Test Edge Cases

• Invalid inputs
• API failures
• Empty responses
• Timeout scenarios

Document Complex Logic

Add comments to condition expressions and complex transformations.

---

Related

• Tools Overview
• Code Tools
• MCP Tools
• Tool Calling