Meerdere AI-agents orkestreren

Waarom orkestratie?

Een enkele agent met veel tools wordt snel inefficient: het model moet kiezen uit tientallen opties, de context groeit snel en gespecialiseerde kennis verdunt. Orkestratie splitst een complex systeem op in gespecialiseerde agents die elk uitblinken in hun eigen domein.

Architectuurpatronen

Er zijn drie patronen die je in de praktijk het vaakst tegenkomt. Kies op basis van hoe de taken zich tot elkaar verhouden.

Orchestrator implementeren

De orchestrator krijgt voor elke sub-agent een delegate_to_*-tool. Het model kiest zelf welke agent het inzet en geeft een taak plus context mee.

const subAgents = {
  research: new ResearchAgent(),
  writer: new WriterAgent(),
  reviewer: new ReviewerAgent(),
};

const orchestratorTools: Anthropic.Tool[] = Object.entries(subAgents).map(([name, agent]) => ({
  name: `delegate_to_${name}`,
  description: agent.description,
  input_schema: {
    type: "object" as const,
    properties: {
      task: { type: "string", description: "De taak die de sub-agent moet uitvoeren" },
      context: { type: "string", description: "Relevante context voor de sub-agent" },
    },
    required: ["task"],
  },
}));

async function orchestrate(userTask: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userTask },
  ];

  const ORCHESTRATOR_SYSTEM = `Je bent een orchestrator die complexe taken verdeelt over gespecialiseerde agents.
Analyseer de taak, splits hem op in subtaken en delegeer elke subtaak aan de meest geschikte agent.
Combineer de resultaten tot een coherent eindantwoord.`;

  while (true) {
    const response = await anthropic.messages.create({
      model: "claude-opus-4-8",
      max_tokens: 4096,
      system: ORCHESTRATOR_SYSTEM,
      tools: orchestratorTools,
      messages,
    });

    if (response.stop_reason === "end_turn") {
      return extractText(response);
    }

    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") continue;
      const agentName = block.name.replace("delegate_to_", "");
      const agent = subAgents[agentName as keyof typeof subAgents];
      const result = await agent.execute(block.input.task as string, block.input.context as string);
      toolResults.push({ type: "tool_result", tool_use_id: block.id, content: result });
    }

    messages.push({ role: "assistant", content: response.content });
    messages.push({ role: "user", content: toolResults });
  }
}

Sub-agents met gespecialiseerde tools

Elke sub-agent krijgt zijn eigen system-prompt en eigen set tools. De description is belangrijk: de orchestrator gebruikt die tekst om te beslissen welke agent past, dus maak hem concreet.

class ResearchAgent {
  description = "Verzamelt informatie via web-zoekopdrachten en document-analyse. Gebruik voor feitenverzameling, marktonderzoek en technische documentatie.";

  async execute(task: string, context?: string): Promise<string> {
    return reactAgent(task, researchTools, RESEARCH_SYSTEM_PROMPT, context);
  }
}

class WriterAgent {
  description = "Schrijft en formatteert content: rapporten, e-mails, samenvattingen en presentaties. Gebruik nadat onderzoek is afgerond.";

  async execute(task: string, context?: string): Promise<string> {
    return reactAgent(task, writingTools, WRITER_SYSTEM_PROMPT, context);
  }
}

Parallelle uitvoering met afhankelijkheden

Zijn subtaken onafhankelijk, voer ze dan parallel uit. Hebben ze afhankelijkheden, modelleer die dan als een gerichte acyclische graaf (DAG): elke taak draait pas als alle taken waarvan hij afhangt klaar zijn.

async function parallelOrchestrate(tasks: DelegatedTask[]): Promise<Map<string, string>> {
  const results = new Map<string, string>();
  let remaining = [...tasks];

  while (remaining.length > 0) {
    const ready = remaining.filter(t => t.depends_on.every(dep => results.has(dep)));
    if (ready.length === 0) throw new Error("Circulaire afhankelijkheid gedetecteerd");

    const batch = await Promise.all(
      ready.map(async (t) => {
        const context = t.depends_on.map(dep => results.get(dep)).join("

");
        const result = await subAgents[t.agent].execute(t.task, context);
        return { id: t.id, result };
      })
    );
    batch.forEach(({ id, result }) => results.set(id, result));

    remaining = remaining.filter(t => !ready.includes(t));
  }

  return results;
}

In elke ronde draaien alle taken die klaarstaan tegelijk via Promise.all. Daarna schuift de lus door naar de volgende laag van de graaf. Raakt er een ronde waarin niets klaarstaat, dan zit er een cyclus in je afhankelijkheden en gooit de code een fout.

Foutafhandeling en retry

Sub-agents falen soms: een tool geeft een time-out, een API geeft een tijdelijke fout. Vang dat op met een retry met exponentiele backoff, zodat een tijdelijke hapering de hele orchestratie niet onderuit haalt.

async function executeWithRetry(
  agent: SubAgent,
  task: string,
  context: string,
  maxRetries = 2
): Promise<string> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await agent.execute(task, context);
    } catch (err) {
      if (attempt === maxRetries) {
        return `Sub-agent mislukt na ${maxRetries + 1} pogingen: ${err instanceof Error ? err.message : String(err)}`;
      }
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
    }
  }
  return "";
}

Kosten en monitoring

Orkestratie vermenigvuldigt het aantal model-aanroepen, dus hou je verbruik in de gaten. Log per sub-agent-aanroep het aantal input- en output-tokens en aggregeer dat per orchestrator-run. Stel per agent-type een budget in en breek af zodra dat overschreden wordt. Zo zie je meteen welke specialist de meeste kosten veroorzaakt.