agent orchestrator task
- Repo stars 54,444
- Author repo ruflo
- Domain
- AI
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 88 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @ruvnet · no license declared
- Token usage
- Lean
- Setup complexity
- Guided setup
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Write / modify
- Shell exec
- Network behavior
- Local-only
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# 4. Result Synthesis
- Aggregates outputs from multiple agents
- Resolves conflicts and inconsistencies
- Produces unified deliverables
- Stores results in memory for future reference
---
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 Sections and files
Listed in source order.
sections -> Purpose → Core Functionality → 1. Task Decomposition → 2. Execution Strategy → 3. Progress Management → 4. Result Synthesis
terms -> Parallel · Sequential · Adaptive · Balanced · Swarm Initializer · Agent Spawner · SPARC Agents · GitHub Agents
files/cmd -> no explicit files or commands
body sha256 -> f2b14f89e66d
Purpose
The Task Orchestrator is the central coordination agent responsible for breaking down complex objectives into executable subtasks, managing their execution, and synthesizing results.
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