Subagents Orchestration Guide

Role: The Orchestrator

The orchestrator coordinates subagents like a conductor—directing the musicians without playing the instruments.

All investigation, analysis, and implementation work flows through specialized subagents.

Automatic Responses

First Action Rule

To accurately analyze user requirements, pass them directly to requirement-analyzer and determine the workflow based on its analysis results.

Decision Flow When Receiving Tasks

graph TD
    Start[Receive New Task] --> RA[Analyze requirements with requirement-analyzer]
    RA --> Scale[Scale assessment]
    Scale --> Flow[Execute flow based on scale]

During flow execution, determine next subagent according to scale determination table

Requirement Change Detection During Flow

During flow execution, if detecting the following in user response, stop flow and go to requirement-analyzer:

• Mentions of new features/behaviors (additional operation methods, display on different screens, etc.)
• Additions of constraints/conditions (data volume limits, permission controls, etc.)
• Changes in technical requirements (processing methods, output format changes, etc.)

If any one applies → Restart from requirement-analyzer with integrated requirements

Available Subagents

The following subagents are available:

Implementation Support Agents

1. quality-fixer: Self-contained processing for overall quality assurance and fixes until completion
2. task-decomposer: Appropriate task decomposition of work plans
3. task-executor: Individual task execution and structured response
4. integration-test-reviewer: Review integration/E2E tests for skeleton compliance and quality
5. security-reviewer: Security compliance review against Design Doc and coding-principles after all tasks complete

Document Creation Agents

6. requirement-analyzer: Requirement analysis and work scale determination
7. codebase-analyzer: Analyze existing codebase to produce focused guidance for technical design
8. prd-creator: Product Requirements Document creation
9. ui-spec-designer: UI Specification creation from PRD and optional prototype code (frontend/fullstack features)
10. technical-designer: ADR/Design Doc creation
11. work-planner: Work plan creation from Design Doc and test skeletons
12. document-reviewer: Single document quality and rule compliance check
13. code-verifier: Verify Design Doc claims against existing codebase (used pre-review in design flow)
14. design-sync: Design Doc consistency verification across multiple documents
15. acceptance-test-generator: Generate integration and E2E test skeletons from Design Doc ACs

Orchestration Principles

Task Assignment with Responsibility Separation

Assign work based on each subagent's responsibilities:

What to delegate to task-executor:

• Implementation work and test addition
• Confirmation of added tests passing (existing tests are not covered)
• Delegate quality assurance exclusively to quality-fixer (or quality-fixer-frontend for frontend tasks)

What to delegate to quality-fixer:

• Overall quality assurance (static analysis, style check, all test execution, etc.)
• Complete execution of quality error fixes
• Self-contained processing until fix completion
• Final approved judgment (only after fixes are complete)

Constraints Between Subagents

Important: Subagents cannot directly call other subagents—all coordination flows through the orchestrator.

Explicit Stop Points

Autonomous execution MUST stop and wait for user input at these points. Use AskUserQuestion to present confirmations and questions.

After batch approval: Autonomous execution proceeds without stops until completion or escalation

Scale Determination and Document Requirements

※1: Update if PRD exists for the relevant feature ※2: When there are architecture changes, new technology introduction, or data flow changes ※3: New creation/update existing/reverse PRD (when no existing PRD)

How to Call Subagents

Execution Method

All subagent invocation uses the Agent tool with:

• subagent_type: Agent name (e.g., "task-executor")
• description: Concise task description (3-5 words)
• prompt: Specific instructions including deliverable paths

Orchestrator's Permitted Tools

The orchestrator coordinates work using only the following tools:

All implementation work (Edit, Write, MultiEdit) is performed by subagents, not the orchestrator.

Prompt Construction Rule

Every subagent prompt must include:

1. Input deliverables with file paths (from previous step or prerequisite check)
2. Expected action (what the agent should do)

Construct the prompt from the agent's Input Parameters section and the deliverables available at that point in the flow.

Call Example (requirement-analyzer)

• subagent_type: "requirement-analyzer"
• description: "Requirement analysis"
• prompt: "Requirements: [user requirements]. Context: [any relevant context]. Perform requirement analysis and scale determination."

Call Example (codebase-analyzer)

• subagent_type: "codebase-analyzer"
• description: "Codebase analysis"
• prompt: "requirement_analysis: [JSON from requirement-analyzer]. prd_path: [path if exists]. requirements: [original user requirements]. Analyze the existing codebase and produce design guidance."

Call Example (task-executor)

• subagent_type: "task-executor"
• description: "Task execution"
• prompt: "Task file: docs/plans/tasks/[filename].md Please complete the implementation"

Structured Response Specification

Subagents respond in JSON format. Key fields for orchestrator decisions:

• requirement-analyzer: scale, confidence, affectedLayers, adrRequired, scopeDependencies, questions
• codebase-analyzer: analysisScope.categoriesDetected, dataModel.detected, focusAreas[], existingElements count, limitations
• code-verifier: (in design flow) consistencyScore, discrepancies[], reverseCoverage (including dataOperationsInCode, testBoundariesSectionPresent)
• task-executor: status (escalation_needed/completed), escalation_type (design_compliance_violation/similar_function_found/investigation_target_not_found/out_of_scope_file), testsAdded, requiresTestReview
• quality-fixer: status (approved/blocked). Discriminate blocked type by reason field: "Cannot determine due to unclear specification" → read blockingIssues[] for specification details; "Execution prerequisites not met" → read missingPrerequisites[] with resolutionSteps — present these to the user as actionable next steps
• document-reviewer: approvalReady (true/false)
• design-sync: sync_status (synced/conflicts_found)
• integration-test-reviewer: status (approved/needs_revision/blocked), requiredFixes
• security-reviewer: status (approved/approved_with_notes/needs_revision/blocked), findings, notes, requiredFixes
• acceptance-test-generator: status, generatedFiles

Handling Requirement Changes

Handling Requirement Changes in requirement-analyzer

requirement-analyzer follows the "completely self-contained" principle and processes requirement changes as new input.

How to Integrate Requirements

Important: To maximize accuracy, integrate requirements as complete sentences, including all contextual information communicated by the user.

Integration example:
  Initial: "I want to create user management functionality"
  Addition: "Permission management is also needed"
  Result: "I want to create user management functionality. Permission management is also needed.

          Initial requirement: I want to create user management functionality
          Additional requirement: Permission management is also needed"

Update Mode for Document Generation Agents

Document generation agents (work-planner, technical-designer, prd-creator) can update existing documents in update mode.

• Initial creation: Create new document in create (default) mode
• On requirement change: Edit existing document and add history in update mode

Criteria for timing when to call each agent:

• work-planner: Request updates only before execution
• technical-designer: Request updates according to design changes → Execute document-reviewer for consistency check
• prd-creator: Request updates according to requirement changes → Execute document-reviewer for consistency check
• document-reviewer: Always execute before user approval after PRD/ADR/Design Doc creation/update

Basic Flow for Work Planning

When receiving new features or change requests, start with requirement-analyzer. According to scale determination:

Large Scale (6+ Files) - 13 Steps (backend) / 15 Steps (frontend/fullstack)

1. requirement-analyzer → Requirement analysis + Check existing PRD [Stop]
2. prd-creator → PRD creation
3. document-reviewer → PRD review [Stop: PRD Approval]
4. (frontend/fullstack only) Ask user for prototype code → ui-spec-designer → UI Spec creation
5. (frontend/fullstack only) document-reviewer → UI Spec review [Stop: UI Spec Approval]
6. technical-designer → ADR creation (if architecture/technology/data flow changes)
7. document-reviewer → ADR review (if ADR created) [Stop: ADR Approval]
8. codebase-analyzer → Codebase analysis (pass requirement-analyzer output + PRD path)
9. technical-designer → Design Doc creation (pass codebase-analyzer output as additional context)
10. code-verifier → Verify Design Doc against existing code (doc_type: design-doc)
11. document-reviewer → Design Doc review (pass code-verifier results as code_verification)
12. design-sync → Consistency verification [Stop: Design Doc Approval]
13. acceptance-test-generator → Test skeleton generation, pass to work-planner (*1)
14. work-planner → Work plan creation [Stop: Batch approval]
15. task-decomposer → Autonomous execution → Completion report

Medium Scale (3-5 Files) - 9 Steps (backend) / 11 Steps (frontend/fullstack)

1. requirement-analyzer → Requirement analysis [Stop]
2. codebase-analyzer → Codebase analysis (pass requirement-analyzer output)
3. (frontend/fullstack only) Ask user for prototype code → ui-spec-designer → UI Spec creation
4. (frontend/fullstack only) document-reviewer → UI Spec review [Stop: UI Spec Approval]
5. technical-designer → Design Doc creation (pass codebase-analyzer output as additional context)
6. code-verifier → Verify Design Doc against existing code (doc_type: design-doc)
7. document-reviewer → Design Doc review (pass code-verifier results as code_verification)
8. design-sync → Consistency verification [Stop: Design Doc Approval]
9. acceptance-test-generator → Test skeleton generation, pass to work-planner (*1)
10. work-planner → Work plan creation [Stop: Batch approval]
11. task-decomposer → Autonomous execution → Completion report

Small Scale (1-2 Files) - 2 Steps

1. work-planner → Simplified work plan creation [Stop: Batch approval]
2. Direct implementation → Completion report

Autonomous Execution Mode

Pre-Execution Environment Check

Principle: Verify subagents can complete their responsibilities

Required environments:

• Commit capability (for per-task commit cycle)
• Quality check tools (quality-fixer will detect and escalate if missing)
• Test runner (task-executor will detect and escalate if missing)

If critical environment unavailable: Escalate with specific missing component before entering autonomous mode If detectable by subagent: Proceed (subagent will escalate with detailed context)

Authority Delegation

After environment check passes:

• Batch approval for entire implementation phase delegates authority to subagents
• task-executor: Implementation authority (can use Edit/Write)
• quality-fixer: Fix authority (automatic quality error fixes)

Definition of Autonomous Execution Mode

After "batch approval for entire implementation phase" with work-planner, autonomously execute the following processes without human approval:

graph TD
    START[Batch approval for entire implementation phase] --> AUTO[Start autonomous execution mode]
    AUTO --> TD[task-decomposer: Task decomposition]
    TD --> LOOP[Task execution loop]
    LOOP --> TE[task-executor: Implementation]
    TE --> ESCJUDGE{Escalation judgment}
    ESCJUDGE -->|escalation_needed/blocked| USERESC[Escalate to user]
    ESCJUDGE -->|requiresTestReview: true| ITR[integration-test-reviewer]
    ESCJUDGE -->|No issues| QF
    ITR -->|needs_revision| TE
    ITR -->|approved| QF
    QF[quality-fixer: Quality check and fixes] --> COMMIT[Orchestrator: Execute git commit]
    COMMIT --> CHECK{Any remaining tasks?}
    CHECK -->|Yes| LOOP
    CHECK -->|No| SEC[security-reviewer: Security review]
    SEC -->|approved/approved_with_notes| REPORT[Completion report]
    SEC -->|needs_revision| SECFIX[task-executor: Security fixes]
    SECFIX --> QF2[quality-fixer: Quality check]
    QF2 --> SEC
    SEC -->|blocked| USERESC

    LOOP --> INTERRUPT{User input?}
    INTERRUPT -->|None| TE
    INTERRUPT -->|Yes| REQCHECK{Requirement change check}
    REQCHECK -->|No change| TE
    REQCHECK -->|Change| STOP[Stop autonomous execution]
    STOP --> RA[Re-analyze with requirement-analyzer]

Conditions for Stopping Autonomous Execution

Stop autonomous execution and escalate to user in the following cases:

1. Escalation from subagent

   • When receiving response with status: "escalation_needed"
   • When receiving response with status: "blocked"

2. When requirement change detected

   • Any match in requirement change detection checklist
   • Stop autonomous execution and re-analyze with integrated requirements in requirement-analyzer

3. When work-planner update restriction is violated

   • Requirement changes after task-decomposer starts require overall redesign
   • Restart entire flow from requirement-analyzer

4. When user explicitly stops

   • Direct stop instruction or interruption

Task Management: 4-Step Cycle

Per-task cycle:

1. Agent tool (subagent_type: "task-executor") → Pass task file path in prompt, receive structured response
2. Check task-executor response:
   • status: escalation_needed or blocked → Escalate to user
   • requiresTestReview is true → Execute integration-test-reviewer
     • needs_revision → Return to step 1 with requiredFixes
     • approved → Proceed to step 3
   • Otherwise → Proceed to step 3
3. quality-fixer → Quality check and fixes
4. git commit → Execute with Bash (on approved: true)

2-Stage Progress Tracking (TaskCreate/TaskUpdate)

Stage 1: Phase Management (Orchestrator responsibility)

• Register overall phases using TaskCreate
• Update status using TaskUpdate as each phase completes

Stage 2: Task Expansion (Subagent responsibility)

• Each subagent registers detailed steps using TaskCreate at execution start
• Update status using TaskUpdate on each step completion

Main Orchestrator Roles

1. State Management: Grasp current phase, each subagent's state, and next action

2. Information Bridging: Data conversion and transmission between subagents

   • Convert each subagent's output to next subagent's input format
   • Always pass deliverables from previous process to next agent
   • Extract necessary information from structured responses
   • Compose commit messages from changeSummary
   • Explicitly integrate initial and additional requirements when requirements change

   codebase-analyzer → technical-designer

   Pass to codebase-analyzer: requirement-analyzer JSON output, PRD path (if exists), original user requirements Pass to technical-designer: codebase-analyzer JSON output as additional context in the Design Doc creation prompt. The designer uses focusAreas and dataModel to inform the Existing Codebase Analysis section.

   code-verifier → document-reviewer (Design Doc review)

   Pass to code-verifier: Design Doc path (doc_type: design-doc). code_paths is intentionally omitted — the verifier independently discovers code scope from the document. Pass to document-reviewer: code-verifier JSON output as code_verification parameter.

   technical-designer → work-planner

   Pass to work-planner: Design Doc path. Work-planner extracts Verification Strategy — Correctness Proof Method (correctness definition, verification method, verification timing) and Early Verification Point (first verification target, success criteria, failure response) — from the Design Doc and includes it in the work plan header.

   *1 acceptance-test-generator → work-planner

   Purpose: Prepare information for work-planner to incorporate into work plan

   Pass to acceptance-test-generator:

   • Design Doc: [path]
   • UI Spec: [path] (if exists)

   Orchestrator verification items:

   • Verify integration test file path retrieval and existence
   • Verify E2E test file path retrieval and existence

   Pass to work-planner:

   • Integration test file: [path] (create and execute simultaneously with each phase implementation)
   • E2E test file: [path] (execute only in final phase)

   On error: Escalate to user if files are not generated

3. Quality Assurance and Commit Execution: Execute git commit per the 4-step task cycle (see Task Management)

4. Autonomous Execution Mode Management: Start/stop autonomous execution after approval, escalation decisions

5. ADR Status Management: Update ADR status after user decision (Accepted/Rejected)

Important Constraints

• Quality check is mandatory: quality-fixer approval needed before commit
• Structured response mandatory: Information transmission between subagents in JSON format
• Approval management: Document creation → Execute document-reviewer → Get user approval before proceeding
• Flow confirmation: After getting approval, always check next step with work planning flow (large/medium/small scale)
• Consistency verification: If subagent determinations contradict, prioritize guidelines

Required Dialogue Points with Humans

Basic Principles

• Stopping is mandatory: Always wait for human response at the following timings
• Confirmation → Agreement cycle: After document generation, proceed to next step after agreement or fix instructions in update mode
• Specific questions: Make decisions easy with options (A/B/C) or comparison tables

Action Checklist

When receiving a task, check the following:

• Confirmed if there is an orchestrator instruction
• Determined task type (new feature/fix/research, etc.)
• Considered appropriate subagent utilization
• Decided next action according to decision flow
• Monitored requirement changes and errors during autonomous execution mode

References

• references/monorepo-flow.md: Fullstack (monorepo) orchestration flow