Claude Code Dynamic Workflows: The 6 Orchestration Patterns That Turn One Prompt Into 100 Parallel Agents

Phase 1: Classify
  Input → [Classifier Agent] → Category A, B, or C
Phase 2: Act
  Category A → [Action Agent A] → Result A
  Category B → [Action Agent B] → Result B
  Category C → [Action Agent C] → Result C

// Claude-generated orchestrator
async function classifyActWorkflow(tickets) {
  const results = await Promise.all(tickets.map(async (ticket) => {
    // Phase 1: Classify
    const classification = await claude.subagent({
      prompt: Classify this support ticket into one of: 
        BUG_REPORT, FEATURE_REQUEST, ACCOUNT_ISSUE, GENERAL_QUESTION
        Ticket: ${ticket.text},
      outputSchema: { category: 'string', confidence: 'number' }
    });
    
    // Phase 2: Act based on classification
    switch(classification.category) {
      case 'BUG_REPORT':
        return await handleBugReport(ticket, classification.confidence);
      case 'FEATURE_REQUEST':
        return await handleFeatureRequest(ticket);
      case 'ACCOUNT_ISSUE':
        return await escalateToTeam(ticket, 'billing');
      case 'GENERAL_QUESTION':
        return await generateAnswer(ticket);
    }
  }));
  
  return synthesizeResults(results);
}

Input → [Decomposer Agent] → Subtasks 1..N
  Subtask 1 → [Worker Agent 1] → Result 1
  Subtask 2 → [Worker Agent 2] → Result 2
  ...
  Subtask N → [Worker Agent N] → Result N
  All Results → [Synthesizer Agent] → Final Output

async function fanOutSynthesize(document, targetChunkTime = 5) {
  let chunks = splitIntoChunks(document, 100); // initial size
  let results = [];
  
  while (chunks.length > 0) {
    const batch = chunks.splice(0, 50); // process 50 at a time
    const batchResults = await Promise.all(batch.map(async (chunk, i) => {
      const start = Date.now();
      const result = await claude.subagent({
        prompt: Analyze this chunk for compliance issues...,
        context: chunk
      });
      const elapsed = (Date.now() - start) / 1000;
      
      // Adjust chunk size based on actual time
      if (elapsed < targetChunkTime * 0.5) {
        chunkSize = Math.min(chunkSize * 1.5, 500);
      } else if (elapsed > targetChunkTime * 1.5) {
        chunkSize = Math.max(chunkSize * 0.5, 20);
      }
      
      return result;
    }));
    
    results.push(...batchResults);
  }
  
  return await claude.subagent({
    prompt: Synthesize these ${results.length} analysis results into a coherent report...,
    context: results
  });
}

Input → [Generator Agent] → Solution
Solution → [Verifier Agent] → Flaws
Flaws → [Generator Agent] → Improved Solution
...loop until verifier approves or max iterations...

async function adversarialVerification(task, maxIterations = 3) {
  let solution = await claude.subagent({
    role: 'generator',
    prompt: Generate a PostgreSQL migration for: ${task}
  });
  
  for (let i = 0; i < maxIterations; i++) {
    const verification = await claude.subagent({
      role: 'verifier',
      prompt: Find ALL flaws in this migration. Consider:
        - Data loss risks
        - Performance impacts
        - Rollback complexity
        - Locking concerns
        Migration: ${solution}
    });
    
    if (verification.approved) {
      return { solution, iterations: i + 1, confidence: 'high' };
    }
    
    solution = await claude.subagent({
      role: 'generator',
      prompt: Improve this migration based on verification feedback.
        Original task: ${task}
        Current solution: ${solution}
        Feedback: ${verification.flaws}
        Generate an improved version that addresses ALL concerns.
    });
  }
  
  return { solution, iterations: maxIterations, confidence: 'medium' };
}

Input → [Generator Agent] → Candidates [1..N]
Candidates → [Filter Agent] → Filtered Candidates
Filtered Candidates → [Ranker Agent] → Top K Results

async function generateFilter(task, candidatesCount = 20) {
  // Phase 1: Generate diverse candidates
  const candidates = await Promise.all(
    Array.from({ length: candidatesCount }, (_, i) => 
      claude.subagent({
        role: 'generator',
        prompt: Design an API for: ${task}
          Approach ${i + 1}: Take a completely different approach than previous designs.
          Focus on: ${['simplicity', 'performance', 'extensibility', 'security', 'developer experience'][i % 5]},
        temperature: 0.8 + (i * 0.01) // slight variation
      })
    )
  );
  
  // Phase 2: Filter for viability
  const viable = await claude.subagent({
    role: 'filter',
    prompt: Evaluate these ${candidates.length} API designs. 
      Eliminate any that are:
      - Not technically feasible
      - Inconsistent with REST best practices
      - Missing critical endpoints
      Return only viable designs with brief justification.,
    context: candidates
  });
  
  // Phase 3: Rank and select
  const top3 = await claude.subagent({
    role: 'ranker',
    prompt: Rank the remaining designs by: developer experience, 
      scalability, maintainability, and security.
      Return top 3 with detailed comparison.,
    context: viable
  });
  
  return top3;
}

Round 1: Candidate A vs Candidate B → Winner 1
         Candidate C vs Candidate D → Winner 2
         Candidate E vs Candidate F → Winner 3
         Candidate G vs Candidate H → Winner 4
Round 2: Winner 1 vs Winner 2 → Finalist A
         Winner 3 vs Winner 4 → Finalist B
Final:   Finalist A vs Finalist B → Champion

async function tournament(architectures, rounds = 3) {
  let competitors = architectures;
  
  for (let round = 0; round < rounds; round++) {
    const pairs = [];
    for (let i = 0; i < competitors.length; i += 2) {
      if (i + 1 < competitors.length) {
        pairs.push([competitors[i], competitors[i + 1]]);
      } else {
        // Odd competitor gets a bye
        pairs.push([competitors[i]]);
      }
    }
    
    const winners = await Promise.all(pairs.map(async (pair) => {
      if (pair.length === 1) return pair[0]; // bye
      
      return await claude.subagent({
        role: 'judge',
        prompt: Compare these two architectures and select the better one.
          Consider: scalability, maintainability, cost, team expertise required.
          
          Architecture A: ${pair[0]}
          Architecture B: ${pair[1]}
          
          Provide detailed reasoning for your choice.,
        outputSchema: { 
          winner: 'number', 
          reasoning: 'string',
          confidence: 'number' 
        }
      });
    }));
    
    competitors = winners;
  }
  
  return competitors[0]; // champion
}

Input → [Agent] → Output
Output → [Quality Check] → Pass? → Yes → Final Output
                         → No → [Agent] → Improved Output
                         → No → [Agent] → Improved Output
                         ...until pass or max iterations

async function loopUntilDone(task, qualityThreshold = 0.9, maxIterations = 10) {
  let output = await claude.subagent({
    role: 'writer',
    prompt: Write documentation for: ${task}
  });
  
  for (let i = 0; i < maxIterations; i++) {
    const quality = await claude.subagent({
      role: 'reviewer',
      prompt: Evaluate this documentation on:
        - Completeness (0-1): Are all topics covered?
        - Clarity (0-1): Is it understandable by a junior developer?
        - Accuracy (0-1): Are there any technical errors?
        - Actionability (0-1): Can someone follow the instructions?
        
        Documentation: ${output}
        
        Return overall score and specific improvement suggestions.,
      outputSchema: {
        completeness: 'number',
        clarity: 'number',
        accuracy: 'number',
        actionability: 'number',
        improvements: ['string']
      }
    });
    
    const overallScore = (quality.completeness + quality.clarity + 
                         quality.accuracy + quality.actionability) / 4;
    
    if (overallScore >= qualityThreshold) {
      return { output, iterations: i + 1, finalScore: overallScore };
    }
    
    output = await claude.subagent({
      role: 'writer',
      prompt: IMPROVE this documentation based on feedback.
        Current version: ${output}
        
        Issues to fix:
        ${quality.improvements.join('\n')}
        
        Generate an improved version that addresses ALL issues.
    });
  }
  
  return { output, iterations: maxIterations, finalScore: 'max iterations reached' };
}

Generate → [Create solution]
Test → [Verify quality]
Pass/Fail → [Binary decision: ship or iterate]
Iterate → [Apply feedback, regenerate]