claw-conductor – OpenClaw Skill

---

name: claw-conductor description: Always-on autonomous development orchestrator with intelligent triage. Auto-detects Discord channels, routes to project workspaces, triages simple vs development requests, decomposes complex tasks, routes to optimal AI models, executes in parallel, and consolidates results. version: 2.1.0

Claw Conductor v2.1

Your always-on development assistant - handles everything from quick questions to full project builds.

Claw Conductor is an intelligent orchestration layer that:

• 🎯 Always-On: Handles every message automatically (no need to invoke)
• 🤖 Smart Triage: Detects simple questions vs development tasks
• 💬 Discord-Aware: Auto-maps channels to project workspaces
• 🔀 Multi-Model: Routes tasks to optimal AI based on capabilities
• ⚡ Parallel Execution: Builds complete projects efficiently

🚀 How It Works

Automatic Flow:

1. Message arrives in Discord channel (e.g., #scientific-calculator)
2. Claw-conductor detects channel → maps to /root/projects/scientific-calculator
3. Triages request: Simple question or development task?
4. If Simple: Quick response from fast model with project context
5. If Development: Full orchestration - decompose, route, execute, consolidate

You never need to explicitly invoke it - it handles everything automatically!

🎯 Usage Examples

Simple Questions (fast response):

User: What files are in this project?
Conductor: 📋 Simple response mode
          [Lists files from /root/projects/scientific-calculator]

User: How does the calculator work?
Conductor: 📋 Simple response mode
          [Explains architecture with project context]

Development Tasks (full orchestration):

User: Build a scientific calculator with trig functions
Conductor: 🔧 Development mode - full orchestration
          [Decomposes into tasks, routes to models, executes in parallel]

User: Fix the bug in the calculation logic
Conductor: 🔧 Development mode - full orchestration
          [Analyzes code, creates fix, tests, commits]

User Overrides:

User: !simple Build a calculator
Conductor: 📋 Simple response mode
          [Gives advice/explanation instead of building]

User: !dev What files exist?
Conductor: 🔧 Development mode - full orchestration
          [Treats as development task - maybe creates file listing tool]

🚀 Skill Invocation (For OpenClaw Agent)

NEW: Always-On Mode (Recommended)

Configure this skill as the default handler for Discord channels in "Active Projects" category:

# In OpenClaw agent configuration
from orchestrator import Orchestrator

orchestrator = Orchestrator()

# Handle ALL messages through conductor
result = orchestrator.handle_message(
    request=user_message,
    channel_id=discord_channel_id,
    channel_name=discord_channel_name
)

Legacy: Explicit Invocation

When this skill is invoked with a development request, execute the following:

1. Extract the request from the user's message (everything after "use claw-conductor to")

2. Determine project name from the request or generate one from keywords

3. Execute the orchestrator using Python:

   cd ~/.openclaw/skills/claw-conductor/scripts
   python3 -c "
   from orchestrator import Orchestrator
   import sys
   
   orchestrator = Orchestrator()
   
   request = '''[USER'S REQUEST HERE]'''
   project_name = '[PROJECT-NAME]'  # e.g., 'calculator-app', 'todo-app', 'blog-site'
   
   # Get GitHub user from config
   github_user = orchestrator.config.get('github_user')
   
   result = orchestrator.execute_request(
       request=request,
       project_name=project_name,
       github_user=github_user
   )
   
   # Report results back to Discord
   if result['success']:
       print(f\"✅ Project '{project_name}' completed successfully!\")
       print(f\"📦 {result['tasks_completed']} tasks completed\")
       if github_user:
           print(f\"🔗 GitHub: https://github.com/{github_user}/{project_name}\")
       print(f\"📁 Workspace: {result.get('workspace', '/root/projects/' + project_name)}\")
   else:
       print(f\"❌ Project failed: {result.get('error', 'Unknown error')}\")
       sys.exit(1)
   "
   

4. Report progress to Discord during execution:

   • Announce task decomposition results
   • Report task routing decisions
   • Update on parallel execution progress
   • Share final results with GitHub link

Example Invocation: User says: @OpenClaw use claw-conductor to build a calculator app

You execute:

• Request: "build a calculator app"
• Project name: "calculator-app"
• Run orchestrator with these parameters

---

What's New in v2.1

🤖 AI-Powered Decomposition: Intelligently analyzes complex requests using your best AI model (auto-selected or configured) 🎯 Full Orchestration: Decomposes complex requests → Routes subtasks → Executes in parallel → Consolidates results ⚡ Parallel Execution: Up to 5 tasks running concurrently across multiple projects 📁 Project Management: Automatic workspace creation, git initialization, and GitHub integration 🔗 Dependency-Aware: Respects task dependencies and file conflicts 📦 Auto-Consolidation: Merges results, runs tests, commits to git, pushes to GitHub

---

Quick Start

Installation

In OpenClaw:

cd ~/.openclaw/skills
git clone https://github.com/johnsonfarmsus/claw-conductor.git
cd claw-conductor
./scripts/setup.sh

First-Time Setup

./scripts/setup.sh

This creates your personalized agent-registry.json with:

• Your AI model configurations
• Cost tracking (free vs paid)
• Capability ratings per model
• Routing preferences

Usage

Simple request:

@OpenClaw use claw-conductor to build a calculator app

Complex request:

@OpenClaw use claw-conductor to build a towing dispatch system with:
- Customer portal for requesting service
- Driver dashboard for accepting jobs
- Admin panel for managing users
- Real-time location tracking
- Payment integration

---

How It Works

Complete Workflow

Discord Request
    ↓
1. Task Decomposition
   • Analyzes request complexity
   • Breaks into independent subtasks
   • Assigns category & complexity to each
   • Builds dependency graph
    ↓
2. Intelligent Routing
   • Scores each model for each task (0-100)
   • Routes to best match based on capabilities
   • Considers cost optimization
    ↓
3. Project Initialization
   • Creates /root/projects/{name}/
   • Initializes git repository
   • Creates GitHub repo (if configured)
   • Sets up workspace
    ↓
4. Parallel Execution
   • Spawns up to 5 tasks simultaneously
   • Respects dependencies (database before auth)
   • Avoids file conflicts (same files sequential)
   • Reports progress to Discord
    ↓
5. Result Consolidation
   • Merges all task outputs
   • Resolves file conflicts
   • Runs tests (if present)
   • Commits to git
   • Pushes to GitHub
    ↓
Discord Completion Report

Example: Dispatch System

Request:

Build a towing dispatch system with customer portal,
driver dashboard, admin panel, and real-time tracking

Decomposition:

Task 1: Database schema (database-operations, complexity: 4)
Task 2: Authentication system (security-fixes, complexity: 4)
Task 3: Customer portal UI (frontend-development, complexity: 3)
Task 4: Driver dashboard UI (frontend-development, complexity: 3)
Task 5: Admin panel UI (frontend-development, complexity: 3)
Task 6: REST API endpoints (api-development, complexity: 3)
Task 7: Real-time tracking (performance-optimization, complexity: 5)
Task 8: Unit tests (unit-test-generation, complexity: 2)

Routing:

Task 1 → Mistral Devstral (score: 92, best for database)
Task 2 → Mistral Devstral (score: 88, security expert)
Task 3 → Mistral Devstral (score: 95, frontend expert)
Task 4 → Mistral Devstral (score: 95, frontend expert)
Task 5 → Mistral Devstral (score: 95, frontend expert)
Task 6 → Llama 3.3 70B (score: 87, API specialist)
Task 7 → Mistral Devstral (score: 78, fallback - needs Claude ideally)
Task 8 → Llama 3.3 70B (score: 95, test generation expert)

Execution:

Parallel execution plan:
Worker 1: Task 1 (Database) → Mistral
Worker 2: Task 3 (Customer UI) → Devstral
Worker 3: Task 4 (Driver UI) → Devstral
Worker 4: Task 5 (Admin UI) → Devstral
Worker 5: Task 6 (API) → Llama

After Task 1 completes:
Worker 1: Task 2 (Auth - depends on DB) → Mistral

After all code complete:
Worker 1: Task 8 (Tests) → Llama

Result:

✅ All 8 tasks completed in 47 minutes
📦 Committed to git with 8 changes
🔗 Pushed to GitHub repository
🎉 Project ready for deployment

---

Scoring Algorithm

Each model is scored 0-100 for each task:

score = (
    (rating / 5.0) * 50 +              # Model capability (0-50 pts)
    (1 - complexity/5.0) * 40 +        # Complexity fit (0-40 pts)
    (experience / 100) * 10 +          # Experience (0-10 pts)
    cost_factor * 10                   # Cost (0-10 pts)
)

Hard Ceiling: Models cannot handle tasks above their max_complexity rating.

Scoring Example

Task: Backend API development (complexity: 4)

Model	Capability	Complexity Fit	Experience	Cost	Total
Mistral Devstral	4★ (40pts)	Can handle 4 (40pts)	0 (0pts)	Free (10pts)	90/100
Llama 3.3 70B	4★ (40pts)	Can handle 4 (40pts)	2 tasks (2pts)	Free (10pts)	92/100 ✅
Perplexity	N/A	Cannot handle backend	-	-	0/100

Winner: Llama 3.3 70B (higher experience)

---

Configuration

Agent Registry Structure

config/agent-registry.json:

{
  "version": "1.0.0",
  "user_config": {
    "cost_tracking_enabled": true,
    "prefer_free_when_equal": true,
    "max_parallel_tasks": 5,
    "default_complexity_if_unknown": 3,
    "fallback": {
      "enabled": true,
      "retry_delay_seconds": 2,
      "track_failures": true,
      "penalize_failures": true,
      "failure_penalty_points": 5
    }
  },
  "agents": {
    "mistral-devstral-2512": {
      "model_id": "mistral/devstral-2512",
      "provider": "mistral",
      "context_window": 256000,
      "enabled": true,
      "user_cost": {
        "type": "free-tier",
        "input_cost_per_million": 0,
        "output_cost_per_million": 0
      },
      "capabilities": {
        "frontend-development": {
          "rating": 5,
          "max_complexity": 5,
          "notes": "Expert - near-parity with Claude"
        },
        "multi-file-refactoring": {
          "rating": 5,
          "max_complexity": 5,
          "notes": "Expert - designed for 50+ file changes"
        }
      }
    }
  }
}

Fallback Strategy

Conservative fallback (user-configurable):

1. Try primary model (attempt 1)
2. Try primary model (attempt 2)
3. If both fail → Try first runner-up (attempt 3)
4. Try first runner-up (attempt 4)
5. If all fail → Give up, report to Discord

Why conservative? Prevents cascading through irrelevant models that may not have capability for the task.

---

Task Categories (23 Standard)

• code-generation-new-features
• bug-detection-fixes
• multi-file-refactoring
• unit-test-generation
• debugging-complex-issues
• api-development
• security-vulnerability-detection
• security-fixes
• documentation-generation
• code-review
• frontend-development
• backend-development
• database-operations
• codebase-exploration
• dependency-management
• legacy-modernization
• error-correction
• performance-optimization
• test-coverage-analysis
• algorithm-implementation
• boilerplate-generation

---

Advanced Features

Multi-Project Support

Handle concurrent requests across different projects:

Project A: Dispatch System (3 tasks running)
Project B: Calculator App (2 tasks running)
────────────────────────────────────────────
Total: 5 concurrent tasks (at global limit)

File Conflict Detection

Tasks touching the same files run sequentially:

Task 1: Modify src/api/users.js → Running
Task 2: Modify src/api/users.js → Queued (waits for Task 1)
Task 3: Modify src/ui/dashboard.js → Running (independent)

Dependency-Aware Scheduling

Task 1: Database schema → No deps, starts immediately
Task 2: Auth system → Depends on Task 1, waits
Task 3: Frontend UI → Depends on Task 2, waits
Task 4: Tests → Depends on all, runs last

Auto-Consolidation

After all tasks complete:

1. Check git status for conflicts
2. Run tests (pytest, npm test, etc.)
3. Commit with conventional commit message
4. Push to GitHub (if configured)
5. Report to Discord

---

Examples

Simple Calculator

@OpenClaw use claw-conductor to build a calculator with:
- Basic operations (add, subtract, multiply, divide)
- Clean UI
- Unit tests

Result:

• 3 tasks (UI, logic, tests)
• Completed in ~8 minutes
• Pushed to GitHub

Towing Dispatch System

@OpenClaw use claw-conductor to build a dispatch system with:
- Customer portal
- Driver dashboard
- Admin panel
- Real-time tracking
- Payment integration

Result:

• 8 tasks across 3 models
• Completed in ~45 minutes
• Full working application

API with Documentation

@OpenClaw use claw-conductor to create a REST API for a blog with:
- CRUD operations for posts
- Authentication
- Swagger documentation
- Integration tests

Result:

• 5 tasks (schema, auth, endpoints, docs, tests)
• Completed in ~20 minutes
• API-first design

---

Troubleshooting

Task Decomposition Issues

Problem: Request not decomposed correctly Solution: Be specific in request. Include keywords: "database", "API", "frontend", "tests"

Model Selection Issues

Problem: Wrong model chosen for task Solution: Adjust capability ratings in agent-registry.json

Execution Failures

Problem: Task fails with error Solution: Fallback tries primary 2x, runner-up 2x. Check error logs in .claw-conductor/execution-log.json

Git Conflicts

Problem: Consolidation fails due to conflicts Solution: Currently requires manual resolution. Future: AI-powered conflict resolution

---

Roadmap

• Task decomposition (v2.0)
• Parallel execution (v2.0)
• Multi-project support (v2.0)
• Auto-consolidation (v2.0)
• AI-powered decomposition (v2.1)
• Discord progress updates (v2.1)
• Conflict resolution with AI (v2.2)
• Real-time task streaming (v2.2)
• Web dashboard (v3.0)

---

License

GNU AGPL v3 - See LICENSE file

Copyleft license requiring server-side source availability.

---

Contributing

See CONTRIBUTING.md for guidelines.

Published on ClawHub.ai: https://clawhub.ai/skills/claw-conductor

---

Built with ❤️ by the Claw Conductor team

Claw Conductor v2.1

Build Complete Projects with a Single Request

Transform complex development requests into working software through intelligent multi-model orchestration. Claw Conductor decomposes your request, routes subtasks to optimal AI models, executes in parallel, and delivers a complete project.

🚀 What is This?

Claw Conductor is a full autonomous development orchestrator that transforms a single Discord message into a complete, working software project.

The Problem

Building software requires multiple AI models for different tasks:

• Database design → Best with Mistral Devstral (256K context)
• Unit tests → Best with Llama 3.3 70B (test generation expert)
• Frontend UI → Best with Mistral Devstral (near-Claude quality)
• API endpoints → Best with Llama or Mistral
• Research → Best with Perplexity (internet access)

Manually coordinating these models is tedious and error-prone.

The Solution

Single Discord request:

@OpenClaw use claw-conductor to build a towing dispatch system with:
- Customer portal for requesting service
- Driver dashboard for accepting jobs
- Admin panel for managing users
- Real-time location tracking

Claw Conductor automatically:

1. ✨ Decomposes into 8 subtasks with dependencies
2. 🎯 Routes each to the optimal model (Mistral/Llama/Perplexity)
3. ⚡ Executes up to 5 tasks in parallel
4. 📦 Consolidates results, runs tests, commits to git
5. 🐙 Pushes complete project to GitHub

Result: Working dispatch system in ~45 minutes, zero manual intervention.

---

✨ What's New in v2.1

🤖 Always-On Triage: Automatically classifies requests as simple questions vs development tasks 💬 Discord Integration: Auto-maps Discord channels to project workspaces in /root/projects ⚡ Dual-Mode Response: Fast answers for questions, full orchestration for development 🎯 Smart Routing: Simple mode uses fast models, development mode uses full pipeline 🔧 User Overrides: Force classification with !simple or !dev flags 📋 Path Announcements: Visual indicators (📋 Simple / 🔧 Development) show routing decisions 🌍 Project-Aware: All responses know their workspace, channel, and context 🎨 Multi-Project: Handle multiple concurrent requests across different Discord channels

---

📋 Complete Workflow

Discord Message in #calculator-app channel
    ↓
1. Context Detection & Triage
   ├─ Discord Integration: Maps #calculator-app → /root/projects/calculator-app
   ├─ Request Classification: "Build a calculator app" → DEVELOPMENT
   ├─ Path Announcement: 🔧 Development mode - full orchestration
   └─ Route to: Full decomposition pipeline
    ↓
2. AI-Powered Task Decomposition (Development Mode)
   ├─ Uses best-rated model (auto-selected or configured)
   ├─ Task 1: Calculator logic (backend-development, complexity: 2)
   ├─ Task 2: UI components (frontend-development, complexity: 2)
   └─ Task 3: Unit tests (unit-test-generation, complexity: 2)
    ↓
3. Intelligent Routing
   ├─ Task 1 → Llama 3.3 70B (score: 87/100)
   ├─ Task 2 → Mistral Devstral (score: 95/100)
   └─ Task 3 → Llama 3.3 70B (score: 95/100)
    ↓
4. Project Initialization
   ├─ Workspace: /root/projects/calculator-app/ (from Discord mapping)
   ├─ Initializes git repository
   ├─ Creates GitHub repo: {user}/calculator-app
   └─ Registers OpenClaw agent
    ↓
5. Parallel Execution (max 5 concurrent)
   ├─ Worker 1: Task 1 (Llama) → Running
   ├─ Worker 2: Task 2 (Devstral) → Running
   └─ Worker 3: Task 3 (Llama) → Running
    ↓
6. Result Consolidation
   ├─ Merges all code changes
   ├─ Runs npm test (passes)
   ├─ Commits: "feat: calculator-app - 3 tasks completed"
   └─ Pushes to github.com/{user}/calculator-app
    ↓
✅ Complete project delivered in ~8 minutes

---

🎯 Key Features

Always-On Triage & Discord Integration

The Problem: Not every Discord message needs full orchestration. Questions like "What's the status?" shouldn't trigger decomposition.

The Solution: Claw Conductor acts as an always-on layer that intelligently routes requests:

Triage Classification

• Simple Mode (📋): Questions, status checks, explanations → Fast model response
• Development Mode (🔧): Build, fix, implement requests → Full orchestration pipeline

Discord Channel Mapping

Discord #scientific-calculator → /root/projects/scientific-calculator
Discord #dispatch-suite → /root/projects/dispatch-suite
Discord #satire-news → /root/projects/satire-news

Each Discord channel in "Active Projects" category automatically maps to its project workspace.

User Overrides

@OpenClaw !simple Build a calculator  → Forces simple mode (just answers)
@OpenClaw !dev What is this project?  → Forces development mode (probably errors)

Example Flows

Simple Request:

User: "What files are in this project?"
  → 📋 Simple response mode
  → Fast answer from Mistral Devstral (project-aware)
  → Response in ~2 seconds

Development Request:

User: "Add user authentication with email verification"
  → 🔧 Development mode - full orchestration
  → Decompose into 5 tasks
  → Execute in parallel
  → Complete project in ~15 minutes

AI-Powered Task Decomposition

• Intelligent Analysis: Uses AI models to analyze complex requests and break them into structured tasks
• Auto-Selection: Automatically picks the best model from your registry (or manual override)
• Fallback Strategy: Falls back to second-best model on failure
• Structured Output: Generates tasks with categories, complexity ratings, dependencies, and file targets

Intelligent Multi-Model Routing

• Capability-Based Scoring: 1-5 star ratings per model per task category
• Complexity Analysis: Hard ceilings prevent overwhelming models
• Cost Optimization: Prefers free models when capabilities equal
• Experience Tracking: Learns which models perform best over time

Parallel Task Execution

• Worker Pool: Up to 5 tasks running simultaneously
• Dependency-Aware: Database tasks complete before auth tasks
• File Conflict Detection: Tasks touching same files run sequentially
• Multi-Project Support: Handle multiple concurrent project requests

Complete Project Delivery

• Auto-Setup: Creates workspace, git repo, GitHub repo
• Test Execution: Runs pytest, npm test, etc.
• Conventional Commits: Clean git history with co-authorship
• GitHub Integration: Automatic push on completion

---

🛠️ Installation

Quick Start

# On your OpenClaw server
cd ~/.openclaw/skills
git clone https://github.com/johnsonfarmsus/claw-conductor.git
cd claw-conductor
chmod +x scripts/*.sh scripts/*.py
./scripts/setup.sh

The wizard will:

1. Detect your configured OpenClaw models
2. Ask about cost structure (free vs paid)
3. Create personalized agent-registry.json
4. Set routing preferences

Manual Setup

# Copy example configuration
cp config/agent-registry.example.json config/agent-registry.json

# Add your models
python3 scripts/update-capability.py \
  --agent mistral-devstral-2512 \
  --category frontend-development \
  --rating 5 \
  --max-complexity 5

---

📚 Usage

Simple Request

@OpenClaw use claw-conductor to build a calculator with:
- Basic operations (add, subtract, multiply, divide)
- Clean UI
- Unit tests

Result:

• 3 tasks decomposed
• 2 models used (Mistral + Llama)
• Completed in ~8 minutes
• GitHub repo created and pushed

Complex Request

@OpenClaw use claw-conductor to build a towing dispatch system with:
- Customer portal for requesting service
- Driver dashboard for accepting jobs
- Admin panel for managing users
- Real-time location tracking
- Payment integration

Result:

• 8 tasks decomposed (database, auth, UIs, API, tracking, tests, docs)
• 3 models used (Mistral, Llama, Perplexity)
• Completed in ~45 minutes
• Full working application on GitHub

Testing the Router

# Test decomposition and routing (dry run)
cd scripts
python3 orchestrator.py

# Test with custom request
python3 decomposer.py "Build a blog system with comments"

# Test routing for specific task
python3 router.py --test

---

🎓 How It Works

1. Task Decomposition

Analyzes your request and breaks into categorized subtasks:

Request: "Build user registration with email verification"

Subtasks:
├─ Database schema (database-operations, complexity: 3)
├─ Registration API (api-development, complexity: 3)
├─ Email verification (backend-development, complexity: 4)
├─ Registration UI (frontend-development, complexity: 2)
└─ Unit tests (unit-test-generation, complexity: 3)

Dependencies: API depends on database, UI depends on API, tests depend on all

2. Intelligent Routing

Each task scored 0-100 against all models:

Example: API Development (complexity: 3)

Mistral Devstral 2512:
  Rating: 4★ (40 pts)
  Complexity fit: Can handle 3 (40 pts)
  Experience: 0 tasks (0 pts)
  Cost: Free tier (10 pts)
  Total: 90/100

Llama 3.3 70B:
  Rating: 4★ (40 pts)
  Complexity fit: Can handle 4 (40 pts)
  Experience: 2 tasks (2 pts)
  Cost: Free (10 pts)
  Total: 92/100 ✅ Winner

3. Parallel Execution

Worker Pool (max 5 concurrent):

Worker 1: Database schema (Mistral) → Running
Worker 2: Registration UI (Devstral) → Running
Worker 3: Tests (Llama) → Queued (waits for API)
Worker 4: -
Worker 5: -

After database completes:
Worker 1: Registration API (Llama) → Running

After API completes:
Worker 1: Tests (Llama) → Running

4. Result Consolidation

# After all tasks complete:
1. Check git status for conflicts → None
2. Run tests: npm test → ✅ Passed
3. Commit: "feat: user-registration - 5 tasks completed"
4. Push to github.com/{user}/user-registration
5. Report to Discord: "✅ Project completed!"

---

🔧 Configuration

Agent Registry

config/agent-registry.json:

{
  "user_config": {
    "cost_tracking_enabled": true,
    "prefer_free_when_equal": true,
    "max_parallel_tasks": 5,
    "fallback": {
      "enabled": true,
      "retry_delay_seconds": 2
    }
  },
  "agents": {
    "mistral-devstral-2512": {
      "model_id": "mistral/devstral-2512",
      "enabled": true,
      "user_cost": {
        "type": "free-tier"
      },
      "capabilities": {
        "frontend-development": {
          "rating": 5,
          "max_complexity": 5
        }
      }
    }
  }
}

Task Categories (23 Standard)

• code-generation-new-features
• bug-detection-fixes
• multi-file-refactoring
• unit-test-generation
• api-development
• frontend-development
• backend-development
• database-operations
• security-fixes
• documentation-generation
• performance-optimization
• algorithm-implementation
• And more...

See config/task-categories.json

---

📊 Supported Models

Default Profiles

Model	Provider	Cost	Best For
Mistral Devstral 2512	Mistral	Free tier	Multi-file refactoring, frontend, 256K context
Llama 3.3 70B	OpenRouter	Free	Unit tests, algorithms, boilerplate
Perplexity Sonar	Perplexity	$1/M tokens	Research, documentation, exploration
Claude Sonnet 4.5	Anthropic	$3-15/M	Complex architecture (future)
GPT-4 Turbo	OpenAI	$10-30/M	General purpose (future)

See config/defaults/ for all profiles.

---

🎯 Examples

Example 1: Calculator

Request: Build a calculator with operations and tests

Decomposition:

• Task 1: Calculator logic (Llama)
• Task 2: UI components (Devstral)
• Task 3: Unit tests (Llama)

Result: 3 tasks, 8 minutes, pushed to GitHub

Example 2: Blog API

Request: REST API for blog with auth and docs

Decomposition:

• Task 1: Database schema (Mistral)
• Task 2: Auth system (Mistral)
• Task 3: CRUD endpoints (Llama)
• Task 4: Swagger docs (Perplexity)
• Task 5: Integration tests (Llama)

Result: 5 tasks, 20 minutes, API-first design

Example 3: Dispatch System

Request: Full towing dispatch with portals and tracking

Decomposition:

• Task 1: Database (Mistral)
• Task 2: Auth (Mistral)
• Task 3-5: UIs for customer/driver/admin (Devstral)
• Task 6: REST API (Llama)
• Task 7: Real-time tracking (Mistral)
• Task 8: Tests (Llama)

Result: 8 tasks, 45 minutes, full application

---

🔍 Advanced Features

Conservative Fallback

If a task fails:

1. Try primary model (attempt 1)
2. Try primary model (attempt 2)
3. Try first runner-up (attempt 3)
4. Try first runner-up (attempt 4)
5. Give up, report to Discord

File Conflict Detection

Task 1: Modify src/api/users.js → Running
Task 2: Modify src/api/users.js → Queued (waits)
Task 3: Modify src/ui/home.js → Running (independent)

Multi-Project Concurrency

Project A: Dispatch System (3 tasks running)
Project B: Calculator (2 tasks running)
───────────────────────────────────────────
Total: 5 tasks (at global max_parallel_tasks)

---

📖 Documentation

• SKILL.md - Complete usage guide for OpenClaw
• docs/orchestration-design.md - Architecture details
• examples/ - Working examples with walkthroughs
• config/ - Configuration reference

---

🤝 Contributing

We welcome contributions!

1. Share benchmark data - Help improve capability ratings
2. Add model profiles - Support more AI models
3. Improve decomposition - Better task breakdown logic
4. Report issues - Help us fix bugs

See CONTRIBUTING.md for guidelines.

---

📄 License

GNU AGPL v3 - See LICENSE

This copyleft license requires anyone running a modified version on a server to make source code available to users.

---

🙏 Acknowledgments

• Capability ratings from SWE-bench, HumanEval, and real-world testing
• Built for the OpenClaw ecosystem
• Published on ClawHub.ai

---

🔗 Links

• GitHub: johnsonfarmsus/claw-conductor
• ClawHub: clawhub.ai/skills/claw-conductor
• OpenClaw Docs: openclaw.ai

---

Made with 🎼 for autonomous development

Stop manually coordinating AI models. Let the Conductor orchestrate.