ArcanFlows - The Visual Builder for Production-Grade AI Flows

Workflows are visual automation pipelines that connect triggers, actions, and AI agents to automate complex business processes.

What is a Workflow?

A workflow in ArcanFlows is a visual representation of an automated process. It consists of:

Triggers: Events that start the workflow
Nodes: Individual steps that process data
Connections: Links that define the flow of data
Branches: Conditional paths based on logic

The Visual Builder

The workflow builder provides a drag-and-drop canvas where you design your automations:

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Trigger   │────▶│   Action    │────▶│   Action    │
│  (Webhook)  │     │ (AI Agent)  │     │(Send Email) │
└─────────────┘     └─────────────┘     └─────────────┘
                           │
                           ▼
                    ┌─────────────┐
                    │  Condition  │
                    └─────────────┘
                      ╱         ╲
                     ▼           ▼
              ┌──────────┐ ┌──────────┐
              │  Yes     │ │   No     │
              │ (Slack)  │ │ (Email)  │
              └──────────┘ └──────────┘

Node Types

Triggers

Events that start your workflow:

Trigger	Description	Use Case
Manual	Start on demand	Testing, one-off tasks
Webhook	HTTP request	External integrations
Schedule	Cron expression	Daily reports, cleanup
Form	Form submission	Lead capture, surveys
Event	System event	User actions, data changes
Chat	Agent conversation	Chatbot triggers

Actions

Tasks your workflow performs:

Action	Description
HTTP Request	Call external APIs
Send Email	Send via SMTP or providers
Send Notification	Slack, Teams, Discord, SMS
Database Query	Read/write data
Execute Code	Run JavaScript/Python
AI Agent	Invoke an agent for processing
Sub-Workflow	Call another workflow

Logic & Control

Control the flow of execution:

Node	Description
Condition	If/else branching
Switch	Multi-way branching
Loop	Iterate over arrays
Delay	Wait for time period
Transform	Modify data structure
Variables	Set/get variables
Approval	Human-in-the-loop
Parallel	Execute branches simultaneously

Building a Workflow

Step 1: Add a Trigger

Every workflow starts with a trigger. Drag a trigger node onto the canvas:

javascript
// Webhook trigger example payload
{
  "trigger": "webhook",
  "method": "POST",
  "headers": { "Content-Type": "application/json" },
  "body": {
    "customer_id": "cust_123",
    "event": "subscription_created",
    "data": {
      "plan": "pro",
      "amount": 49.00
    }
  }
}

Step 2: Add Processing Nodes

Add nodes to process the incoming data:

Transform: Extract and reshape data
Condition: Make decisions based on values
AI Agent: Use AI for complex processing

Step 3: Add Actions

Add output nodes to complete the workflow:

javascript
// Send notification action configuration
{
  "action": "send_notification",
  "channel": "slack",
  "config": {
    "channel_id": "#sales-notifications",
    "message": "New {{input.data.plan}} subscription! Amount: ${{input.data.amount}}"
  }
}

Step 4: Connect Nodes

Draw connections between nodes to define the data flow. Each connection passes the output of one node to the input of the next.

Step 5: Test and Debug

Use the built-in debugger to:

Set breakpoints on any node
Inspect data at each step
Step through execution
Modify inputs on the fly

Variables and Expressions

Reference data throughout your workflow using expressions:

Input Data

javascript
{{ input.customer_id }}
{{ input.data.plan }}

Previous Node Output

javascript
{{ nodes.http_request_1.response.data }}
{{ nodes.ai_agent.response.content }}

Built-in Functions

javascript
{{ now() }}                    // Current timestamp
{{ formatDate(input.date) }}   // Format date
{{ input.name | uppercase }}   // Transform text
{{ input.items | length }}     // Array length
{{ env.API_KEY }}              // Environment variable

Error Handling

Handle failures gracefully:

Try-Catch Pattern

Wrap risky operations in error handling:

┌──────────────┐
│   Try Block  │
└──────────────┘
       │
    Success?
    ╱      ╲
   ▼        ▼
[Continue] [Catch Block]
              │
              ▼
       [Error Handler]

Retry Configuration

Configure automatic retries:

Setting	Description
Max Retries	Number of retry attempts
Delay	Time between retries
Backoff	Exponential backoff multiplier

Execution Monitoring

Track workflow execution in real-time:

Execution Log

View detailed logs for each run:

Start time and duration
Status of each node
Input/output data
Error messages

Metrics

Monitor workflow health:

Success/failure rate
Average execution time
Node-level performance
Error frequency

Best Practices

Design

Keep workflows focused on one goal
Use sub-workflows for reusable logic
Add descriptive names to nodes
Document complex flows

Performance

Minimize HTTP calls
Use parallel execution where possible
Cache frequently accessed data
Set appropriate timeouts

Reliability

Add error handling to all workflows
Configure appropriate retries
Set up monitoring alerts
Test with edge cases

Next Steps

Builder Interface - Master the visual builder
Triggers - Learn about trigger types
Actions - Explore action nodes
Debugging - Debug like a pro