Task Orchestrator

Intelligent task management and execution coordination officer. Automatically generates task lists, intelligently decomposes complex tasks, matches AI agents...

Security Scan

The skill's code and instructions are consistent with an offline task-orchestration helper: it runs local Python scripts to decompose tasks, score/prioritize them, and update a local tasks JSON; it does not request credentials, install external packages, or call remote endpoints.

Purpose & Capability

The name/description (task orchestration, decomposition, agent matching, monitoring) aligns with the included Python scripts and reference documents. The files implement decomposition, priority scoring, and progress monitoring — capabilities expected for this purpose. Agent names referenced in mappings are labels for matching and do not imply external credential requirements.

Instruction Scope

SKILL.md instructs the agent to run the included scripts and operate on a tasks JSON (e.g., python3 scripts/task_decomposer.py --goal ... --output tasks.json). The runtime instructions reference only repository files and expected task output files. There are no instructions to read unrelated system files, environment variables, or transmit data externally.

Install Mechanism

There is no install spec — the skill is instruction-plus-local-scripts only. No downloads, package installs, or external installers are requested.

Credentials

The skill declares no required environment variables, no credentials, and no config paths. The included code does not access environment variables or external secrets. The set of declared/used resources is proportionate to the stated functionality.

Persistence & Privilege

The skill is not marked always:true and uses normal agent invocation. It does write/read its own task JSON files (progress_monitor updates the supplied tasks file), which is expected behavior for a local progress tracker and not a system-wide privilege escalation.

Assessment

This skill appears coherent and self-contained: the scripts operate on local JSON task files and do not contact external endpoints or request credentials. Before installing or running it, consider these practical precautions: - Review the code locally (you already have full source) and run it in a sandbox or container if you are cautious. - Be aware progress_monitor.py will overwrite the tasks JSON you point it at (it saves changes in place). Back up any important files before using the update action. - The 'agent' names in references are placeholders for matching — they do not automatically call external agent services. If you adapt the skill to invoke external agents, you'll need to add credentials and networking; re-review for new risks then. - If you plan to run these scripts on shared or production hosts, run them with a dedicated working directory to avoid accidental modification of other files. No red flags were found in the included code or SKILL.md; confidence is high because all behavior is visible in the bundled source and it does not perform network I/O or request secrets.

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

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:

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:

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

Output structure:

{
  "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

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

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

Dimension	Weight	Scoring Criteria
Urgency	30%	Deadline, blocking impact
Value	40%	Business value, user expectations
Cost	20%	Time cost, resource consumption
Risk	10%	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