Coordinate multiple agents and tasks for complex workflows. Orchestrate subagents, manage dependencies, handle parallel execution, and ensure successful comp...
---
name: task-orchestra
version: "1.0.0"
description: "Coordinate multiple agents and tasks for complex workflows. Orchestrate subagents, manage dependencies, handle parallel execution, and ensure successful completion of multi-step operations.\n"
metadata:
openclaw:
emoji: "๐๏ธ"
requires:
bins: ["curl", "jq"]
env: ["BRAVE_API_KEY"]
install:
- id: npm
kind: node
package: async
bins: ["async"]
---
# Task Orchestra
Coordinate multiple agents and tasks for complex workflows.
## When to Use
- Multi-step operations requiring coordination
- Parallel execution of independent tasks
- Complex workflows with dependencies
- Orchestrating subagents for large projects
## Core Capabilities
### 1. Task Coordination
- Break down complex tasks into manageable steps
- Manage dependencies between tasks
- Coordinate parallel execution
- Handle task sequencing and scheduling
### 2. Agent Orchestration
- Spawn and manage multiple subagents
- Route tasks to appropriate agents
- Monitor progress and handle failures
- Aggregate results from multiple sources
### 3. Workflow Management
- Define workflow patterns and templates
- Implement error handling and recovery
- Manage state and progress tracking
- Coordinate handoffs between agents
### 4. Dependency Resolution
- Analyze task dependencies
- Create execution order
- Handle conditional execution
- Manage resource conflicts
## Orchestration Patterns
### 1. Sequential Execution
```
Task A โ Task B โ Task C
```
### 2. Parallel Execution
```
Task A, Task B, Task C โ Aggregate
```
### 3. Pipeline Processing
```
Input โ Task A โ Task B โ Task C โ Output
```
### 4. Supervisor Pattern
```
Coordinator โ Multiple Subagents โ Results
```
### 5. Event-Driven Processing
```
Event โ Trigger โ Response โ Next Event
```
## Quick Actions
- `orchestrate [workflow]` - Execute complex workflow
- `parallel [tasks]` - Run tasks in parallel
- `pipeline [steps]` - Chain tasks in sequence
- `supervise [agents]` - Manage multiple agents
- `dependencies [tasks]` - Analyze and resolve dependencies
## Usage Examples
```
"Orchestrate a complete research project with multiple agents"
"Run these tasks in parallel and combine results"
"Create a pipeline for content creation from research to publication"
"Supervise a team of agents working on different aspects"
"Analyze dependencies and create execution order"
```
## Workflow Templates
### Research Project
```
1. Research Topic โ Research Agent
2. Data Collection โ Data Agent
3. Analysis โ Analysis Agent
4. Report Generation โ Writing Agent
5. Review โ QA Agent
```
### Content Creation
```
1. Topic Research โ Research Agent
2. Outline Creation โ Writing Agent
3. Draft Writing โ Writing Agent
4. Editing โ Editing Agent
5. Publication โ Publishing Agent
```
### Software Development
```
1. Requirements โ Analysis Agent
2. Design โ Design Agent
3. Implementation โ Coding Agent
4. Testing โ QA Agent
5. Deployment โ Deployment Agent
```
## Agent Management
### Spawning Agents
```
sessions_spawn({ task: "specific task", label: "agent-name", mode: "run" })
```
### Monitoring Progress
```
subagents list
```
### Handling Failures
```
subagents kill [agent-id]
subagents steer [agent-id] "new instructions"
```
## Dependency Resolution
### Types of Dependencies
- **Data Dependencies**: Task B needs output from Task A
- **Resource Dependencies**: Tasks sharing same resources
- **Order Dependencies**: Tasks must run in specific order
- **Conditional Dependencies**: Task runs only if condition met
### Resolution Process
```
1. Identify all dependencies
2. Create dependency graph
3. Find topological sort
4. Execute in dependency order
5. Handle conflicts and cycles
```
## Error Handling
### Common Failure Scenarios
- **Agent Failure**: Subagent crashes or times out
- **Dependency Failure**: Required task fails
- **Resource Conflict**: Multiple agents need same resource
- **Network Issues**: API calls fail or timeout
### Recovery Strategies
- **Retry**: Attempt failed task again
- **Alternative**: Use different approach or agent
- **Skip**: Continue without failed task
- **Rollback**: Undo previous steps
## State Management
### Progress Tracking
- Track completed tasks
- Monitor current execution
- Record task results
- Maintain workflow state
### Checkpointing
- Save progress at key points
- Enable restart from checkpoints
- Maintain consistency across failures
## Communication Patterns
### Parent โ Child
```
/sessions_send [agent-id] "instructions"
```
### Child โ Parent
```
Auto-announce results
Reply with findings
Report errors and status
```
### Agent โ Agent
```
Share data through files
Coordinate via shared state
Trigger other agents
```
## Performance Optimization
### Parallel Execution
- Identify independent tasks
- Run in parallel when possible
- Aggregate results efficiently
### Resource Management
- Monitor agent resource usage
- Balance load across agents
- Avoid resource conflicts
### Efficiency Metrics
- Task completion time
- Resource utilization
- Error rates
- Success rates
## Safety Considerations
### Agent Limits
- Max 10 concurrent subagents
- Max 2 levels of nesting
- 10-minute timeout per agent
- Automatic cleanup
### Data Integrity
- Validate task inputs/outputs
- Maintain consistency
- Handle partial failures
- Ensure atomic operations
## Advanced Patterns
### 1. Hierarchical Orchestration
```
Main Coordinator โ Team Coordinators โ Individual Agents
```
### 2. Dynamic Work Allocation
```
Assign tasks based on agent capabilities
Reassign if agent fails
Balance load dynamically
```
### 3. Event-Driven Workflows
```
Event โ Trigger โ Agent โ Result โ Next Event
```
### 4. Adaptive Planning
```
Plan โ Execute โ Monitor โ Adjust โ Repeat
```
## Integration with Other Skills
### Self-Evolution
- Use for complex self-improvement tasks
- Coordinate multiple evolution agents
- Manage long-term capability building
### Analysis Skills
- Orchestrate research projects
- Coordinate data analysis
- Manage multi-step investigations
### Content Creation
- Coordinate content production pipelines
- Manage multi-agent content creation
- Orchestrate publication workflows
## Quick Reference
### Common Commands
```bash
# List running agents
subagents list
# Kill failed agent
subagents kill [id]
# Send instructions
sessions_send [agent-id] "message"
# Spawn new agent
sessions_spawn({ task: "task", label: "name", mode: "run" })
```
### Workflow Examples
```bash
# Research project
orchestrate "research-project" with agents: research, analysis, writing
# Content pipeline
pipeline "content-creation" with steps: research, outline, draft, edit, publish
# Software development
supervise "dev-team" with agents: analysis, design, coding, testing, deployment
```
## Best Practices
1. **Start Simple**: Begin with sequential execution
2. **Add Parallelism**: Identify independent tasks
3. **Handle Failures**: Implement robust error handling
4. **Monitor Progress**: Track execution and results
5. **Optimize Performance**: Balance load and resources
## Success Metrics
- Task completion rate
- Execution time efficiency
- Resource utilization
- Error recovery effectiveness
- Overall workflow success
---
**Remember**: Good orchestration makes complex tasks manageable and reliable.don't have the plugin yet? install it then click "run inline in claude" again.