Multi-agent systemen bouwen

Van enkelvoudige naar multi-agent systemen

Een enkelvoudige agent met veel tools schaalt slecht: de context groeit, het model raakt afgeleid en er is geen specialisatie. Multi-agent systemen lossen dit op door taken te verdelen over gespecialiseerde agents die samenwerken.

Het verschil met orkestratie zit in de mate van autonomie. Bij orkestratie stuurt een centrale orchestrator alle agents aan. In een echt multi-agent systeem communiceren agents ook met elkaar, handelen ze deels autonoom en delen ze geheugen.

Welke topologie kies je

In de praktijk van 2026 domineren drie patronen. Kies bewust en houd het zo simpel mogelijk.

Dit artikel werkt het supervisor-patroon uit, omdat dat het beste te bewaken en te debuggen is.

Systeem-architectuur

De opzet bestaat uit een supervisor die drie workers aanstuurt (research, schrijven, review), met daaronder een gedeeld geheugen dat alle agents kunnen lezen en schrijven.

• Supervisor: maakt het plan, deelt stappen uit, bewaakt timeouts en voegt het eindresultaat samen.
• Research-agent: verzamelt en verifieert informatie, schrijft tussenresultaten naar het geheugen.
• Writer-agent: stelt de output op met de research uit het geheugen als context.
• Reviewer-agent: controleert de output en kan om correcties vragen.
• Gedeeld geheugen: een vector store voor semantisch zoeken plus een sleutel-waarde store voor tussenresultaten.

Message bus implementeren

De message bus is de ruggengraat. Alle berichten lopen hierlangs, zodat je elke taak achteraf kunt volgen.

type MessageHandler = (message: AgentMessage) => Promise<void>;

class AgentMessageBus {
  private handlers = new Map<string, MessageHandler[]>();
  private messageLog: AgentMessage[] = [];

  subscribe(agentId: string, handler: MessageHandler): void {
    const existing = this.handlers.get(agentId) ?? [];
    this.handlers.set(agentId, [...existing, handler]);
  }

  async publish(message: AgentMessage): Promise<void> {
    this.messageLog.push({ ...message, timestamp: new Date().toISOString() });
    const handlers = this.handlers.get(message.to) ?? [];
    await Promise.all(handlers.map(h => h(message)));
  }

  getLog(): AgentMessage[] {
    return [...this.messageLog];
  }
}

interface AgentMessage {
  id: string;
  from: string;
  to: string;
  type: "task" | "result" | "error" | "query";
  payload: Record<string, unknown>;
  timestamp?: string;
}

Gedeeld geheugen

Het geheugen scheidt vluchtige tussenresultaten (sleutel-waarde) van herbruikbare kennis (vectoren). Elke schrijfactie legt vast welke agent de eigenaar is, wat helpt bij debuggen en bij conflictdetectie.

class SharedAgentMemory {
  private kvStore = new Map<string, { value: unknown; owner: string; timestamp: string }>();
  private vectorStore: VectorStore;

  async write(key: string, value: unknown, agentId: string): Promise<void> {
    this.kvStore.set(key, { value, owner: agentId, timestamp: new Date().toISOString() });
  }

  read(key: string): unknown {
    return this.kvStore.get(key)?.value;
  }

  async storeEmbedding(content: string, metadata: Record<string, unknown>, agentId: string): Promise<void> {
    await this.vectorStore.upsert({ content, metadata: { ...metadata, agent_id: agentId } });
  }

  async queryEmbeddings(query: string, limit = 5): Promise<SearchResult[]> {
    return this.vectorStore.search(query, limit);
  }
}

Supervisor-agent

De supervisor maakt een plan, voert de stappen in volgorde uit, geeft elke stap een timeout en herstelt waar mogelijk van fouten. Resultaten van eerdere stappen komen als context bij de volgende stap binnen.

class SupervisorAgent {
  private activeAgents = new Map<string, AgentStatus>();

  async supervise(goal: string, agents: Record<string, WorkerAgent>): Promise<string> {
    const plan = await this.createPlan(goal, Object.keys(agents));

    for (const step of plan.steps) {
      const agent = agents[step.agent];
      if (!agent) throw new Error(`Agent ${step.agent} niet gevonden`);

      this.activeAgents.set(step.id, { status: "running", start: Date.now() });

      try {
        const context = step.depends_on
          .map(dep => sharedMemory.read(`result:${dep}`) as string)
          .join("

");

        const result = await Promise.race([
          agent.execute(step.task, context),
          this.timeout(step.timeout_ms ?? 30000, step.id),
        ]);

        await sharedMemory.write(`result:${step.id}`, result, step.agent);
        this.activeAgents.set(step.id, { status: "done", start: Date.now() });
      } catch (err) {
        this.activeAgents.set(step.id, { status: "failed", start: Date.now() });
        const recovery = await this.handleFailure(step, err);
        if (!recovery) throw err;
      }
    }

    return await this.synthesize(goal, plan.steps);
  }

  private timeout(ms: number, stepId: string): Promise<never> {
    return new Promise((_, reject) =>
      setTimeout(() => reject(new Error(`Stap ${stepId} timed out na ${ms}ms`)), ms)
    );
  }
}

Communicatie tussen agents

Naast de top-down aansturing kunnen agents elkaar bevragen via de bus. Een worker abonneert zich op zijn eigen ID en beantwoordt binnenkomende queries.

class WorkerAgent {
  constructor(
    private id: string,
    private bus: AgentMessageBus,
    private memory: SharedAgentMemory,
    private tools: AgentTool[]
  ) {
    bus.subscribe(id, this.handleMessage.bind(this));
  }

  private async handleMessage(message: AgentMessage): Promise<void> {
    if (message.type === "query") {
      const result = await this.executeQuery(message.payload.query as string);
      await this.bus.publish({
        id: crypto.randomUUID(),
        from: this.id,
        to: message.from,
        type: "result",
        payload: { result, query_id: message.id },
      });
    }
  }

  async execute(task: string, context: string): Promise<string> {
    return reactAgent(task, this.tools, this.buildSystemPrompt(), context);
  }
}

Stappenplan voor een eerste systeem

Bestaande frameworks of zelf bouwen

In juni 2026 zijn LangGraph en CrewAI de meest gebruikte keuzes, naast AutoGen (AG2) en de OpenAI Agents SDK. LangGraph is de standaard voor stateful, controleerbare workflows met trace-niveau observability. CrewAI is de snelste weg naar een werkend prototype met een rol- en taakmetafoor en native ondersteuning voor MCP en het A2A-protocol (Agent-to-Agent). Bouw je zelf, dan houd je maximale controle en begrijp je precies wat er onder de motorkap gebeurt, maar je betaalt dat met meer eigen onderhoud.