TaskMaster - AI Cost Optimizer

Project manager and task delegation system. Use when you need to break down complex work into smaller tasks, assign appropriate AI models based on complexity, spawn sub-agents for parallel execution, track progress, and manage token budgets. Ideal for research projects, multi-step workflows, or when you want to delegate routine tasks to cheaper models while handling complex coordination yourself.

Security Scan

The skill's code, docs, and runtime instructions are consistent with a task-delegation / cost-optimization tool; nothing requested or installed is disproportionate to its stated purpose.

Purpose & Capability

Name/description (task delegation, model selection, sub-agents, token tracking) match the included files and code. The Python code implements complexity analysis, model selection, spawn-command generation, and local cost logging consistent with the stated functionality. Use of Anthropic model identifiers is coherent with cost-optimization claims.

Instruction Scope

SKILL.md and code stick to orchestration, model selection, spawn command generation, and cost tracking; they do not instruct reading unrelated system files or requesting unrelated credentials. However, several integration functions are stubs or designed for manual invocation (e.g., execute_task prints spawn commands and returns instructions rather than calling sessions_spawn directly; track_session_cost/session_status parsing is incomplete/truncated). Also the skill writes/updates a local JSON cost log (taskmaster-costs.json) which may contain task metadata; review whether that file could store sensitive task text before use.

Install Mechanism

No install spec and no external downloads. The skill is instruction+code only and depends only on Python standard capabilities. There are no URLs, installers, or extracted archives that would execute arbitrary remote code during install.

Credentials

The package declares no required environment variables, no credentials, and no config paths. The code expects OpenClaw platform functions (sessions_spawn, session_status) for integration but does not request unrelated secrets or cloud credentials.

Persistence & Privilege

always:false (no forced inclusion). The skill writes a local cost log (taskmaster-costs.json) and returns spawn commands that include 'cleanup': 'keep' which may retain session artifacts until cleaned. The skill does not request system-wide privileges or alter other skills' config, but consider that saved logs may contain task descriptions or outputs.

Assessment

This skill appears internally coherent and implements what it claims: model triage, sub-agent spawn command generation, and local token-cost tracking. Before installing or running it, consider: 1) Integration is partially manual/stubbed — execute_task prints spawn commands rather than automatically calling sessions_spawn, and track_session_cost is not fully implemented; expect to supply platform session calls or finish integration. 2) Cost/log file (taskmaster-costs.json) will be created/updated locally and may contain task descriptions, token counts, or outputs — treat that as potentially sensitive and store it securely or audit what gets written. 3) The spawn command uses cleanup: "keep" (retains session artifacts); decide whether you want sessions retained. 4) The skill references Anthropic model names — using it will incur model/billing costs when you actually spawn sessions. 5) Because the skill can generate and suggest automated sub-agent work, review and control actual execution (sessions_spawn/session_status) on your OpenClaw instance to avoid unintended automated runs. If you want higher assurance, review the full delegate_task.py and openclaw_integration.py to confirm there are no hidden network calls or logging of full task outputs to external endpoints.

TaskMaster: AI Project Manager & Task Delegation

Transform complex projects into managed workflows with smart model selection and sub-agent orchestration.

Core Capabilities

🎯 Smart Task Triage

• Analyze complexity → assign appropriate model (Haiku/Sonnet/Opus)
• Break large projects into smaller, manageable tasks
• Prevent over-engineering (don't use Opus for simple web searches)

🤖 Sub-Agent Orchestration

• Spawn isolated sub-agents with specific model constraints
• Run tasks in parallel for faster completion
• Consolidate results into coherent deliverables

💰 Budget Management

• Track token costs per task and total project
• Set budget limits to prevent runaway spending
• Optimize model selection for cost-efficiency

📊 Progress Tracking

• Real-time status of all active tasks
• Failed task retry with escalation
• Final deliverable compilation

Quick Start

1. Basic Task Delegation

TaskMaster: Research PDF processing libraries
- Budget: $2.00
- Priority: medium
- Deadline: 2 hours

2. Complex Project Breakdown

TaskMaster: Build recipe app MVP
- Components: UI mockup, backend API, data schema, deployment
- Budget: $15.00
- Timeline: 1 week
- Auto-assign models based on complexity

Model Selection Rules

Haiku ($0.25/$1.25) - Simple, repetitive tasks:

• Web searches & summarization
• Data formatting & extraction
• Basic file operations
• Status checks & monitoring

Sonnet ($3/$15) - Most development work:

• Research & analysis
• Code writing & debugging
• Documentation creation
• Technical design

Opus ($15/$75) - Complex reasoning:

• Architecture decisions
• Creative problem-solving
• Code reviews & optimization
• Strategic planning

Advanced Usage

Custom Model Assignment

Override automatic selection when you know better:

TaskMaster: Debug complex algorithm [FORCE: Opus]

Parallel Execution

Run multiple tasks simultaneously:

TaskMaster: Multi-research project
- Task A: Library comparison
- Task B: Performance benchmarks  
- Task C: Security analysis
[PARALLEL: true]

Budget Controls

Set spending limits:

TaskMaster: Market research
- Max budget: $5.00
- Escalate if >$3.00 spent
- Stop if any single task >$1.00

Key Resources

• Model Selection: See references/model-selection-rules.md for detailed complexity guidelines
• Task Templates: See references/task-templates.md for common task patterns
• Delegation Engine: Uses scripts/delegate_task.py for core orchestration logic

Implementation Notes

Sessions Management: Each sub-agent gets isolated session with specific model constraints. No cross-talk unless explicitly designed.

Error Handling: Failed tasks automatically retry once on Sonnet, then escalate to human review.

Result Aggregation: TaskMaster compiles all sub-agent results into a single, coherent deliverable for the user.

Token Tracking: Real-time cost monitoring with alerts when approaching budget limits.