Boris Workflow for OpenClaw

Run multiple independent tasks in parallel across AI agents with automatic load balancing, retries, progress tracking, optional verification, and organized a...

Security Scan

The skill is an instruction-only workflow/orchestrator that requires fetching and running external code (pip/git) but the packaged submission lacks the runtime artefacts and contains inconsistent repository references — review the remote code and repository links before installing.

Purpose & Capability

The declared purpose (parallel agent runner for OpenClaw) matches the documentation and CLI usage, but the skill package contains only documentation (no bin/boris-run, no lib/ files). The SKILL.json lists entry_points and a GitHub repo, while INSTALL.md points to a different GitHub URL. This mismatch means the package itself does not contain the claimed runtime components; installing will require cloning and running code from an external repository.

Instruction Scope

Runtime instructions tell the user to git clone a repo, pip install requirements, write config files under ~/.boris, and run local servers (web UI on localhost:8080). Those actions are appropriate for a workflow tool, but they entail executing third-party code and creating/modifying user files. The instructions do not ask for unrelated secrets or system paths beyond user home, and they do not explicitly instruct reading unrelated sensitive files.

Install Mechanism

There is no packaged install spec; INSTALL.md directs users to git clone and pip install from a GitHub repo. Using GitHub is normal, but the documentation references inconsistent repository URLs (https://github.com/mukston/boris-workflow.git versus SKILL.json's mukston-debug repo). Because the shipped bundle lacks the code, installing requires fetching and executing remote code — treat this as an external dependency and verify the upstream repository before running pip/install commands.

Credentials

The skill declares no required credentials and only optional BORIS_* environment variables for configuration. No secrets or cloud credentials are requested. Writing configuration under ~/.boris and artifact directories is proportional to the stated purpose.

Persistence & Privilege

Flags are ordinary (always: false, user-invocable, agent-invocation allowed). The skill will create per-user config/artifact directories and suggests adding environment variables to shell profiles, which is normal for a CLI tool. It does not request system-wide privileges or modify other skills' configurations in the provided documentation.

What to consider before installing

This submission is documentation-only: it documents a CLI and web UI but does not include the runtime code; following the docs will make you clone and run code from a GitHub repository. Before installing: 1) Verify the upstream repository URL and owner (the docs reference inconsistent repo names). 2) Inspect the remote code (bin/boris-run, lib/) in the repo to ensure it matches the documentation and contains no unexpected network exfiltration or privileged operations. 3) Run pip installs in an isolated environment (virtualenv, container) and avoid running unknown scripts as root. 4) Consider starting the web UI on a non-default port or binding only to localhost, and check the web server code for any endpoints that accept uploads or post results externally. If you cannot validate the remote repo, treat the submission as untrusted and avoid executing its install/run steps.

Parallel agent task runner implementing the Boris Cherny multi-agent pattern

Overview

Boris Workflow is a powerful parallel execution engine for OpenClaw that enables you to run multiple independent tasks across multiple AI agents simultaneously. Inspired by Boris Cherny's approach to multi-agent orchestration, it provides automatic progress tracking, configurable error retry, and organized artifact management.

What It Does

The Boris Workflow implements a 3-phase parallel execution pattern:

1. Phase 1: Distribution — Tasks are queued and distributed to available agents
2. Phase 2: Execution — Agents pull work from the queue (work-stealing pattern)
3. Phase 3: Verification — Optional verification agent reviews all results

┌─────────────────────────────────────────────────────────────┐
│                      ORCHESTRATOR                           │
│                    (boris-run CLI)                          │
└─────────────────────────────────────────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│  AGENT 1     │    │  AGENT 2     │    │  AGENT N     │
│ (Task A)     │    │ (Task B)     │    │ (Task C)     │
└──────┬───────┘    └──────┬───────┘    └──────┬───────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           ▼
              ┌────────────────────┐
              │  RESULT COLLECTOR  │
              └────────────────────┘

Key Features

🚀 Parallel Execution

• Spawn 1-20 agents working simultaneously
• Work-stealing pattern ensures no idle agents
• Automatic load balancing across varying task durations

🔄 Intelligent Retry

• Configurable retry strategies: none, linear, exponential
• Per-task timeout handling
• Automatic failure recovery

📊 Progress Tracking

• Real-time progress updates
• Compact progress bar or verbose logging modes
• Per-task status monitoring

✅ Verification Layer

• Optional verification agent reviews all results
• Quality assessment and error detection
• Verification reports in structured JSON

🎨 Web UI (Optional)

• Modern dark-themed interface
• Real-time status via Server-Sent Events
• Drag-and-drop task management
• Configuration export as YAML

📁 Organized Artifacts

• Automatic directory structure per workflow
• Timestamped artifact naming
• Cleanup policies (keep_all, keep_last_N, age_based)

Quick Start

# Install dependencies
cd ~/.openclaw/workspace/skills/boris-workflow
pip install -r requirements.txt

# Run 3 tasks with 3 agents
./bin/boris-run --tasks "research|analyze|write"

# Run 10 tasks with 5 agents
./bin/boris-run --tasks "t1|t2|t3|t4|t5|t6|t7|t8|t9|t10" --agents 5

# With verification step
./bin/boris-run --tasks "code|test|review" --verify

# Dry run to preview
./bin/boris-run --tasks "build|deploy" --dry-run

Web Interface

Boris Workflow includes a modern web UI for visual workflow management:

# Start the Web UI
cd ~/.openclaw/workspace/skills/boris-workflow/webui
./start.sh

Open http://localhost:8080 in your browser.

Web UI Features

• Dynamic Task Management — Add, remove, and reorder workflow tasks with an intuitive interface
• Agent Configuration — Adjust agent count (1-20) and select AI models from a dropdown
• Real-time Status — Live progress updates via Server-Sent Events (SSE)
• Results Viewer — View and download workflow results in JSON format
• Configuration Management — Save settings and export as YAML
• Modern Dark UI — Clean interface built with Tailwind CSS
• Mobile Responsive — Works seamlessly on all screen sizes

Web UI Screenshots

┌─────────────────────────────────────────────────────────────┐
│  🚀 Boris Workflow                              [Settings]  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Workflow Name: batch-analysis                              │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ Tasks                    │  Agents: [ 3 ▼]          │   │
│  │ ──────────────────────── │  Model: [kimi-coding ▼]  │   │
│  │ □ Research market trends │  Timeout: [300s ▼]       │   │
│  │ □ Analyze competitors    │  Retries: [2 ▼]          │   │
│  │ □ Write summary report   │                          │   │
│  │ □ + Add Task             │  [✓] Enable Verification │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  [Start Workflow]          [Dry Run]          [Export YAML] │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ Progress                                            │   │
│  │ ████████░░░░░░░░░░ 8/10 tasks complete (80%)       │   │
│  │                                                     │   │
│  │ task_0_research     ✅ Complete    2m 14s          │   │
│  │ task_1_analyze      ✅ Complete    1m 52s          │   │
│  │ task_2_write        🔄 Running     0m 45s          │   │
│  │ task_3_verify       ⏳ Pending     --              │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Requirements

System Requirements

• OpenClaw: Installed and configured
• Python: 3.9 or higher
• OS: Linux, macOS, or WSL on Windows
• Memory: 4GB RAM minimum (8GB recommended for multiple agents)
• Disk: 100MB for installation, variable for artifacts

Python Dependencies

pyyaml>=6.0
requests>=2.28.0

Optional Dependencies (for Web UI)

fastapi>=0.100.0
uvicorn[standard]>=0.23.0
pydantic>=2.0.0
python-multipart>=0.0.6

Configuration

Configuration Hierarchy

Config values are resolved in priority order (highest to lowest):

1. CLI arguments
2. Environment variables (BORIS_*)
3. Project config (./.boris/config.yaml)
4. User config (~/.boris/config.yaml)
5. System defaults

Example Config File

# ~/.boris/config.yaml

# Agent defaults
agents:
  default_count: 3
  max_count: 20
  timeout_seconds: 300
  model: "kimi-coding/k2p5"

# Retry configuration
retry:
  max_attempts: 2
  backoff_strategy: "exponential"
  initial_delay_ms: 1000
  max_delay_ms: 30000

# Output and artifacts
output:
  base_dir: "~/.boris/artifacts"
  naming_pattern: "{workflow_name}_{timestamp}_{task_id}"
  cleanup_policy: "keep_last_10"

# Verification settings
verification:
  enabled: false
  verifier_model: "kimi-coding/k2p5"
  auto_retry_failed: true

# Logging
logging:
  level: "info"
  format: "text"

CLI Reference

Usage: boris-run [OPTIONS]

Required:
  -t, --tasks TEXT          Tasks to run, pipe-separated
  
Optional:
  -a, --agents INTEGER      Number of agents (default: 3, max: 20)
  -n, --name TEXT          Workflow name
  -c, --config PATH        Config file path
  -o, --output PATH        Artifacts directory
  -r, --retries INTEGER    Max retries per task
  -T, --timeout INTEGER    Timeout per agent (seconds)
  --verify                 Enable verification step
  --dry-run                Preview without execution
  --mock                   Use mock bridge for testing
  -v, --verbose            Verbose logging
  -q, --quiet              Suppress progress output
  --version                Show version
  -h, --help               Show help

Use Cases

• Batch Content Processing — Generate 10 blog posts simultaneously
• Multi-Source Research — Research 5 topics in parallel
• Code Review at Scale — Review 20 files with 5 agents
• Data Analysis Pipeline — Process multiple datasets concurrently
• Test Suite Execution — Run independent test files in parallel

License

MIT License - OpenClaw Community

Author

Created by Goli / mukston for the OpenClaw ecosystem.