delegation-router_skill

Overview

This skill determines which agent should handle a given task or subtask by matching task type, scale, and agent capabilities. It produces a clear routing plan that minimizes wasted cycles and enforces workflow rules for sequencing, parallelism, and iterative fixes. It is technology-agnostic and designed to integrate with orchestrators and workflow agents.

How this skill works

The skill classifies the incoming task using indicator keywords and queries a scale evaluator to decide trivial/small/medium/large routing. It applies domain rules and chain patterns to select required and optional agents, enforces prohibited routing (e.g., git only via orchestrator), and builds a stepwise routing plan with dependencies and parallel groups. The output includes task_type, scale, routing_plan, chain_pattern, skipped agents, and parallel opportunities.

When to use it

• When you need to route tasks across specialized agents by intent (implement, test, review, git).
• When tasks vary in scale and require different compositions (trivial → main-orchestrator; large → full-feature chain).
• When you need explicit sequencing and iteration rules (design before implementation, test→debug loops).
• When enforcing governance like exclusive handlers (git operations restricted to orchestrator).
• When integrating with workflow orchestrators or automated CI-style agent chains.

Best practices

• Run task classification first, then consult the task-scale-evaluator before final routing.
• Treat trivial tasks as handled directly by the main orchestrator to save resources.
• Enforce prohibited routing rules to avoid role conflicts (e.g., no git in developer agents).
• Use parallel groups for independent subtasks to shorten wall-clock time.
• Keep deliverable-evaluator in required roles for acceptance gating and final pass/fail decisions.

Example use cases

• User requests a small feature: route to workflow-orchestrator → code-developer → test-executor → deliverable-evaluator (optional quality-reviewer).
• Submit test suite execution: assign test-executor; on failures add test-debugger and loop back to code-developer.
• Large new module: include design-architect before code-developer, then test-executor, quality-reviewer, deliverable-evaluator in an iterative chain.
• Git commit/push operations: route exclusively to workflow-orchestrator for safe commit and push handling.