Overview

The Workflows feature enables you to chain 2+ MCP tools together into multi-step automated processes. Instead of manually executing tools one at a time and copying outputs between them, workflows orchestrate the entire sequence—automatically mapping outputs from one step as inputs to the next.

Perfect for testing complex scenarios, automating repetitive tasks, and validating multi-tool interactions in your MCP server implementations.

Key Capabilities

🔗 Multi-Step Tool Chaining

Chain 2+ MCP tools where output from one feeds into the next

🎨 Visual Workflow Designer

Hybrid List + Inspector layout (master-detail interface)

🗺️ Intelligent Parameter Mapping

Three source types: previous step outputs, manual values, or runtime prompts

🔍 JSON Property Selector

Browse button opens modal with clickable property tree from tool response schemas

🔁 Array Iteration (Batch Processing)

Iterate over array elements with “Each”, “First”, or “Last” modes - execute steps once per array element

📊 Schema Analysis

Automatically extracts required parameters with split-view Required Parameters panel

⚡ Real-time Execution Progress

Animated indicator with step counter, tool name, and gradient progress bar

📜 Execution History

Last 10 executions saved per workflow with tabbed results viewer

🏷️ Property Highlighting

Mark properties to highlight in results for easy identification

📤 Import/Export

Share workflows as JSON files with wider modal for readability

⚠️ Configurable Error Handling

Choose per-step whether to stop or continue on error

🔌 Connection Selection

Set default connection with ability to change per execution

Understanding Array Iteration (Batch Processing)

One of the most powerful workflow features is Array Iteration - the ability to automatically execute a workflow step multiple times, once for each element in an array from a previous step.

Why Array Iteration Matters

Without array iteration:

  ❌ Manual approach:
1. Get list of 50 devices
2. Manually note first device ID
3. Run remediation tool with first ID
4. Manually note second device ID
5. Run remediation tool with second ID
6. Repeat 48 more times... 😫

With array iteration:

  ✅ Automated approach:
1. Get list of 50 devices
2. Set up remediation step with "Each" mode
3. Execute workflow once
4. All 50 devices processed automatically! 🚀

Real-World Use Cases

Device Management:

  • Query noncompliant devices → Remediate each one automatically
  • List devices → Fetch detailed properties for each
  • Find devices by criteria → Update configuration on each

User Administration:

  • Get department members → Send onboarding email to each
  • Query inactive accounts → Disable each one
  • List license assignments → Audit each user’s entitlements

Data Processing:

  • Fetch file list → Download each file
  • Query database records → Transform each record
  • List API resources → Validate each resource

Testing & Validation:

  • Get test cases → Execute each test
  • List configurations → Validate each config
  • Fetch endpoints → Health check each endpoint

How It Works Technically

When you configure a parameter with “From Previous Step” source and “Each” iteration mode:

  1. Workflow engine extracts the array from previous step’s output
  2. Counts total elements (e.g., 10 devices)
  3. Loops through each element automatically
  4. For each iteration:
    • Creates a new tool invocation
    • Passes the current element’s value as parameter
    • Executes the tool
    • Captures the result
    • Continues to next element (or stops if error mode = Stop)
  5. Aggregates all results into execution history
  6. Reports final status (Completed or Partially Completed)

Performance Considerations

Execution time:

  • Each iteration runs sequentially (not parallel)
  • If one tool call takes 2 seconds, 10 iterations = ~20 seconds
  • Factor this into workflow design

Result size:

  • Each iteration produces its own result
  • 100 iterations = 100 result sets
  • Large batches may consume significant memory
  • Consider pagination for very large arrays (split into multiple workflows)

Best practices:

  • Test with small arrays first (5-10 elements)
  • Use “First” mode to validate logic before “Each”
  • Monitor execution progress indicator
  • Set reasonable timeouts for long-running batches

Iteration Modes Compared

ModeBehaviorIterationsUse Case
NoneExtract literal path1When you want exactly array[0]
EachLoop all elementsN (array length)Batch processing
FirstGet first element1Test or sample first item
LastGet last element1Get most recent entry

Getting Started

Step 1: Connect to a Server

Workflows require an active MCP connection to access tools.

  1. Navigate to 🔌 Connections tab
  2. Configure and save a connection
  3. Return to 🔗 Workflows tab
  4. Connection will be available for workflow execution

📸 Screenshot:

Description: Show the Workflows page header with “No connection” badge and the Connections button visible

Step 2: Create Your First Workflow

  1. Click ➕ New Workflow button in the top-right
  2. Enter a Workflow Name (required)
  3. Add an optional Description of what it does
  4. Select a Default Connection (can be changed at runtime)
  5. Click ➕ Add Step to create your first step

📸 Screenshot:

Description: Show the workflow editor with empty name/description fields and the “Add Step” button

Step 3: Add Workflow Steps

Each step executes one MCP tool and can use outputs from previous steps.

To add a step:

  1. Click ➕ Add Step
  2. Select a Tool from the dropdown
  3. Configure Parameter Mappings (see below)
  4. Set Error Handling mode (Stop or Continue)
  5. Add optional Notes for documentation

📸 Screenshot:

Description: Show a workflow step card with tool dropdown, parameter mappings section, error handling options, and notes field

Step 4: Map Parameters

For each tool parameter, choose where the value comes from:

Three mapping source types:

  1. From Previous Step: Use output from an earlier step

    • Select which step (or use previous)
    • Enter JSON path (e.g., result.data[0].userId)
    • Click 🔍 Browse to open Property Selector

  2. Manual Value: Enter a constant value

    • Type directly into the text field
    • Useful for fixed configuration values

  3. Prompt at Runtime: Ask for value during execution

    • User will be prompted when workflow runs
    • Ideal for dynamic or sensitive values

Array Iteration (when using From Previous Step):

When your property path references arrays, an Array Iteration dropdown appears giving you powerful batch processing capabilities. This feature allows a single workflow step to process multiple items from a previous step’s output.

Four iteration modes:

  1. None (as-is) - Default behavior

    • Extracts value exactly as specified in the path
    • Use for paths with explicit array indexes: data[0].id
    • No iteration occurs

  2. Each - Batch processing

    • Executes the current step once for each element in the array
    • Most powerful mode for bulk operations
    • Produces multiple results (one per array element)
    • Ideal for processing lists of devices, users, files, etc.

  3. First - Get first element

    • Extracts only the first element from the array
    • Equivalent to array[0] but more explicit
    • Useful for “get the latest” scenarios

  4. Last - Get last element

    • Extracts only the last element from the array
    • Useful for “get the most recent” scenarios

How It Works:

When you select “From Previous Step” as your parameter source:

  1. Choose which step to pull data from (or use “Previous Step”)
  2. Enter the JSON path (e.g., data[0].id or use 🔍 Browse)
  3. Select iteration mode from the dropdown (appears automatically for array paths)
  4. Save and execute - the step runs once or multiple times based on mode

Example: Processing Multiple Devices

If Step 1 (list_noncompliant_devices) returns:

  {
  "data": [
    { "id": "abc-123", "name": "Device 1", "os": "Windows" },
    { "id": "def-456", "name": "Device 2", "os": "macOS" },
    { "id": "ghi-789", "name": "Device 3", "os": "Linux" }
  ]
}

Step 2 configuration:

  • Tool: remediate_device
  • Parameter: deviceId
  • Source: From Step 1
  • JSON Path: data[0].id
  • Array Iteration: Your choice determines behavior

Results by iteration mode:

ModeExecutionsValues PassedUse Case
None1 time"abc-123" onlyProcess just the first device (literal [0])
Each3 times"abc-123", "def-456", "ghi-789"Remediate ALL devices
First1 time"abc-123"Test remediation on first device only
Last1 time"ghi-789"Process most recently added device

info: Key Difference: With None, you get data[0].id literally (first element). With Each, you get ALL elements’ IDs automatically - the step runs 3 separate times!

Selecting From Specific Steps:

You can reference arrays from any previous step, not just the immediately preceding one:

Example workflow:

  Step 0: get_tenant_devices    → Returns 50 devices
Step 1: filter_by_compliance  → Returns 12 noncompliant devices  
Step 2: get_device_details    → Gets details for one device
  ├─ deviceId: [From Step 1] data[0].id
  └─ Array Iteration: Each      → Runs 12 times (once per noncompliant device)

Step 2 references Step 1 (skipping Step 0) to process the filtered list.

Nested Arrays:

The iteration mode applies to the first array encountered in your property path.

Example path: devices[0].alerts[0].id

  • Selecting “Each” iterates over the devices array
  • Each execution receives: devices[0].alerts[0].id, devices[1].alerts[0].id, devices[2].alerts[0].id, etc.
  • To iterate over the nested alerts array, create a separate step

Multi-level iteration workflow:

  Step 1: get_devices
  Returns: { "devices": [ { "alerts": [...] }, { "alerts": [...] } ] }

Step 2: process_device_alerts
  ├─ device: [From Step 1] devices[0]
  └─ Array Iteration: Each       → Iterates devices array

Step 3: handle_alert
  ├─ alert: [From Step 2] alerts[0]
  └─ Array Iteration: Each       → Iterates alerts within each device

This creates a nested loop: Step 2 runs once per device, Step 3 runs once per alert in each device.

📸 Screenshot:

Description: Show parameter mapping interface with the three source type options and an example JSON path entered

Step 5: Use JSON Property Selector

The 🔍 Browse button helps you discover available properties from previous steps.

How to use:

  1. Click 🔍 Browse next to a parameter mapping
  2. Modal opens showing the tool response schema
  3. Browse the property tree with nested objects/arrays
  4. Click a property to select it
  5. JSON path is automatically inserted (e.g., result.items[0].id)

📸 Screenshot:

Description: Show the JSON Property Selector modal with an expanded property tree displaying nested objects and arrays, with some properties highlighted as clickable

info: Smart Paths: The selector handles nested objects and array indexing automatically. Click items → [0] → id to get result.items[0].id.

Step 6: Save and Execute

Once your workflow is configured:

  1. Click 💾 Save in the workflow editor
  2. Workflow appears in the left panel list
  3. Select the workflow to view details
  4. Choose a Connection (if different from default)
  5. Click ▶️ Execute Workflow
  6. Watch real-time progress indicator
  7. View results in tabbed interface

📸 Screenshot:

Description: Show the workflow detail view with the Execute button, connection selector, and the execution progress interface with animated spinner

Workflow Execution

Real-time Progress Tracking

During execution, you’ll see:

Progress elements:

  • Animated spinner icon (rotating)
  • Step counter: “Executing Step 2 of 5”
  • Tool name: Which tool is currently running
  • Progress bar: Gradient showing completion percentage
  • Status updates: Real-time step completion

📸 Screenshot:

Description: Show the progress indicator with all elements visible: spinner, step counter “Executing Step 2 of 4”, tool name, and gradient progress bar at 50%

Auto-Connect Feature

If the selected connection isn’t active:

  1. Workflow execution automatically connects
  2. You see “Connecting…” status
  3. Once connected, steps begin executing
  4. No manual intervention needed

This ensures workflows always run with fresh connections!

Execution Results Viewer

After execution completes, results are displayed in horizontal tabs:

Tab format:

  [Step 1: get_user ✓] [Step 2: update_profile ✓] [Step 3: send_email ✗]

Status badges:

  • ✓ Success
  • ✗ Error
  • ⏱ Running (during execution)

Each tab shows:

  • Tool name
  • Execution status
  • JSON response from that step
  • Highlighted properties (if configured)
  • Execution timestamp
  • Duration

📸 Screenshot:

Description: Show the horizontal tabs with 3-4 steps, some with success checkmarks and one with an error X. Below the tabs, show the JSON response for the selected step

Execution History

MCP Explorer automatically saves the last 10 executions per workflow.

To view history:

  1. Select a workflow from the list
  2. Scroll to Execution History section
  3. Click any execution to view its results
  4. Compare results across runs
  5. Debug failures by reviewing previous attempts

Each history entry shows:

  • Execution timestamp
  • Final status (Completed/Failed/Partially Completed)
  • Duration
  • Step count
  • Connection used

📸 Screenshot:

Description: Show a list of execution history entries with timestamps, status badges, and durations. One entry should be selected/expanded showing its full results

Advanced Features

Property Highlighting

Mark specific JSON properties to highlight in execution results.

How to use:

  1. Edit your workflow
  2. Scroll to Highlighted Properties section
  3. Enter JSON paths to highlight (one per line)
    • Example: result.userId
    • Example: data[0].email
  4. Save workflow
  5. Execute workflow
  6. Highlighted properties appear with visual emphasis

Use cases:

  • Focus on key business data
  • Identify important IDs or references
  • Debug specific field values
  • Create visual documentation

📸 Screenshot:

Description: Show the Highlighted Properties configuration field with a few paths entered, and then show execution results with those properties visually highlighted (bold, colored background, or similar)

Error Handling Modes

Configure per-step behavior when errors occur:

Stop on Error (default):

  • Workflow stops immediately if step fails
  • No subsequent steps execute
  • Useful for dependent operations
  • Final status: Failed

Continue on Error:

  • Workflow continues to next step even if this step fails
  • Useful for optional operations
  • Allows partial completion
  • Final status: Partially Completed

To configure:

  1. Edit a workflow step
  2. Find Error Handling dropdown
  3. Select “Stop on Error” or “Continue on Error”
  4. Save workflow

Example scenario:

  Step 1: Get user data         [Stop on Error]
Step 2: Update profile        [Stop on Error]
Step 3: Send notification     [Continue on Error]  ← Optional
Step 4: Log activity          [Continue on Error]  ← Optional

Import/Export Workflows

Share workflows with team members or back them up as JSON files.

To export:

  1. Select a workflow from the list
  2. Click 📤 Export button
  3. JSON file downloads (e.g., my-workflow.json)
  4. Share the file via email, Git, or other methods

To import:

  1. Click 📥 Import button
  2. Select a workflow JSON file
  3. Workflow is added to your list
  4. Edit as needed to match your connections/tools

Export includes:

  • Workflow name and description
  • All steps and parameter mappings
  • Error handling configuration
  • Highlighted properties
  • Notes and documentation

Export excludes:

  • Execution history (not portable)
  • Actual tool responses (too large)

📸 Screenshot:

Description: Show the Import/Export buttons in the header, and a wider modal displaying JSON export content in a readable format

Connection Flexibility

Change connections at execution time without editing the workflow.

Default connection:

  • Set when creating workflow
  • Automatically selected for execution
  • Can be changed per run

Runtime connection:

  1. Select workflow
  2. View details panel
  3. Choose Connection dropdown
  4. Select different connection
  5. Click Execute
  6. Workflow runs with chosen connection

Use cases:

  • Test against dev/staging/prod servers
  • Compare behavior across environments
  • Use different authentication contexts
  • Switch between local and remote servers

Required Parameters Panel

The workflow editor displays a Required Parameters panel as a visual reminder.

Features:

  • Split-view layout
  • Automatically extracted from tool schemas
  • Shows all required fields with asterisks (*)
  • Updates as you select different tools
  • Helps prevent missing parameter errors

📸 Screenshot:

Description: Show the split-view editor with the Required Parameters panel on the right side listing required fields for the selected tool

Common Workflows

Example 1: User Data Pipeline

Goal: Fetch user data, update profile, send notification

  Step 1: get_user
  ├─ Parameters:
  │   └─ userId: [Manual Value] "12345"
  └─ Error: Stop on Error

Step 2: update_profile
  ├─ Parameters:
  │   ├─ userId: [From Step 1] result.id
  │   └─ email: [Manual Value] "new@example.com"
  └─ Error: Stop on Error

Step 3: send_notification
  ├─ Parameters:
  │   ├─ userId: [From Step 1] result.id
  │   └─ message: [Manual Value] "Profile updated"
  └─ Error: Continue on Error

Result: User fetched, profile updated, notification attempted (non-critical)

Example 2: Multi-Environment Testing

Goal: Test tool behavior across dev and prod

  Workflow: "Cross-Environment Validation"
Default Connection: "Dev Server"

Step 1: validate_config
  └─ Error: Stop on Error

Step 2: run_health_check
  └─ Error: Stop on Error

Execution:

  1. Run with “Dev Server” → Baseline results
  2. Change to “Prod Server” → Compare results
  3. Review execution history to identify differences

Example 3: Data Transformation Chain

Goal: Fetch, transform, and store data

  Step 1: fetch_raw_data
  ├─ Parameters:
  │   └─ source: [Prompt at Runtime]
  └─ Error: Stop on Error

Step 2: transform_data
  ├─ Parameters:
  │   └─ input: [From Step 1] result.rawData
  └─ Error: Stop on Error

Step 3: validate_schema
  ├─ Parameters:
  │   └─ data: [From Step 2] result.transformed
  └─ Error: Stop on Error

Step 4: store_data
  ├─ Parameters:
  │   └─ data: [From Step 2] result.transformed
  └─ Error: Stop on Error

Highlighted Properties:

  result.recordCount
result.validationErrors
result.storageLocation

Example 4: Batch Processing with Array Iteration

Goal: Process multiple devices returned from a query

Workflow Configuration:

  Step 1: list_noncompliant_devices
  ├─ Parameters:
  │   └─ complianceState: [Manual Value] "Noncompliant"
  └─ Error: Stop on Error
  
  Returns:
  {
    "data": [
      { "id": "abc-123", "deviceName": "Device1", "issue": "outdated_os" },
      { "id": "def-456", "deviceName": "Device2", "issue": "missing_patch" },
      { "id": "ghi-789", "deviceName": "Device3", "issue": "config_drift" }
    ]
  }

Step 2: remediate_device
  ├─ Parameters:
  │   └─ deviceId: [From Step 1] data[0].id
  │       Array Iteration: Each    ← KEY: Enables batch processing
  └─ Error: Continue on Error       ← KEY: Don't stop if one device fails

Execution Behavior:

With Array Iteration: Each, Step 2 executes 3 separate times:

ExecutiondeviceId ValueResult
Execution 1"abc-123"✓ Success
Execution 2"def-456"✗ Failed (continues due to error mode)
Execution 3"ghi-789"✓ Success

Final Workflow Status: Partially Completed (2 of 3 succeeded)

Comparison of Iteration Modes:

ModeStep ExecutionsDevices ProcessedWhen To Use
Each3 timesAll 3 devicesProduction remediation - process entire list
First1 timeDevice 1 onlyTesting - validate remediation on first device
Last1 timeDevice 3 onlyLatest entry - process most recently added
None1 timeDevice 1 onlyLiteral path - when you specifically want [0]

Advanced: Multi-Parameter Array Iteration

You can use array iteration for multiple parameters from the same step:

  Step 2: update_device
  ├─ Parameters:
  │   ├─ deviceId: [From Step 1] data[0].id
  │   │   Array Iteration: Each
  │   ├─ deviceName: [From Step 1] data[0].deviceName
  │   │   Array Iteration: Each
  │   └─ issue: [From Step 1] data[0].issue
  │       Array Iteration: Each
  └─ Error: Continue on Error

Result: All three parameters iterate together - each execution gets matching values:

  • Execution 1: id=abc-123, name=Device1, issue=outdated_os
  • Execution 2: id=def-456, name=Device2, issue=missing_patch
  • Execution 3: id=ghi-789, name=Device3, issue=config_drift

warning: Consistency Required: When using multiple parameters with “Each” iteration from the same source step, ensure all paths reference the same array structure. Mixing different arrays will cause unpredictable behavior.

Example 5: Referencing Specific Steps for Array Iteration

Goal: Filter devices, then process only the filtered results

Workflow Configuration:

  Step 0: get_all_devices
  ├─ Parameters:
  │   └─ tenantId: [Manual Value] "tenant-xyz"
  └─ Error: Stop on Error
  
  Returns:
  {
    "devices": [
      { "id": "dev-1", "name": "Device 1", "compliant": true },
      { "id": "dev-2", "name": "Device 2", "compliant": false },
      { "id": "dev-3", "name": "Device 3", "compliant": true },
      { "id": "dev-4", "name": "Device 4", "compliant": false },
      { "id": "dev-5", "name": "Device 5", "compliant": false }
    ]
  }
  // 5 total devices

Step 1: filter_noncompliant_devices
  ├─ Parameters:
  │   └─ devices: [From Step 0] devices
  └─ Error: Stop on Error
  
  Returns:
  {
    "filtered": [
      { "id": "dev-2", "name": "Device 2", "compliant": false },
      { "id": "dev-4", "name": "Device 4", "compliant": false },
      { "id": "dev-5", "name": "Device 5", "compliant": false }
    ]
  }
  // 3 noncompliant devices

Step 2: get_device_details
  ├─ Parameters:
  │   └─ deviceId: [From Step 1] filtered[0].id   ← References Step 1, not Step 0
  │       Array Iteration: Each                     ← Processes 3 devices, not 5
  └─ Error: Continue on Error

Key Insight: Step 2 references Step 1 specifically, not “Previous Step”. This ensures we only process the filtered 3 devices, not all 5 from Step 0.

Execution Flow:

  1. Step 0 fetches 5 total devices
  2. Step 1 filters down to 3 noncompliant devices
  3. Step 2 runs 3 times (once per filtered device)

Why reference specific steps?

  • Precision: Process exactly the data you need
  • Flexibility: Skip intermediate transformation steps
  • Clarity: Makes data flow explicit in complex workflows

Example 6: Testing Error Recovery

Goal: Validate graceful degradation

  Step 1: critical_operation
  └─ Error: Stop on Error

Step 2: optional_cache_update
  └─ Error: Continue on Error

Step 3: optional_logging
  └─ Error: Continue on Error

Step 4: final_cleanup
  └─ Error: Stop on Error

Expected behavior:

  • If Step 1 fails → Entire workflow stops
  • If Step 2 fails → Workflow continues to Step 3
  • If Step 3 fails → Workflow continues to Step 4
  • If Step 4 fails → Workflow marked as Failed

Managing Workflows

Workflow List Panel

The left panel shows all your workflows:

List features:

  • Ordered by most recently modified
  • Shows workflow name
  • Displays step count
  • Shows description (if provided)
  • Displays last modified timestamp
  • Click to select and view details

📸 Screenshot:

Description: Show the left panel with 4-5 workflows listed, showing names, step counts, descriptions, and timestamps. One workflow should be selected/highlighted

Editing Workflows

To edit an existing workflow:

  1. Select workflow from list
  2. Click ✏️ Edit button (in detail panel)
  3. Modify name, description, or steps
  4. Adjust parameter mappings
  5. Change error handling modes
  6. Click 💾 Save

While editing:

  • Add/remove/reorder steps
  • Use ↑/↓ arrows to move steps
  • Delete steps with 🗑 button
  • All changes are draft until saved
  • Click ✖ Cancel to discard changes

📸 Screenshot:

Description: Show the workflow editor in edit mode with multiple steps, up/down arrows visible, delete buttons, and Save/Cancel buttons at the top

Deleting Workflows

To delete a workflow:

  1. Select workflow from list
  2. Click 🗑 Delete button
  3. Confirm deletion in prompt
  4. Workflow and its execution history are permanently removed

warning: No Undo: Deletion is permanent. Export workflows before deleting if you might need them later.

Reordering Steps

Change the execution order of steps:

Move step up:

  1. Click ↑ arrow on step card
  2. Step moves up one position
  3. Step numbers automatically renumber

Move step down:

  1. Click ↓ arrow on step card
  2. Step moves down one position
  3. Step numbers automatically renumber

Important: Parameter mappings referencing “previous step” adjust automatically when reordering.

Troubleshooting

Workflow Won’t Execute

Problem: Execute button is disabled or execution fails immediately

Solutions:

  1. Ensure a connection is selected (check dropdown)
  2. Verify connection is available (may need to create first)
  3. Check that workflow has at least 2 steps
  4. Ensure all required parameters are mapped
  5. Review console for detailed error messages

Parameter Mapping Errors

Problem: Step fails with “missing parameter” error

Solutions:

  1. Check parameter mapping source type is correct
  2. Verify JSON path is valid (use Property Selector)
  3. Ensure referenced step completed successfully
  4. Test JSON path against actual response structure
  5. Use Manual Value temporarily to debug
  6. Check for typos in property names (case-sensitive)

JSON Property Selector Empty

Problem: Property Selector modal shows no properties

Solutions:

  1. Ensure previous steps have executed at least once
  2. Check that referenced step returned a response
  3. Verify tool actually returns structured data
  4. Try executing workflow once to populate schemas
  5. Manually enter JSON path if you know the structure

Execution History Missing

Problem: No history entries appear for workflow

Solutions:

  1. Execute workflow at least once
  2. Check that execution completed (not still running)
  3. Verify browser storage is enabled
  4. Review console for storage errors
  5. History limited to last 10 executions (older ones removed)

Connection Auto-Connect Fails

Problem: Workflow can’t connect automatically during execution

Solutions:

  1. Verify connection configuration is correct
  2. Test connection manually in Connections tab first
  3. Check authentication credentials are valid
  4. Ensure server is reachable and running
  5. Review connection logs for specific errors
  6. Try connecting manually before executing workflow

Array Iteration Not Working

Problem: Step executes only once even with “Each” mode selected

Solutions:

  1. Verify the JSON path actually points to an array
  2. Check that previous step returned array data (not null/empty)
  3. Ensure array path uses [0] syntax (e.g., data[0].id)
  4. Test property path in Property Selector first
  5. Review step execution results to see actual data structure
  6. Confirm iteration mode is saved (check after reopening workflow)
  7. Verify the referenced step completed successfully

How to debug:

  1. Execute workflow once
2. View the source step's results in execution history
3. Verify it returns an array: {"data": [...]}
4. Copy the JSON path exactly as shown in results
5. Use 🔍 Browse button to validate path

Wrong Array Elements Processed

Problem: “Each” mode processes wrong elements or in wrong order

Solutions:

  1. Ensure JSON path is correct (case-sensitive property names)
  2. Check array indexing: data[0] vs data vs [0]
  3. Verify you’re referencing the correct step (not previous by accident)
  4. Review source step results to confirm array structure
  5. Use Property Selector to discover correct path
  6. Check for nested arrays - iteration applies to first array found

Common path mistakes:

  • ❌ data.id (missing array index)
  • ❌ Data[0].id (wrong case - should be data)
  • ❌ data[0] (missing property after index)
  • ✅ data[0].id (correct format)

Multiple Parameters With Array Iteration

Problem: Parameters don’t iterate together correctly

Solutions:

  1. Ensure all “Each” parameters reference same source step
  2. Verify all paths point to same array (e.g., all use data[0])
  3. Check that array has sufficient elements for all properties
  4. Don’t mix “Each” with “First/Last/None” on same array
  5. Test with single parameter first, then add more

Example of correct multi-parameter iteration:

  ✅ CORRECT:
  - param1: [From Step 1] data[0].id       (Each)
  - param2: [From Step 1] data[0].name     (Each)
  - param3: [From Step 1] data[0].status   (Each)

❌ WRONG:
  - param1: [From Step 1] data[0].id       (Each)
  - param2: [From Step 2] devices[0].name  (Each) ← Different step!
  - param3: [From Step 1] data[0].status   (First) ← Different mode!

Steps Execute Out of Order

Problem: Steps seem to run in wrong sequence

Solutions:

  1. Check step numbers (should be sequential: 0, 1, 2…)
  2. Use ↑/↓ arrows to reorder if needed
  3. Verify you’re viewing the correct workflow
  4. Save workflow after reordering
  5. Clear execution history and run again

Tips & Best Practices

🔄 Test Array Iteration First

Start with “First” mode to test your step logic, then change to “Each” for full batch processing.

⚠️ Use Continue on Error for Batch

When using “Each” iteration, set error mode to “Continue” to avoid one failure stopping entire batch.

📊 Reference Specific Steps

Use explicit step references (Step 1, Step 2) instead of “Previous” for clearer data flow in complex workflows.

🔍 Validate Array Paths

Always use the 🔍 Browse button first to discover correct array paths - avoids typos and case issues.

📈 Monitor Batch Progress

Watch the execution progress bar - it shows completion percentage across all array iterations.

🎯 One Array Per Step

Keep workflows simple - process one array type per step rather than nested arrays in single step.

💾 Export Regularly

Begin with 2-3 steps before building complex workflows. Test each step individually first.

📝 Use Descriptions

Document what each workflow does and why. Future you will thank present you.

🔍 Test Parameter Paths

Execute workflow once, then use Property Selector to discover actual response structure.

⭐ Mark Critical Steps

Use “Stop on Error” for dependencies, “Continue on Error” for optional operations.

💾 Export Regularly

Back up important workflows as JSON files to prevent accidental loss.

🔗 One Workflow Per Scenario

Create separate workflows for different use cases rather than one complex workflow.

📊 Highlight Key Properties

Use property highlighting to focus on important data in execution results.

🔄 Compare Executions

Keep execution history to track changes in tool behavior over time.

🧪 Test Error Modes

Intentionally trigger failures to verify error handling behaves as expected.

📚 Document with Notes

Use the Notes field on steps to explain complex parameter mappings or logic.

Work with Tools First

Before creating workflows, familiarize yourself with tools:

Configure Connections

Workflows require active connections:

Understand Concepts

Learn about MCP architecture:

Use in Chat

Reference workflows when chatting with AI:

Next Steps

Now that you understand workflows:

  1. Create your first workflow - Start with a simple 2-step chain
  2. Map parameters - Learn the three mapping source types
  3. Execute and review results - See your workflow in action
  4. Export and share - Back up your workflows as JSON

Workflows unlock the full power of MCP tool chaining! 🚀