Agent orchestration patterns

An agent orchestration pattern wires several agents together, each running in its own context with one focused goal.

The six patterns below come from the Claude Code dynamic-workflows writeup.¹ Each one pairs a diagram with a TypeScript sketch.

The sketches use two primitives: agent(prompt, opts) spawns one agent and returns its output, and parallel(fns) runs several at once and waits for all. Structured output is declared with a Zod schema and comes back typed.

---

Classify and act

A classifier agent reads the task and routes it to one of several specialized agents. A focused agent on a clean context handles its case better than one generalist that classifies and executes in the same window.

                   ┌──→ agent A
task ──→ classifier├──→ agent B
                   └──→ agent C

const Triage = z.object({ kind: z.enum(["bug", "feature", "question"]) })

const { kind } = await agent(`Classify this task: ${task}`, { schema: Triage })

const route = { bug: "debugger", feature: "builder", question: "explainer" }
const result = await agent(task, { agentType: route[kind] })

---

Fan out and synthesize

Split a task into independent subtasks, run an agent on each in parallel, then let a synthesize agent merge their outputs.

Each subtask keeps a clean context so results don't cross-contaminate, and the synthesize step is a barrier that waits for all of them.

       ┌─→ agent ─┐
task ──┼─→ agent ─┼──→ synthesize ──→ result
       └─→ agent ─┘
       barrier: waits for all

const Plan = z.object({ subtasks: z.array(z.string()) })

const { subtasks } = await agent(`Break this into independent parts: ${task}`, { schema: Plan })

const partials = await parallel(
  subtasks.map(s => () => agent(`Handle one part: ${s}`)),
)

const result = await agent(`Synthesize these into one result:\n${partials.join("\n\n")}`)

---

Adversarial verification

A worker agent's output goes to a panel of verifier agents, each checking it against one rule of the rubric.

A separate agent has no stake in the output, so it catches faults the worker misses, since an agent grading its own work in one context tends to favor it.

                ┌─→ verifier ─┐
worker ─output─→┼─→ verifier ─┼─→ verdicts ─→ pass / fix
                └─→ verifier ─┘
                  (vs. rubric)

const Verdict = z.object({ issues: z.array(z.string()) })

const rubric = [
  "every error is handled, never swallowed",
  "no hard-coded secrets",
  "public functions have explicit types",
]

const output = await agent(task)
const verdicts = await parallel(
  rubric.map(rule => () =>
    agent(`Check this output against one rule. List violations.\nRule: ${rule}\n\n${output}`, {
      schema: Verdict,
      agentType: "skeptic",
    })),
)

const issues = verdicts.flatMap(v => v.issues)
const final = issues.length === 0
  ? output
  : await agent(`Revise to fix these issues:\n${issues.join("\n")}\n\n${output}`)

---

Generate and filter

Several generator agents produce candidate ideas, then a filter agent scores them against a rubric, drops duplicates, and keeps the best.

Generating wide and judging separately beats asking one agent to both invent and critique at once.

generator ─┐
generator ─┼─→ ideas ──→ filter (rubric + dedupe) ──→ best
generator ─┘                                      └──→ discarded

const Ideas = z.object({ ideas: z.array(z.string()) })
const Best = z.object({ best: z.array(z.string()) })

const angles = ["conservative", "novel", "minimal"]

const batches = await parallel(
  angles.map(angle => () =>
    agent(`Brainstorm options for this task, ${angle} angle: ${task}`, { schema: Ideas })),
)
const ideas = batches.flatMap(b => b.ideas)

const { best } = await agent(
  `Rank these by the rubric, drop duplicates, keep the top 3:\n${ideas.join("\n")}`,
  { schema: Best },
)

---

Tournament

Spawn several agents that each attempt the same task a different way, then have judge agents compare them two at a time until one is left.

Pairwise comparison is more reliable than absolute scoring, and the bracket picks a winner from a field too large to compare in one context.

attempt ─┐
         ├─→ judge ─┐
attempt ─┘          │
                    ├─→ judge ──→ winner
attempt ─┐          │
         ├─→ judge ─┘
attempt ─┘

const approaches = ["brute force", "greedy", "dynamic programming", "divide and conquer"]

let bracket = await parallel(
  approaches.map(a => () => agent(`Solve this task with a ${a} approach: ${task}`)),
)

while (bracket.length > 1) {
  const matches = []
  for (let i = 0; i < bracket.length; i += 2) {
    const [x, y] = [bracket[i], bracket[i + 1]]
    matches.push(() => agent(`Return the better of these two:\n${x}\n---\n${y}`))
  }
  bracket = await parallel(matches)
}

const winner = bracket[0]

---

Loop until done

Spawn an agent, check a stop condition, then spawn another until the condition holds.

An external condition like "no new findings" handles work of unknown size, instead of letting the agent decide for itself when it's done.

       ┌─────────────┐
       ▼             │
     agent           │ yes
       │             │
       ▼             │
  new findings? ─────┘
       │
       │ no
       ▼
     done

const Round = z.object({ newFindings: z.array(z.string()) })

const findings: string[] = []
while (true) {
  const { newFindings } = await agent(`Investigate further. Known so far:\n${findings.join("\n")}`, {
    schema: Round,
  })
  if (newFindings.length === 0) break
  findings.push(...newFindings)
}

---