Task Orchestrator#

End-to-end automated task management: from goals to execution, intelligent decomposition, agent matching, and progress monitoring.

Use Cases#

• User mentions keywords such as "task management," "task planning," "task decomposition," "multi-task parallelism," "task orchestration"
• User needs to decompose complex objectives into executable steps
• User needs multiple Agents to collaborate on work
• User needs to track task progress and resource allocation
• User needs intelligent decision-making for execution order and dependencies.

Core Capabilities#

1. Task Parsing and Decomposition#

Automatically decompose natural language objectives into a structured task tree:

• Goal Decomposition: Break complex objectives into atomic tasks
• Dependency Identification: Establish dependency relationships between tasks
• Effort Estimation: Estimate execution time based on task complexity

2. Intelligent Agent Matching#

Match the most suitable execution agent based on task characteristics:

• Capability Matching: Select specialized agents based on task type
• Load Balancing: Avoid agent overload
• Cost Optimization: Balance quality and cost

3. Priority Decision-Making#

Autonomously decide task execution order:

• Urgency Assessment: Based on time constraints and impact scope
• Value Assessment: Based on business value and user expectations
• Dependency Priority: Ensure dependency chains execute correctly

4. Progress Monitoring#

Track task execution status in real time:

• Status Tracking: Pending, In Progress, Completed, Blocked
• Anomaly Detection: Identify timed-out, failed, and blocked tasks
• Automatic Retry: Intelligent retry strategy for failed tasks

Workflow#

text

User Goal → Task Parsing → Task Decomposition → Dependency Analysis → Priority Sorting → Agent Matching → Execution → Monitoring → Summary

Step 1: Receive and Parse Goal#

Understand user intent and identify core objectives:

• Clarify task boundaries and expected outputs
• Identify time constraints and priority hints
• Confirm available resources and constraints

Example Dialogue:

text

User: "Help me complete a product launch, including documentation, testing, and promotional materials"
Orchestrator: Parse goal into 3 main tasks:
  1. Product documentation writing (parallelizable)
  2. Test case design and execution (depends on partial completion of 1)
  3. Promotional material production (parallelizable)

Step 2: Task Decomposition#

Use a script to generate a structured task tree:

bash

python3 scripts/task_decomposer.py --goal "User Goal" --output tasks.json

Output structure:

json

{
  "main_goal": "Product Launch",
  "tasks": [
    {
      "id": "T1",
      "title": "Write Product Documentation",
      "description": "Includes feature descriptions, user guides, and API documentation",
      "priority": "high",
      "estimated_time": "2h",
      "dependencies": [],
      "subtasks": [
        {"id": "T1.1", "title": "Feature Description Document"},
        {"id": "T1.2", "title": "User Guide"},
        {"id": "T1.3", "title": "API Interface Documentation"}
      ],
      "required_skills": ["doc-writing-skill"],
      "status": "pending"
    }
  ]
}

Step 3: Agent Matching and Resource Allocation#

Select execution agents based on task characteristics. See references/agent_matching.md for details.

Step 4: Execution and Monitoring#

Initiate task execution and continuously monitor:

• Execute tasks without dependencies in parallel
• Execute tasks with dependencies serially
• Update task status in real time
• Automatically adjust plans upon anomalies

Step 5: Result Integration and Feedback#

After task completion:

• Integrate execution results from each agent
• Generate an execution report
• Collect feedback to optimize subsequent tasks

Quick Start#

Scenario 1: Complex Task Decomposition#

text

User: "Help me prepare for next week's tech sharing session; I need a PPT, demo code, and a promotional poster"

Orchestrator:
1. Parse Goal → Identify 3 parallel tasks
2. Decompose Tasks → Estimate total effort 8h
3. Match Agents →
   - PPT: doc-writing-skill + ppt-parser-local
   - Demo: Code generation agent
   - Poster: image_generation
4. Suggest Execution Order → PPT outline → demo development → poster design → PPT refinement

Scenario 2: Multi-Agent Collaboration#

text

User: "Complete a competitive analysis report; need data scraping, chart generation, and report writing"

Orchestrator:
1. Task Decomposition: Data scraping (T1) → Data analysis (T2) → Chart generation (T3) → Report writing (T4)
2. Dependency Chain: T1→T2→T3→T4
3. Agent Matching:
   - T1: web-search + deep-search-skill
   - T2: Data analysis agent
   - T3: image_generation
   - T4: doc-writing-skill
4. Execution Plan: Serial execution, estimated total duration 6h

Decision Framework#

Priority Decision Matrix#

DimensionWeightScoring CriteriaUrgency30%Deadline, blocking impactValue40%Business value, user expectationsCost20%Time cost, resource consumptionRisk10%Failure risk, dependency risk

Agent Selection Strategy#

See references/agent_matching.md for details.

Resource Files#

scripts/#

• task_decomposer.py - Task decomposition script, generates structured task tree
• priority_calculator.py - Priority calculation script, supports custom weights
• progress_monitor.py - Progress monitoring script, tracks task status in real time

references/#

• agent_matching.md - Agent matching strategies and capability matrix
• workflow_patterns.md - Common workflow patterns and best practices
• task_templates.md - Common task template library

assets/#

• task_plan_template.md - Task planning document template
• execution_report_template.md - Execution report template