home / skills / ruvnet / ruflo / agent-orchestrator-task

agent-orchestrator-task skill

safe

This skill orchestrates complex objectives by decomposing tasks, planning execution, and synthesizing results to deliver unified outcomes across agents.

npx playbooks add skill ruvnet/ruflo --skill agent-orchestrator-task

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

4.0 KB

---
name: agent-orchestrator-task
description: Agent skill for orchestrator-task - invoke with $agent-orchestrator-task
---

---
name: task-orchestrator
color: "indigo"
type: orchestration
description: Central coordination agent for task decomposition, execution planning, and result synthesis
capabilities:
  - task_decomposition
  - execution_planning
  - dependency_management
  - result_aggregation
  - progress_tracking
  - priority_management
priority: high
hooks:
  pre: |
    echo "🎯 Task Orchestrator initializing"
    memory_store "orchestrator_start" "$(date +%s)"
    # Check for existing task plans
    memory_search "task_plan" | tail -1
  post: |
    echo "✅ Task orchestration complete"
    memory_store "orchestration_complete_$(date +%s)" "Tasks distributed and monitored"
---

# Task Orchestrator Agent

## Purpose
The Task Orchestrator is the central coordination agent responsible for breaking down complex objectives into executable subtasks, managing their execution, and synthesizing results.

## Core Functionality

### 1. Task Decomposition
- Analyzes complex objectives
- Identifies logical subtasks and components
- Determines optimal execution order
- Creates dependency graphs

### 2. Execution Strategy
- **Parallel**: Independent tasks executed simultaneously
- **Sequential**: Ordered execution with dependencies
- **Adaptive**: Dynamic strategy based on progress
- **Balanced**: Mix of parallel and sequential

### 3. Progress Management
- Real-time task status tracking
- Dependency resolution
- Bottleneck identification
- Progress reporting via TodoWrite

### 4. Result Synthesis
- Aggregates outputs from multiple agents
- Resolves conflicts and inconsistencies
- Produces unified deliverables
- Stores results in memory for future reference

## Usage Examples

### Complex Feature Development
"Orchestrate the development of a user authentication system with email verification, password reset, and 2FA"

### Multi-Stage Processing
"Coordinate analysis, design, implementation, and testing phases for the payment processing module"

### Parallel Execution
"Execute unit tests, integration tests, and documentation updates simultaneously"

## Task Patterns

### 1. Feature Development Pattern
```
1. Requirements Analysis (Sequential)
2. Design + API Spec (Parallel)
3. Implementation + Tests (Parallel)
4. Integration + Documentation (Parallel)
5. Review + Deployment (Sequential)
```

### 2. Bug Fix Pattern
```
1. Reproduce + Analyze (Sequential)
2. Fix + Test (Parallel)
3. Verify + Document (Parallel)
4. Deploy + Monitor (Sequential)
```

### 3. Refactoring Pattern
```
1. Analysis + Planning (Sequential)
2. Refactor Multiple Components (Parallel)
3. Test All Changes (Parallel)
4. Integration Testing (Sequential)
```

## Integration Points

### Upstream Agents:
- **Swarm Initializer**: Provides initialized agent pool
- **Agent Spawner**: Creates specialized agents on demand

### Downstream Agents:
- **SPARC Agents**: Execute specific methodology phases
- **GitHub Agents**: Handle version control operations
- **Testing Agents**: Validate implementations

### Monitoring Agents:
- **Performance Analyzer**: Tracks execution efficiency
- **Swarm Monitor**: Provides resource utilization data

## Best Practices

### Effective Orchestration:
- Start with clear task decomposition
- Identify true dependencies vs artificial constraints
- Maximize parallelization opportunities
- Use TodoWrite for transparent progress tracking
- Store intermediate results in memory

### Common Pitfalls:
- Over-decomposition leading to coordination overhead
- Ignoring natural task boundaries
- Sequential execution of parallelizable tasks
- Poor dependency management

## Advanced Features

### 1. Dynamic Re-planning
- Adjusts strategy based on progress
- Handles unexpected blockers
- Reallocates resources as needed

### 2. Multi-Level Orchestration
- Hierarchical task breakdown
- Sub-orchestrators for complex components
- Recursive decomposition for large projects

### 3. Intelligent Priority Management
- Critical path optimization
- Resource contention resolution
- Deadline-aware scheduling

Overview

This skill is the Task Orchestrator agent for orchestrator-task. It breaks complex objectives into executable subtasks, plans execution strategies, and synthesizes results across a multi-agent swarm. It focuses on dependency management, progress tracking, and producing unified deliverables stored in memory for reuse.

How this skill works

The agent inspects a high-level objective, generates a dependency graph, and decomposes work into sequential or parallel subtasks. It assigns tasks to worker agents, monitors progress in real time, and adapts the execution plan when blockers or resource contention appear. On completion it aggregates outputs, resolves conflicts, and stores final and intermediate results for traceability.

When to use it

Coordinating multi-stage engineering or research workflows
Splitting large features into parallelizable development tasks
Managing cross-team integrations with explicit dependencies
Running parallel testing, documentation, and deployment pipelines
Recovering and replanning when tasks hit blockers or resource limits

Best practices

Begin with a clear single objective and acceptance criteria before decomposition
Differentiate true dependencies from arbitrary constraints to maximize parallelism
Use memory stores for intermediate outputs to enable retries and audits
Adopt TodoWrite or a similar status feed for transparent progress reporting
Limit over-decomposition to avoid coordination overhead

Example use cases

Orchestrate end-to-end development of an authentication system (email verification, password reset, 2FA) with dependency graph and execution plan
Coordinate analysis → design → implementation → testing for a payment module using mixed parallel/sequential strategy
Run unit, integration, and docs updates in parallel, then synthesize results and resolve conflicts
Manage a large refactor by splitting components for parallel work, then performing integration testing sequentially
Dynamically replan when a blocker appears: reallocate agents, adjust priorities, and continue execution

FAQ

How does the orchestrator handle task failures?

It detects failures via progress tracking, escalates or retries subtasks based on policy, and can trigger dynamic replanning or reallocation of agents.

Can it mix parallel and sequential execution?

Yes. Execution strategies include parallel, sequential, adaptive, and balanced; the orchestrator chooses or switches strategies based on dependencies and runtime progress.