Claude Code Dynamic Workflow Guide: Multi-Agent Orchestration with JavaScript

.claude/
├── workflows/              # Directory for Workflow scripts
│   └── math-problems.js    # One workflow = One .js file
├── agents/                 # Custom agent definitions (⚠️ cannot be referenced by workflows)
│   ├── math-solver.md      # Only used for automatic routing in the main session
│   └── math-verifier.md
└── settings.json           # Project configuration

export const meta = {
  name: 'my-workflow',           // Required: Unique identifier
  description: 'Description of purpose', // Required: Description of purpose
  phases: [                      // Optional: Define phases (for UI display)
    { title: 'Analyze' },
    { title: 'Execute' },
  ],
}

// ... Your orchestration logic
// Orchestrate using agent() / pipeline() / parallel()
// Finally, return the result

export const meta = {
  name: 'hello',
  description: 'The simplest workflow',
  phases: [{ title: 'Greet' }],
}

const result = await agent('Say hello world', { phase: 'Greet' })
return result

export const meta = {
  name: 'hello-name',
  description: 'Greeting',
}

// args are passed from the outside
const name = (args && args.name) || 'World'
const result = await agent(`Say hello to ${name} and introduce yourself`)
return result

// Basic usage
const result = await agent('Your prompt')

// Full parameters
const result = await agent('Your prompt', {
  label: 'Display Name',      // Label displayed in the UI
  phase: 'Solve',             // Assigned phase
  schema: {                   // Enforce structured output (JSON Schema)
    type: 'object',
    properties: {
      answer: { type: 'string' },
      confidence: { type: 'number' }
    }
  },
  model: 'sonnet',            // Optional model override
  agentType: 'Explore',       // ⚠️ Only supports built-in types, custom types are not supported
})

const results = await pipeline(
  ['Problem 1', 'Problem 2', 'Problem 3'], // Data array
  (item) => agent(`Process: ${item}`),     // stage 1
  (prev, item) => agent(`Review: ${prev}`), // stage 2
)

// results[0] = Result of stage2(Problem 1)
// results[1] = Result of stage2(Problem 2)
// Each data item completes the entire pipeline independently; different items run in parallel

const results = await parallel([
  () => agent('Analyze frontend code'),
  () => agent('Analyze backend code'),
  () => agent('Analyze database'),
])

// results = [Frontend analysis, Backend analysis, Database analysis]
// Returns null if any fails; filter using .filter(Boolean)

phase('Review')          // Switch to the Review phase (UI progress bar grouping)
log('Processed 3/10 files')  // Output progress information

Data flow per group (using Group 1 as an example):

┌─────────────────────────────────────────────────┐
│ Stage 1: Solver                                 │
│ prompt = SOLVER_PROMPT + all Group 1 problems   │
│ output = detailed solutions for 5 problems      │
└──────────────────────┬──────────────────────────┘
                       │ solution (output from previous stage)
┌──────────────────────▼──────────────────────────┐
│ Stage 2: Verifier                               │
│ prompt = VERIFIER_PROMPT + Group 1 problems + solution │
│ output = step-by-step verification results (✅/❌) │
└──────────────────────┬──────────────────────────┘
                       │ verification (output from previous stage)
┌──────────────────────▼──────────────────────────┐
│ Stage 3: Scorer                                 │
│ prompt = SCORER_PROMPT + Group 1 problems + verification │
│ output = score and comments for each problem    │
└─────────────────────────────────────────────────┘

You are a math problem-solving expert. Please solve the following math problems one by one.

1. 12 × 15 = ?
2. √144 + 3² = ?
3. 2^10 = ?
4. 1 + 2 + 3 + ... + 100 = ?
5. 1/2 + 1/3 + 1/6 = ?

Output format (per problem):
- Problem: {Original problem}
- Solution process: {Step-by-step derivation}
- Answer: {Final result}

You are a math problem-solving expert. Please solve the following math problems one by one.

6. How many trailing zeros are in 100!?
7. sin30° × cos60° = ?
8. log₂1024 = ?
9. The circumference of a circle is 31.4cm, find its area (π≈3.14)
10. Solve the equation: 2x + 5 = 17

Output format (per problem):
- Problem: {Original problem}
- Solution process: {Step-by-step derivation}
- Answer: {Final result}

You are a math verification expert. Independently re-solve the problems and compare them with the solutions below.

1. 12 × 15 = ?
2. √144 + 3² = ?
3. 2^10 = ?
4. 1 + 2 + 3 + ... + 100 = ?
5. 1/2 + 1/3 + 1/6 = ?

=== Solutions to Verify ===
[Solver's complete output will be inserted here]

=== Requirements ===
- Calculate independently; do not trust the provided solutions.
- Compare step-by-step and mark as correct or incorrect.
- If there is an error, pinpoint its exact location.

Output format:
- Judgment: ✅ Correct / ❌ Incorrect
- Verification process: {Independent derivation}
- Reason for error: {If any}

You are a math scoring expert. Score based on the solutions and verification results.

1. 12 × 15 = ?
2. √144 + 3² = ?
3. 2^10 = ?
4. 1 + 2 + 3 + ... + 100 = ?
5. 1/2 + 1/3 + 1/6 = ?

=== Verification Results ===
[Verifier's complete output will be inserted here]

Scoring: 10=Perfect | 7-9=Correct but improvable | 4-6=Partially correct | 0-3=Incorrect

Output format:
- Score: {0-10}
- Comment: {One sentence}

export const meta = {
  name: 'math-problems',
  description: 'Math problem workflow — problems written into prompt by group, 3-stage pipeline (Solve→Verify→Score)',
  phases: [
    { title: 'Solve', detail: 'Solve problems in parallel per group' },
    { title: 'Verify', detail: 'Independently verify solutions per group' },
    { title: 'Score', detail: 'Comprehensive scoring' },
  ],
}

// ─── Prompt Templates (Defined at the top for clarity) ──────────────
// {problems_block}  → All problems in the group
// {solution}        → Solver's output
// {verification}    → Verifier's output

const SOLVER_PROMPT = `You are a math problem-solving expert. Please solve the following math problems one by one.

{problems_block}

Output format (per problem):
- Problem: {Original problem}
- Solution process: {Step-by-step derivation}
- Answer: {Final result}`

const VERIFIER_PROMPT = `You are a math verification expert. Independently re-solve the problems and compare them with the solutions below.

{problems_block}

=== Solutions to Verify ===
{solution}

=== Requirements ===
- Calculate independently; do not trust the provided solutions.
- Compare step-by-step and mark as correct or incorrect.
- If there is an error, pinpoint its exact location.

Output format:
- Judgment: ✅ Correct / ❌ Incorrect
- Verification process: {Independent derivation}
- Reason for error: {If any}`

const SCORER_PROMPT = `You are a math scoring expert. Score based on the solutions and verification results.

{problems_block}

=== Verification Results ===
{verification}

Scoring: 10=Perfect | 7-9=Correct but improvable | 4-6=Partially correct | 0-3=Incorrect

Output format:
- Score: {0-10}
- Comment: {One sentence}`

// ─── Problem Grouping (Written directly here, easy for beginners to modify) ──────────
const DEFAULT_GROUPS = [
  {
    name: 'Group 1 (Basic Math)',
    problems: [
      '1. 12 × 15 = ?',
      '2. √144 + 3² = ?',
      '3. 2^10 = ?',
      '4. 1 + 2 + 3 + ... + 100 = ?',
      '5. 1/2 + 1/3 + 1/6 = ?',
    ],
  },
  {
    name: 'Group 2 (Advanced Math)',
    problems: [
      '6. How many trailing zeros are in 100!?',
      '7. sin30° × cos60° = ?',
      '8. log₂1024 = ?',
      '9. The circumference of a circle is 31.4cm, find its area (π≈3.14)',
      '10. Solve the equation: 2x + 5 = 17',
    ],
  },
]

// ─── Main Flow ─────────────────────────────────────────
const groups = (args && args.groups && args.groups.length)
  ? args.groups
  : DEFAULT_GROUPS

log(`Total ${groups.reduce((n, g) => n + g.problems.length, 0)} problems, ${groups.length} groups`)
groups.forEach((g) => log(`  ${g.name}: ${g.problems.join(', ')}`))

// Run pipeline in parallel for each group, problems written directly in prompt
const results = await parallel(
  groups.map((group) => () => {
    const problemsBlock = group.problems.join('\n')
    return pipeline(
      [group],  // The entire group as a single unit
      // Stage 1: Solve
      (grp) => agent(
        SOLVER_PROMPT.replace('{problems_block}', grp.problems.join('\n')),
        { label: `${grp.name}-Solve`, phase: 'Solve' }
      ),
      // Stage 2: Verify
      (solution, grp) => agent(
        VERIFIER_PROMPT
          .replace('{problems_block}', grp.problems.join('\n'))
          .replace('{solution}', solution),
        { label: `${grp.name}-Verify`, phase: 'Verify' }
      ),
      // Stage 3: Score
      (verification, grp) => agent(
        SCORER_PROMPT
          .replace('{problems_block}', grp.problems.join('\n'))
          .replace('{verification}', verification),
        { label: `${grp.name}-Score`, phase: 'Score' }
      ),
    )
  })
)

// Return by group
const output = {}
groups.forEach((g, i) => output[g.name] = results[i][0])
return output

run workflow math-problems

Workflow({ name: 'math-problems' })

run workflow math-problems, 8 problems divided into 4 groups:
12×15, √144+3², 2^10, trailing zeros of 100!,
1+2+...+100, sin30°×cos60°, log₂1024, 1/2+1/3+1/6

Workflow({
  name: 'math-problems',
  args: {
    groups: [
      { name: 'Group 1', problems: ['1. 12×15', '2. √144+3²'] },
      { name: 'Group 2', problems: ['3. 2^10', '4. trailing zeros of 100!'] },
      { name: 'Group 3', problems: ['5. 1+2+...+100', '6. sin30°×cos60°'] },
      { name: 'Group 4', problems: ['7. log₂1024', '8. 1/2+1/3+1/6'] },
    ]
  }
})

run workflow math-problems, divided into 2 groups:
Geometry: Find the area of a circle with radius 5, find the volume of a cube with side length 3
Algebra: Solve x²-4=0, find x for 3x+2=14

Workflow({
  name: 'math-problems',
  args: {
    groups: [
      { name: 'Geometry', problems: ['Find the area of a circle with radius 5', 'Find the volume of a cube with side length 3'] },
      { name: 'Algebra', problems: ['Solve x²-4=0', 'Find x for 3x+2=14'] },
    ]
  }
})

// ─── Prompt Templates (Defined at the top, clear view of all agents) ──────────

const SOLVER_PROMPT = `You are a math problem-solving expert. Please solve the following math problems one by one.

{problems_block}

Output format (per problem):
- Problem: {Original problem}
- Solution process: {Step-by-step derivation}
- Answer: {Final result}`

const VERIFIER_PROMPT = `You are a math verification expert. Independently re-solve the problems and compare them with the solutions below.

{problems_block}

=== Solutions to Verify ===
{solution}

=== Requirements ===
- Calculate independently; do not trust the provided solutions.
- Compare step-by-step and mark as correct or incorrect.

Output format:
- Judgment: ✅ Correct / ❌ Incorrect
- Reason for error: {If any}`

const SCORER_PROMPT = `You are a math scoring expert. Score based on the solutions and verification results.

{problems_block}

=== Verification Results ===
{verification}

Scoring: 10=Perfect | 7-9=Correct but improvable | 4-6=Partially correct | 0-3=Incorrect

Output format:
- Score: {0-10}
- Comment: {One sentence}`
// ─── End of Templates ─────────────────────────────────────────

// Use .replace() in the pipeline to fill data into templates
pipeline(
  [group],  // Entire group of data
  // Stage 1: Solve
  (grp) => agent(
    SOLVER_PROMPT.replace('{problems_block}', grp.problems.join('\n')),
    { label: `${grp.name}-Solve`, phase: 'Solve' }
  ),
  // Stage 2: Verify (solution is the output of the previous stage)
  (solution, grp) => agent(
    VERIFIER_PROMPT
      .replace('{problems_block}', grp.problems.join('\n'))
      .replace('{solution}', solution),
    { label: `${grp.name}-Verify`, phase: 'Verify' }
  ),
  // Stage 3: Score (verification is the output of the previous stage)
  (verification, grp) => agent(
    SCORER_PROMPT
      .replace('{problems_block}', grp.problems.join('\n'))
      .replace('{verification}', verification),
    { label: `${grp.name}-Score`, phase: 'Score' }
  ),
)

claude, claude-code-guide, Explore, general-purpose, Plan
gsd-*, glm-plan-usage:usage-query-agent, statusline-setup

export const meta = {
  name: 'my-workflow',
  description: 'Description',
  phases: [{ title: 'Phase1' }, { title: 'Phase2' }],
}

// 1. Prompt Templates (Defined at the top, {placeholder} marks data positions)
const AGENT_PROMPT = `You are an expert.

{data_block}

Please process the above data as required.`

// 2. Data Grouping (Defined directly, easy for beginners to understand at a glance)
const DEFAULT_GROUPS = [
  { name: 'Group A', items: ['Data 1', 'Data 2'] },
  { name: 'Group B', items: ['Data 3', 'Data 4'] },
]

const groups = (args && args.groups) || DEFAULT_GROUPS

// 3. Orchestration: Parallel per group, pipeline within group
const results = await parallel(
  groups.map(group => () => pipeline(
    [group],
    (grp) => agent(
      AGENT_PROMPT.replace('{data_block}', grp.items.join('\n')),
      { label: `${grp.name}-Stage 1`, phase: 'Phase1' }
    ),
    (prev, grp) => agent(
      'Further process based on the result:\n' + prev,
      { label: `${grp.name}-Stage 2`, phase: 'Phase2' }
    ),
  ))
)

// 4. Return by group
const output = {}
groups.forEach((g, i) => output[g.name] = results[i][0])
return output