task-orchestra

# 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.