Agent Orchestrator Task
Decompose a fuzzy multi-step objective into dependent subtasks, pick parallel or sequential execution, and track progress when your agent stack needs a coordinator.
Overview
Agent Orchestrator Task is an agent skill most often used in Build (also Ship, Operate) that coordinates task decomposition, execution strategy, and result synthesis across sub-agents.
Install
npx skills add https://github.com/ruvnet/ruflo --skill agent-orchestrator-taskWhat is this skill?
- Task decomposition with dependency graphs and optimal ordering
- Execution modes: parallel, sequential, adaptive, and balanced blends
- Progress, priority, and result aggregation across sub-agents
- Pre/post hooks for orchestrator start and completion markers
- Central coordination narrative for distributing and monitoring work
- 4 execution strategies: parallel, sequential, adaptive, balanced
Adoption & trust: 662 installs on skills.sh; 58.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent keeps jumping between subtasks without a dependency-aware plan, so complex builds stall, duplicate work, or finish out of order.
Who is it for?
Solo builders orchestrating multi-step agent runs—feature builds, refactors, or cross-repo chores—who need explicit decomposition before spawning specialists.
Skip if: Single-file edits, one-shot prompts, or teams that already enforce a fixed human-owned kanban with no agent delegation.
When should I use this skill?
Complex objectives that need task decomposition, dependency ordering, and monitored multi-agent execution—invoke via $agent-orchestrator-task.
What do I get? / Deliverables
You get a decomposed task graph, a chosen parallel/sequential/adaptive execution plan, and aggregated progress so worker agents can run in a monitored sequence.
- Task decomposition and dependency outline
- Execution strategy selection
- Aggregated status and synthesized results
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Orchestration is introduced where you assemble agent tooling—wiring planners, workers, and memory—though the same coordinator pattern replays during ship hardening and operate iteration. Agent-tooling is the canonical shelf because the skill defines decomposition, dependency graphs, and execution strategies for multi-agent runs—not a single integration or UI surface.
Where it fits
Split a full-stack feature into backend, frontend, and docs subtasks with explicit dependencies before parallel agent runs.
Plan ordered steps to add a third-party API, migration, and smoke tests without agents colliding on the same files.
Orchestrate sequential test, review, and fix loops after a release candidate is tagged.
Decompose an incident into reproduce, patch, verify, and monitor tasks with tracked completion.
How it compares
In-repo orchestration playbook for multi-agent sessions—not a managed workflow SaaS or a single MCP tool call.
Common Questions / FAQ
Who is agent-orchestrator-task for?
It is for indie developers and agent power users who run Ruflo-style multi-agent setups and need a coordinator skill before fan-out work.
When should I use agent-orchestrator-task?
Use it when a goal needs several dependent steps—during Build for features and agent tooling, during Ship for test-and-review waves, or during Operate when iterating production fixes across monitors and patches.
Is agent-orchestrator-task safe to install?
Hooks reference shell echo and memory_store; review the Security Audits panel on this Prism page and restrict shell/memory permissions to environments you trust.
SKILL.md
READMESKILL.md - 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 proj