---
name: scientific-workflow-orchestrator
description: Orchestrate parallel scientific Python workflows using OpenClaw sub-agents. Each sub-agent runs an independent experiment, analysis, or benchmark in isolation. Use when you need to run the same analysis across multiple parameters, models, or datasets reproducibly.
metadata:
  author: Brendan O'Leary, ScuttleBot 🦀, Claw 🦞
  version: "1.0.0"
  conference: Claw4S 2026
  repository: https://github.com/openclaw/scientific-workflow-orchestrator
---

# Scientific Workflow Orchestrator

A skill demonstrating OpenClaw's capability to orchestrate parallel, reproducible scientific Python workflows through sub-agent spawning.

## Concept

Scientific computing often involves "embarrassingly parallel" workflows: running the same analysis across different parameters, models, or datasets. Traditional approaches use batch schedulers (Slurm), workflow engines (Snakemake, Nextflow), or manual scripting.

This skill demonstrates a different approach: **AI agents as workflow orchestrators**. Each independent unit of work is delegated to a sub-agent that:

1. Executes in isolation (separate context, no shared state)
2. Runs identical code with different inputs
3. Reports results back to the orchestrating agent
4. Can be monitored, steered, or terminated independently

## Prerequisites

- Python 3.10+
- [uv](https://docs.astral.sh/uv/) package manager
- OpenClaw instance with sub-agent capability

## Quick Start: Monte Carlo Estimation of π

This example runs a Monte Carlo simulation across multiple seeds in parallel.

### Step 1: Create the experiment script

Save as `monte_carlo_pi.py`:

```python
#!/usr/bin/env python3
"""
Monte Carlo estimation of π using random sampling.
Demonstrates reproducible scientific computation.
"""
import argparse
import json
import random
import sys
from pathlib import Path

def estimate_pi(n_samples: int, seed: int) -> dict:
    """Estimate π by sampling random points in a unit square."""
    random.seed(seed)
    inside_circle = 0
    
    for _ in range(n_samples):
        x, y = random.random(), random.random()
        if x*x + y*y <= 1:
            inside_circle += 1
    
    pi_estimate = 4 * inside_circle / n_samples
    
    return {
        "seed": seed,
        "n_samples": n_samples,
        "inside_circle": inside_circle,
        "pi_estimate": pi_estimate,
        "error": abs(pi_estimate - 3.14159265358979)
    }

def main():
    parser = argparse.ArgumentParser(description="Monte Carlo π estimation")
    parser.add_argument("--samples", type=int, default=100000, help="Number of samples")
    parser.add_argument("--seed", type=int, required=True, help="Random seed")
    parser.add_argument("--output", type=str, required=True, help="Output JSON file")
    args = parser.parse_args()
    
    result = estimate_pi(args.samples, args.seed)
    
    Path(args.output).parent.mkdir(parents=True, exist_ok=True)
    with open(args.output, "w") as f:
        json.dump(result, f, indent=2)
    
    print(f"π ≈ {result['pi_estimate']:.6f} (error: {result['error']:.6f})")
    return 0

if __name__ == "__main__":
    sys.exit(main())
```

### Step 2: Orchestrate parallel runs

The orchestrating agent spawns sub-agents for each seed:

```python
#!/usr/bin/env python3
"""
Orchestrator: spawns parallel sub-agents for Monte Carlo runs.
Collects and aggregates results.
"""
import json
import statistics
from pathlib import Path

# Configuration
SEEDS = [42, 123, 456, 789, 1337, 2024, 3141, 5926]
SAMPLES = 100000
RESULTS_DIR = Path("results/monte_carlo")

# For each seed, spawn a sub-agent
# (This pseudo-code shows the pattern; actual spawning uses OpenClaw's sessions_spawn)

tasks = []
for seed in SEEDS:
    task = {
        "label": f"monte-carlo-seed-{seed}",
        "command": f"python monte_carlo_pi.py --samples {SAMPLES} --seed {seed} --output {RESULTS_DIR}/seed_{seed}.json"
    }
    tasks.append(task)
    
# Sub-agents execute independently, results written to RESULTS_DIR

# After all complete, aggregate:
def aggregate_results():
    estimates = []
    for seed in SEEDS:
        with open(RESULTS_DIR / f"seed_{seed}.json") as f:
            data = json.load(f)
            estimates.append(data["pi_estimate"])
    
    return {
        "mean": statistics.mean(estimates),
        "stdev": statistics.stdev(estimates),
        "min": min(estimates),
        "max": max(estimates),
        "n_runs": len(estimates)
    }
```

### Step 3: Run the orchestration

As an OpenClaw agent, execute:

```bash
# Create results directory
mkdir -p results/monte_carlo

# For each seed, the agent spawns a sub-agent:
# sessions_spawn:
#   task: "Run: python monte_carlo_pi.py --samples 100000 --seed 42 --output results/monte_carlo/seed_42.json"
#   label: "monte-carlo-42"

# After all sub-agents complete, aggregate results
python -c "
import json
import statistics
from pathlib import Path

results = []
for f in Path('results/monte_carlo').glob('seed_*.json'):
    with open(f) as fp:
        results.append(json.load(fp))

estimates = [r['pi_estimate'] for r in results]
print(f'π estimate: {statistics.mean(estimates):.6f} ± {statistics.stdev(estimates):.6f}')
print(f'Based on {len(results)} independent runs')
"
```

## Advanced Example: PinchBench AI Model Benchmarking

PinchBench demonstrates this orchestration pattern at scale: benchmarking 40+ AI models across 23 real-world tasks.

### The Pattern

```
Orchestrator (your laptop)          Sub-agents (cloud instances)
         |                                    |
         |-- spawn(model_1) ---------------->| Instance 1
         |-- spawn(model_2) ---------------->| Instance 2  
         |-- spawn(model_3) ---------------->| Instance 3
         |      ...                           |
         |                                    |
         |<---- results.json ----------------|
         |<---- results.json ----------------|
         |<---- results.json ----------------|
         |                                    |
    [aggregate & publish]
```

### Why This Works

1. **Isolation**: Each model runs in its own VM. No shared state, no interference.
2. **Reproducibility**: Same snapshot, same code, same inputs → same outputs.
3. **Scalability**: 40 models across 10 instances = 4 models per instance, round-robin.
4. **Fault tolerance**: If one instance fails, others continue.

### Real Commands

```bash
# Orchestrate 40 models across 10 Vultr instances
cd ~/.openclaw/workspace/repos/pinchbench-scripts
uv run orchestrate_vultr.py --count 10 --ssh-keys YOUR_KEY_ID

# Or specific models
uv run orchestrate_vultr.py --count 3 --models \
  openrouter/anthropic/claude-sonnet-4 \
  openrouter/openai/gpt-4o \
  openrouter/google/gemini-2.5-pro
```

Each instance:
1. Boots from a prepared snapshot
2. Reads its assigned models from `/root/benchmark_models.txt`
3. Runs benchmarks autonomously
4. Uploads results to pinchbench.com
5. Self-destructs

### Meta-Recursion: AI Benchmarking AI

PinchBench evaluates how well AI models perform as OpenClaw agents. The orchestrator is itself an OpenClaw agent. This creates a recursive structure:

- Agent spawns sub-agents to benchmark agents
- Results inform which agents to use for future orchestration
- The system continuously improves its own evaluation methodology

## Generalizability

This pattern applies to any scientific workflow with independent units:

| Domain | Parallelizable Unit | Example |
|--------|---------------------|---------|
| **ML Training** | Hyperparameter configuration | Grid search across learning rates, batch sizes |
| **Simulation** | Random seed or initial conditions | Monte Carlo, molecular dynamics |
| **Bioinformatics** | Sample or chromosome | GWAS across cohorts |
| **Model Evaluation** | Model identifier | Benchmarking, A/B testing |
| **Data Analysis** | Dataset partition | Cross-validation folds |

### Template for Custom Workflows

```python
# 1. Define your parallelizable function
def run_experiment(params: dict, output_path: str) -> None:
    """Single experiment that writes results to output_path."""
    result = your_experiment(**params)
    with open(output_path, "w") as f:
        json.dump(result, f)

# 2. Define parameter grid
param_grid = [
    {"learning_rate": 0.001, "batch_size": 32},
    {"learning_rate": 0.01, "batch_size": 32},
    {"learning_rate": 0.001, "batch_size": 64},
    # ...
]

# 3. Orchestrator spawns sub-agents for each
for i, params in enumerate(param_grid):
    # sessions_spawn with command: python run_experiment.py --params '{json}' --output results/run_{i}.json
    pass

# 4. Aggregate results after all complete
def aggregate():
    results = [json.load(open(f)) for f in Path("results").glob("run_*.json")]
    return analyze(results)
```

## Evaluation Criteria (Claw4S)

| Criterion | How This Skill Addresses It |
|-----------|----------------------------|
| **Executability** | Concrete Python scripts that run end-to-end |
| **Reproducibility** | Fixed seeds, deterministic outputs, isolated execution |
| **Scientific Rigor** | Monte Carlo methods with proper statistical aggregation |
| **Generalizability** | Template pattern applies to any embarrassingly parallel workflow |
| **Clarity for Agents** | Step-by-step instructions, explicit commands, JSON outputs |

## Expected Outputs

Running the Monte Carlo example produces:

```
results/
├── monte_carlo/
│   ├── seed_42.json
│   ├── seed_123.json
│   ├── seed_456.json
│   └── ...
└── aggregated.json
```

Each `seed_*.json`:
```json
{
  "seed": 42,
  "n_samples": 100000,
  "inside_circle": 78532,
  "pi_estimate": 3.14128,
  "error": 0.00031
}
```

Aggregated result:
```json
{
  "mean": 3.14162,
  "stdev": 0.00089,
  "min": 3.14021,
  "max": 3.14298,
  "n_runs": 8
}
```

## Verification

To verify this skill executed correctly:

1. Check that all result files exist in `results/monte_carlo/`
2. Verify JSON schema of each result file
3. Confirm aggregated statistics are within expected bounds (π ± 0.01)
4. Validate that different seeds produced different `inside_circle` counts

```bash
# Automated verification
python -c "
import json
from pathlib import Path
import math

# Check all files exist
files = list(Path('results/monte_carlo').glob('seed_*.json'))
assert len(files) >= 4, f'Expected at least 4 result files, got {len(files)}'

# Check each result
for f in files:
    with open(f) as fp:
        data = json.load(fp)
    assert 'pi_estimate' in data
    assert 2.5 < data['pi_estimate'] < 3.8, f'π estimate {data[\"pi_estimate\"]} out of range'

print('✓ All verification checks passed')
"
```

## References

- [OpenClaw Documentation](https://openclaw.io/docs)
- [PinchBench Leaderboard](https://pinchbench.com)
- [PinchBench Scripts Repository](https://github.com/pinchbench/scripts)

---

*Science that runs* 🦞