Skip to main content

​
What is a Workflow?

A workflow in Splox is a visual, node-based automation that connects AI models, tools, and integrations to accomplish complex tasks. Think of it as a programmable flowchart where each box (node) performs a specific action, and arrows (edges) define the execution path and data flow. Workflows are the foundation of Splox, enabling you to:

AI Model Orchestration

Chain multiple LLMs together with sequential or parallel execution patterns

Tool Integration

Connect AI agents to external tools, APIs, databases, and third-party platforms

Agentic Behavior

Build intelligent agents that make decisions, use tools iteratively, and accomplish complex goals

Multi-Agent Systems

Create collaborative AI systems where multiple agents communicate asynchronously in parallel

Data Processing

Transform and process data through multi-step pipelines with branching logic

Reusable Components

Design modular subflows that can be nested and reused across multiple workflows

​
Key Capabilities

  • Visual Programming - Build complex logic without code using an intuitive canvas interface
  • Chat Mode - Test interactively with conversational interface and real-time feedback
  • Flexible Patterns - Support for sequential, parallel, conditional, and looping execution
  • Real-time Testing - See nodes execute live with immediate feedback
  • Version Control - Track changes, publish versions, and roll back when needed

​
Workflow Structure

​
Components

Every workflow consists of two main components:

Nodes

Individual units of work - AI models, tools, transformations, or control flow logic

Edges

Connections between nodes that define execution order and data flow

​
Visual Canvas

Workflows are built on a visual canvas with powerful editing capabilities:

Add Nodes

Right-click anywhere on the canvas to open a context menu with available nodes

Connect Nodes

Draw edges between nodes by dragging from output to input ports

Configure

Click any node to open its settings panel and configure parameters

Navigate

Pan by dragging the canvas, zoom with mouse wheel or trackpad

Organize

Group related nodes into subflows for better organization

Undo/Redo

Full history support - easily revert changes or restore edits
Workflow Canvas - Visual Node Editor
Workflow Canvas - Visual Node Editor

​
Workflow Lifecycle

1

Creation

When you create a new workflow, Splox automatically:
  • Generates a unique workflow ID
  • Sets up an empty canvas
  • Assigns it to your account
  • Creates initial configuration
2

Building

Build your workflow by:
  • Adding nodes from the context menu
  • Connecting nodes with edges
  • Configuring each node’s settings
  • Testing individual nodes
  • Saving your changes
Test as you build - Use the “Run Node” feature to verify each component works before connecting everything together.
3

Testing & Execution

​
Chat Mode

Purpose: Interactive, conversational interface for testing and debugging workflows.Features:
  • In-editor panel (680px sliding panel)
  • Chat-based conversational interaction
  • Real-time execution with node highlighting
  • Multiple chat sessions management
  • Persistent chat history
  • Start node selection
Chat Actions:
  • Create new chat
  • Switch between existing chats
  • Clear chat memory (flush history)
  • Delete chat
  • Share chat publicly
  • Leave chat session
Best for:
  • Development and testing
  • Debugging workflow logic
  • Iterating on conversation flows
  • Collaborative testing
Chat Mode Interface
Chat Mode Interface

​
Execution Flow

1

Select Start Node

Choose where to begin execution from the available start nodes
2

Provide Inputs

Enter required parameters, messages, or upload files
3

Run Workflow

Execute using either Chat Mode or I/O Mode
4

Monitor Execution

Watch real-time status updates as nodes process
5

View Results

See outputs from end nodes and review execution logs

​
Testing Checklist

  • Verify each node produces expected output format
  • Check data types match downstream requirements
  • Validate transformations are correct
  • Confirm data passes correctly between nodes
  • Test edge connections work as expected
  • Verify parallel branches merge properly
  • Test failure scenarios for critical nodes
  • Verify error edges activate correctly
  • Check fallback logic works as intended
  • Test with empty inputs
  • Try unexpected data formats
  • Verify timeout handling
  • Test rate limit scenarios
Test your workflows thoroughly before setting up triggers. Failed workflows can still consume credits and API calls.
4

Deployment

Once tested, deploy your workflow by:
  • Setting up triggers (webhooks, schedules, forms)
  • Configuring execution settings
  • Enabling the workflow
  • Monitoring the first few runs
5

Monitoring

After deployment, monitor your workflow:
  • View execution history
  • Check success/failure rates
  • Review error logs
  • Analyze performance metrics
  • Optimize as needed

​
Execution Model

​
Sequential Flow

By default, workflows execute sequentially:
Each node completes before the next one begins.

​
Parallel Execution

Use the Merge node to execute multiple branches in parallel:
Both LLM nodes run simultaneously, and the merge node waits for both to complete.

​
Conditional Branching

Use the Switch node for conditional logic:
The workflow takes different paths based on conditions you define.

​
Agent Workflows with Subflows

AI agents use subflows to create intelligent, iterative behavior where the LLM can use tools multiple times until it decides to stop:
How the Agent Loop Works:
1

LLM Analyzes Task

The LLM evaluates the current context and decides what action to take next
2

Tool Selection

Based on the analysis, the LLM can:
  • Use a regular tool (Search, Check Status, Create Ticket) → Results return to LLM
  • Use the Stop tool → Exits the subflow immediately
3

Iteration or Exit

  • Regular tools → Flow hits End Node → Loops back to LLM with tool results
  • Stop tool → Flow hits Stop Node → Exits subflow entirely, no more iterations
4

Final Output

When the Stop tool is called, the subflow terminates and returns final output to the main workflow
Key Components:
Purpose: Complete one iteration and allow the loop to continue
  • Regular tools connect to the End Node
  • End Node signals “iteration complete, ready for next”
  • If under Number of Iterations limit, workflow loops back to LLM
  • LLM receives tool results and decides next action
Use when: Tool provides data the LLM needs to continue reasoning
Example: Customer Support Agent
Scenario: User asks “What’s the status of my order #12345?”Execution Steps:
  1. Iteration 1:
    • LLM receives question
    • Decides to use “Check Order Status” tool
    • Tool executes → Returns “Order shipped, tracking: XYZ123”
    • Hits End Node → Loops back to LLM
  2. Iteration 2:
    • LLM receives order status result
    • Has enough information to answer
    • Calls “Stop Subflow” tool with response: “Your order has shipped! Tracking number: XYZ123”
    • Hits Stop Node → Exits subflow
  3. Final Output:
    • Subflow returns LLM’s final response
    • Main workflow continues with the result
Available Tools:
  • search_knowledge_base → For finding help articles
  • check_order_status → For order lookups
  • create_support_ticket → For escalations
  • stop_subflow → Required! To exit when done
Why Stop Node is Critical: Without the Stop tool, the agent would hit the Number of Iterations limit every time, even when the task is complete early. The Stop Node enables efficient early exits.
Best Practice: Always provide a “stop” or “complete task” tool in agent subflows. This allows the LLM to exit efficiently when the job is done, rather than waiting for iteration limit.
If you don’t provide a Stop tool/node, the subflow will always run until Number of Iterations limit is reached, wasting resources and time.

​
Multi-Agent Workflows

Multi-agent systems enable multiple AI agents to collaborate by communicating asynchronously and in parallel:
How it works:
  1. Multiple agents execute in parallel, each in their own subflow
  2. Agents communicate asynchronously using the Workflow Execution tool
  3. Each agent can trigger other agents by specifying workflow and start node
  4. Agents work concurrently without blocking each other
  5. Communication flows freely in any direction between agents
Collaboration Patterns:
  • Actor Model: Agents communicate peer-to-peer, passing messages directly
  • Orchestrator Model: One agent coordinates tasks and aggregates results
  • Hybrid Patterns: Mix of orchestration and peer-to-peer communication
  • Custom Topologies: Design any collaboration pattern that fits your use case
Key Features:
  • Parallel Execution: Multiple agents work simultaneously
  • Asynchronous Communication: Agents use Workflow Execution tool to trigger other agents
  • Start Node Selection: Each agent specifies entry points in target workflows
  • Flexible Architecture: Support for any collaboration pattern (actor, orchestrator, hybrid)
  • Specialization: Different agents can have different capabilities and responsibilities
Example Use Cases:
  • Research Pipeline: Agents collaborate to search, analyze, and summarize information
  • Content Creation: Multiple agents handle research, outlining, writing, and editing
  • Data Processing: Agents work together on ingestion, validation, transformation, and storage
  • Collaborative Problem Solving: Agents debate, critique, and refine solutions together
Multi-agent workflows excel at complex tasks that benefit from specialized expertise, parallel processing, and collaborative reasoning.

​
Error Handling

Every node can have an error edge that activates when the node fails:
Error edges are indicated by red connections in the workflow editor.

​
Best Practices

Start Simple

Begin with a linear workflow, add complexity as needed

Test Early

Use “Run Node” to test individual components before connecting them

Use Descriptive Labels

Name nodes clearly: “Parse Customer Email” not “Node 1”

Handle Errors

Add error edges to critical nodes for graceful failure handling

Monitor Regularly

Check execution logs and metrics to catch issues early

Document Complex Logic

Use node descriptions to explain non-obvious logic

​
Next Steps

Create Your First Workflow

Step-by-step guide to building a workflow

Understanding Nodes

Learn about different node types and their capabilities

Managing Edges

How to connect nodes and control data flow

Workflow Templates

Start with pre-built workflow templates