Delegation Router

A technology-agnostic skill for determining which agent should handle a given task or subtask.

Core Purpose

Route tasks to the most appropriate agent based on:

• Task type and requirements

• Agent capabilities and specializations

• Workflow state and dependencies

• Resource efficiency

Agent Routing Matrix

Core Agents and Their Domains

main-orchestrator: domain: "User interface and workflow initiation" receives_from: - "User directly" delegates_to: - task-scale-evaluator - goal-clarifier - workflow-orchestrator handles_directly: - "Trivial read/search tasks" - "Result summarization"

task-scale-evaluator: domain: "Task complexity assessment" receives_from: - main-orchestrator delegates_to: - workflow-orchestrator # Automatic chain via SubagentStop hook handles_directly: - "Scale classification" - "Workflow recommendation"

goal-clarifier: domain: "Intent clarification and acceptance criteria drafts" receives_from: - main-orchestrator delegates_to: null # Returns clarification to caller handles_directly: - "Ambiguity resolution" - "Quick acceptance criteria generation"

workflow-orchestrator: domain: "Workflow coordination and Git operations" receives_from: - main-orchestrator - deliverable-evaluator (on PASS) delegates_to: - design-architect - code-developer - quality-reviewer - deliverable-evaluator handles_directly: - "Progress tracking" - "Git commit/push" - "Agent coordination"

design-architect: domain: "Architecture and design specifications" receives_from: - workflow-orchestrator delegates_to: null handles_directly: - "Architecture design" - "Component specification"

code-developer: domain: "Code implementation" receives_from: - workflow-orchestrator - test-debugger (fix recommendations) delegates_to: - test-executor (after implementation) handles_directly: - "Feature implementation" - "Bug fixes" - "Test code creation"

test-executor: domain: "Test execution and result analysis" receives_from: - code-developer (automatic chain) delegates_to: - test-debugger (on failures) handles_directly: - "Test suite execution" - "Result categorization"

test-debugger: domain: "Test failure analysis" receives_from: - test-executor delegates_to: - code-developer (fix implementation) handles_directly: - "Root cause analysis" - "Fix recommendations"

quality-reviewer: domain: "Code quality assessment" receives_from: - workflow-orchestrator delegates_to: null handles_directly: - "Code review" - "Quality scoring"

deliverable-evaluator: domain: "Final deliverable evaluation" receives_from: - workflow-orchestrator delegates_to: - workflow-orchestrator (on PASS, for commit) - assigned agent (on FAIL, for rework) handles_directly: - "Acceptance criteria evaluation" - "Pass/fail verdict"

Routing Decision Logic

By Task Type

task_type_routing: code_implementation: primary: code-developer prerequisites: large_tasks: [design-architect] followup: [test-executor, quality-reviewer]

bug_fix: primary: code-developer prerequisites: [] followup: [test-executor]

test_execution: primary: test-executor on_failure: test-debugger on_success: quality-reviewer

quality_review: primary: quality-reviewer on_issues: code-developer on_pass: deliverable-evaluator

git_operations: exclusive: workflow-orchestrator never: [code-developer, test-executor]

requirements: simple: goal-clarifier complex: goal-clarifier

architecture: primary: design-architect when: "New module or significant changes"

By Task Scale

scale_routing: trivial: can_handle: [main-orchestrator] skip: [workflow-orchestrator, design-architect, quality-reviewer]

All non-trivial tasks go through workflow-orchestrator (automatic chain from task-scale-evaluator)

small: entry_point: workflow-orchestrator required: [code-developer, test-executor, deliverable-evaluator] optional: [quality-reviewer] skip: [design-architect]

medium: entry_point: workflow-orchestrator required: [code-developer, test-executor, quality-reviewer, deliverable-evaluator] optional: [design-architect]

large: entry_point: workflow-orchestrator required: [design-architect, code-developer, test-executor, quality-reviewer, deliverable-evaluator] iterative: true

Chain Patterns

common_chains: standard_implementation: - workflow-orchestrator - code-developer - test-executor - quality-reviewer - deliverable-evaluator

with_debugging: - workflow-orchestrator - code-developer - test-executor - test-debugger # on failure - code-developer # apply fix - test-executor # verify - quality-reviewer - deliverable-evaluator

full_feature: - workflow-orchestrator - design-architect - code-developer - test-executor - quality-reviewer - deliverable-evaluator

Routing Algorithm

Step 1: Identify Task Type

classify_task: implementation: indicators: ["implement", "add", "create", "build"] bug_fix: indicators: ["fix", "resolve", "correct", "debug"] review: indicators: ["review", "check", "assess"] test: indicators: ["test", "verify", "validate"] git: indicators: ["commit", "push", "branch"] requirements: indicators: ["clarify", "define", "specify"]

Step 2: Check Scale Requirements

scale_check:

• Get scale from task-scale-evaluator
• Apply scale_routing rules
• Identify required agents
• Identify optional agents

Step 3: Determine Sequence

sequence_rules: dependencies_first: - design-architect before code-developer (large) - code-developer before test-executor

parallel_when_possible: - "Independent subtasks can run in parallel" - "Example: multiple file fixes"

iterative_when_needed: - "test-debugger → code-developer loop" - "deliverable-evaluator → rework loop"

Step 4: Generate Routing Plan

routing_plan: sequential: - agent: "<agent_name>" task: "<specific task>" depends_on: ["<previous agents>"]

parallel_groups: - group: 1 agents: ["<independent agents>"] - group: 2 agents: ["<agents depending on group 1>"]

Output Format

routing_decision: task_type: "<classified type>" scale: "<task scale>"

routing_plan: - step: 1 agent: "<agent_name>" task: "<what to do>" required: true|false depends_on: []

- step: 2
  agent: "<agent_name>"
  task: "<what to do>"
  required: true|false
  depends_on: [1]

chain_pattern: "<pattern name if applicable>"

skip_agents: - agent: "<agent_name>" reason: "<why skipped>"

parallel_opportunities: - group: ["<agent1>", "<agent2>"] reason: "<why parallel is possible>"

Prohibited Routing

never_route: git_operations: to: [code-developer, test-executor, quality-reviewer] exclusive: workflow-orchestrator

implementation: to: [main-orchestrator, workflow-orchestrator] exclusive: code-developer

quality_judgment: to: [main-orchestrator, code-developer] exclusive: [quality-reviewer, deliverable-evaluator]

Integration

Used By Agents

primary_users:

• main-orchestrator: "Initial routing decisions"
• workflow-orchestrator: "Chain management"

secondary_users:

• task-scale-evaluator: "Routing recommendations"

Configuration Reference

Project-specific routing in .claude/config.yaml

delegation: custom_routes: specific_task_type: primary: custom-agent fallback: default-agent

disabled_agents: - "design-architect" # Small projects may skip

required_agents: - "deliverable-evaluator" # Always required