AI-workflows bouwen met multi-agent frameworks

De meeste ontwikkelaars die AI-agents willen bouwen, beginnen met één grote taalmodellus — een systeemprompt en misschien een tool — en voor kleine taken is dat vaak voldoende.

Maar zodra je structuur wilt, begint het systeem te rafelen. Uitkomsten worden onvoorspelbaar, workflows zijn lastig te debuggen en je verspilt tokens aan herhaling in plaats van vooruitgang.

Met multi-agent workflows kun je AI-agents bouwen die meer werken als een team met duidelijke rollen en inzicht in hoe beslissingen worden genomen en samen naar hetzelfde doel toewerken.

Wat is een Multi-Agent Framework?

Een multi-agent framework is de infrastructuur waarmee je meerdere AI-agents gecoördineerd bouwt, uitvoert en beheert.

Het is de infrastructuur die regelt hoe agents communiceren en hoe taken tussen hen worden overgedragen.

Als je werkt met multi-agent systemen, is het framework wat ze operationeel maakt.

In de kern verandert het ruwe large language models (LLMs) in afgebakende agents, elk met een eigen rol en voorspelbare werkwijze.

In plaats van orkestratielogica vanaf nul te schrijven, biedt het framework structuur, controle en herhaalbaarheid.

Multi-Agent Frameworks: Belangrijke Concepten

Hoe werken Multi-Agent Frameworks?

Multi-agent frameworks geven structuur aan hoe agents worden geactiveerd, hoe ze data doorgeven en hoe het systeem de voortgang bijhoudt.

Ze bieden de bouwstenen om agents te coördineren op een manier die meegroeit met de complexiteit en geschikt is voor echte toepassingen.

Een voorbeeld is het gebruik van een multi-agent setup voor een WhatsApp-chatbot. In dit geval kunnen verschillende agents taken afhandelen zoals boekingen, terugbetalingen of verificatie, en werken ze samen achter de schermen zonder afhankelijk te zijn van één monolithische bot.

Agents worden geregistreerd als oproepbare componenten in het systeem

Voordat een agent iets kan doen, moet het framework weten dat deze bestaat. Dit betekent dat je het systeem vertelt wat de naam van de agent is, waar deze verantwoordelijk voor is en welke tools of informatie deze kan gebruiken.

In de meeste frameworks gebeurt deze setup via een configuratiebestand of code, waarin je de rol van elke agent en de activering ervan definieert. Bijvoorbeeld:

“Dit is de planner. Hij leest gebruikersinvoer en beslist wat er daarna moet gebeuren.”
“Dit is de verifier. Hij neemt gebruikersinformatie en geeft booking_id en gebruikersinformatie terug.”

Eenmaal geregistreerd kan het framework deze agents “oproepen” op naam, wat betekent dat het weet hoe elke agent moet worden uitgevoerd wanneer deze aan de beurt is in de workflow.

De routeringsagent bepaalt welke agent hierna wordt uitgevoerd

Een planner-agent of controllerfunctie verzorgt de AI-agent routering. Deze kijkt naar de laatste bot-uitvoer, de huidige gespreksgeschiedenis en soms de oorspronkelijke gebruikersinvoer om te bepalen wat er moet gebeuren.

Sommige planners zijn prompt-gebaseerd — ze nemen een systeembericht en geven de naam van de volgende agent die moet draaien.

Andere gebruiken hardcoded logica of flow-diagrammen, afhankelijk van de AI-agent frameworks waarmee je werkt.

Het framework gebruikt die uitvoer om de volgende agent aan te roepen. De router bepaalt wie de taak uitvoert, niet de taak zelf.

Data wordt tussen agents doorgegeven via berichten

Agents delen geen geheugen direct. Wanneer een agent klaar is, wordt de uitvoer verpakt in een bericht — meestal een dictionary of JSON-object — en als invoer aan de volgende agent doorgegeven.

Het framework regelt deze overdracht. Het slaat het bericht op in een gedeelde geheugenruimte of geeft het direct door aan de invoerinterface van de volgende agent, afhankelijk van de systeemstructuur.

Berichten bevatten vaak meer dan alleen de inhoud:

• Wie het heeft verzonden (agent of gebruiker)
• Waar het vandaan komt in de workflow
• Hoe het gebruikt moet worden (bijv. trigger, invoer, beslissing)
• Optionele statistieken zoals tokenaantal of tijdstempels

Deze context helpt het systeem taken netjes te routeren en houdt agents losgekoppeld van elkaar.

Uitvoering wordt gevolgd via workflowstatus en triggers

Het framework houdt bij wat er tot nu toe is gebeurd — welke agents zijn uitgevoerd, wat ze hebben teruggegeven en wat er nog moet gebeuren. Dit wordt opgeslagen in een statusobject dat na elke stap wordt bijgewerkt.

Triggers bepalen wat er daarna gebeurt. Ze gebruiken uitvoerwaarden of condities om de flow te laten vertakken.

Hierdoor kan het systeem verdergaan zonder logica in elke agent te hardcoderen. De status stuurt de workflow aan, niet de agents zelf.

Belangrijkste Voordelen van het Gebruik van Multi-Agent Frameworks

Schaal logica zonder één agent te overbelasten

Eén AI-agent kan maar zoveel aan voordat het een wirwar wordt van prompts, tools en onduidelijke verantwoordelijkheden. Multi-agent frameworks laten je die logica opsplitsen in gerichte agents, elk met een duidelijke taak.

In plaats van één agent te overbelasten, kun je specifieke stappen — zoals ophalen, valideren of uitvoeren — aan aparte agents toewijzen en het systeem stap voor stap uitbreiden.

Debug samenwerking tussen agents met volledige zichtbaarheid

Wanneer AI-agents samenwerken, zijn problemen soms lastig te traceren. Frameworks laten zien wat elke agent ontving, wat hij teruggaf en waar het vastliep.

Je hoeft niet te raden wat er misging — je bekijkt de overdrachten en lost het direct op. Dit soort inzicht maakt samenwerking tussen AI-agents beheersbaar.

Herbruik agents in verschillende workflows

Als een agent werkt, hergebruik hem dan. Frameworks laten je dezelfde agent in verschillende flows inzetten zonder hem opnieuw te schrijven. Dat houdt alles consistent en versnelt het testen.

Een validatie-agent die gebruikersinvoer of authenticatie controleert, kun je bijvoorbeeld inzetten in zowel klantenservice-chatbots als boekingschatbots, overal waar dezelfde logica geldt.

Handel fouten en herhalingen automatisch af

Als een agent faalt, kan het framework opnieuw proberen, overslaan of doorgaan. Je hoeft die logica niet zelf te schrijven.

Ingebouwde fallback maakt workflows betrouwbaarder zonder extra werk, en die betrouwbaarheid is essentieel voor echte systemen.

Bouw agent-flows die makkelijk aan te passen zijn

Als je taken over agents verdeelt, hoef je niet het hele systeem te herzien bij elke wijziging.

Je kunt een planner aanpassen zonder de uitvoering te wijzigen, of het gedrag van één agent veranderen zonder de rest te herschrijven.

Die flexibiliteit loont — Salesforce meldt dat teams die agentic AI gebruiken wekelijks 11 uur per medewerker besparen, mede dankzij de aanpasbaarheid van de workflows.

Top 5 Multi-Agent Frameworks

De keuze voor een multi-agent framework hangt af van wat je bouwt en hoeveel controle je wilt over het gedrag, de communicatie en het herstel van agents bij fouten.

De beste frameworks bieden verschillende afwegingen — sommige zijn ideaal voor gestructureerde workflows, andere geven meer flexibiliteit ten koste van duidelijkheid.

Je wilt iets dat past bij de behoeften van je team en bij hoe ver je het systeem wilt ontwikkelen.

1. Botpress

Botpress is een visueel ontwikkelplatform voor het bouwen van AI-agents die kunnen coördineren over stappen, rollen en kanalen.

In plaats van logica in code te schrijven, definieer je het gedrag van agents met flows, geheugen, condities en tool-aanroepen.

Multi-agent gedrag is opgebouwd rond instructies, workflows en externe tools. Elke node in een Botpress-flow fungeert als een gerichte eenheid met eigen instructies en scope.

Je kunt redenering verdelen over meerdere Autonome en Statische Nodes, validatielagen toevoegen of gebruikersinvoer routeren via tool-gebaseerde beslislogica in plaats van alles in één stap af te handelen.

Geheugen is afgebakend per flow, dus agents gebruiken alleen wat ze nodig hebben. Invoer en uitvoer zijn duidelijk gedefinieerd en tool-aanroepen kunnen direct worden toegevoegd via ingebouwde integraties.

Belangrijkste functies

• Visuele agent-orkestratie met flows en nodes
• Afgebakend geheugen en variabelenbeheer tussen nodes
• Geheugen over meerdere beurten, fallback-logica en herhalingen
• Toolgebruik via API-aanroepen, webhooks en functie-invoer

2. LangChain

LangChain is een framework gericht op ontwikkelaars voor het bouwen van LLM-gestuurde applicaties door ketens van prompts, tools en geheugen samen te stellen.

Het begon als een manier om LLM-aanroepen te structureren met tools zoals zoeken en rekenmachines, maar groeide uit tot een uitgebreid ecosysteem.

De ene release richtte zich op “agents”, daarna “assistants”, vervolgens “runnables”. Het resultaat is een krachtig pakket dat bijna alles kan, maar het kost vaak tijd om je weg te vinden.

Je kunt toolkits toewijzen en routeringslogica bouwen over agents heen. De kracht zit in de modulariteit — componenten zijn herbruikbaar, combineerbaar en goed geïntegreerd met externe API's.

Maar je schrijft meer verbindingscode dan je verwacht. En omdat de abstracties snel veranderen, is het verstandig te controleren of de methode die je gebruikt nog steeds de voorkeur heeft.

Belangrijkste functies

• Modulair schakelen van prompts, tools en geheugen
• Integreert met LLMs, vector stores en API's
• Optionele tracing en evaluaties met LangSmith

3. CrewAI

CrewAI maakt het eenvoudig om multi-agent workflows te bouwen waarbij elke agent een duidelijke rol en taak heeft. Je maakt een team, wijst doelen toe en de agents coördineren via een gedeelde manager.

Het is een van de snelste manieren om samenwerking tussen agents te modelleren zonder orkestratielogica vanaf nul te schrijven.

Ideaal voor setups zoals planner–executor-paren, onderzoek–reviewer flows, of elk teamgebaseerd proces waarbij verantwoordelijkheden duidelijk zijn gescheiden.

Maar zodra je meer complexiteit toevoegt, wordt de abstractie beperkend. Er is minder flexibiliteit in hoe en wanneer agents draaien, en gedrag aanpassen betekent vaak buiten de standaardinstellingen van het framework treden.

Belangrijkste functies

• Agent-setup op basis van rollen met namen, doelen en geheugen
• Ondersteunt sequentiële en parallelle uitvoering van agents
• Gedeeld teamgeheugen voor samenwerking tussen agents
• Eenvoudige integratie met tools, functies en aangepaste prompts

4. AutoGPT

AutoGPT was het eerste project dat liet zien wat er gebeurt als je een GPT-chatbot een doel geeft en hem laat draaien — plannen, denken, onderzoeken en uitvoeren zonder constante menselijke input.

Je definieert het doel, en AutoGPT doorloopt redeneerstappen, maakt subdoelen, roept tools aan en past onderweg zijn strategie aan.

Het was een grote stap om agentgedrag autonoom en dynamisch te laten aanvoelen. Maar het is niet gebouwd voor precisie.

De taaklus is kwetsbaar, en agents blijven vaak hangen in het herschrijven van hetzelfde plan of het najagen van irrelevante subtaken.

Je kunt geheugen, tools en API's koppelen — maar alles samenvoegen leidt vaak tot onvoorspelbare flows die lastig te debuggen of te sturen zijn.

Belangrijkste functies

• Doelgerichte agent met zelfprompting en taakplanning
• Automatische subtaakgeneratie en uitvoeringslus
• Ondersteunt toolgebruik via plugins en API-aanroepen
• Uitbreidbaar met aangepaste scripts, functies en integraties

5. Autogen

Autogen is een open-source framework van Microsoft dat zich richt op multi-agent gesprekken, waarbij agents via gestructureerde, beurtgebaseerde berichten interacteren.

Het is vooral geschikt als je controle wilt over elke uitwisseling, zoals in planning–uitvoeringslussen of human-in-the-loop systemen.

Autogen blinkt uit in transparantie. Je kunt functies injecteren tijdens het gesprek, beslissingen routeren via aangepaste logica en precies traceren wat elke agent zei en waarom.

Maar opschalen kost moeite. Berichtorchestratie is flexibel, maar niet geabstraheerd — je beheert nog steeds zelf de geschiedenissen, agentconfiguraties en staplogica.

Voor onderzoeksopstellingen, gecontroleerde tests of reproduceerbaar agentgedrag is het een van de meest precieze frameworks die er zijn.

Belangrijkste functies

• Framework voor beurtgebaseerde communicatie tussen meerdere agents
• Ondersteunt human-in-the-loop en agents die functies aanroepen
• Transparante berichttracering en mogelijkheid tot het injecteren van eigen logica

Hoe bouw je met een Multi-Agent Framework

De makkelijkste manier om te beginnen is door één echte workflow te kiezen — iets dat al te complex is voor één enkele agent — en dit op te splitsen in een paar eenvoudige onderdelen.

Denk aan een leadgeneratie-chatbot, een boekingsflow, of elk scenario waar logica, verificatie en acties door elkaar lopen.

Geef elke stap een eigen agent en verbind ze vervolgens met de routerings- en berichttools van het framework.

Stap 1: Bepaal waar je single-agent logica tekortschiet

Zoek een plek in je bot of systeem waar het uit de hand begint te lopen — lange prompts of aaneengeschakelde tool-aanroepen die als een noodoplossing aanvoelen. Dat is je startpunt. Hier zijn enkele veelvoorkomende voorbeelden die makkelijk te herkennen zijn:

1. Een terugbetalingsflow die gebruikersinvoer verwerkt, de geschiktheid controleert, de terugbetaling uitvoert en een bevestiging stuurt — allemaal in één lus
2. Een onboardingproces dat gegevens verzamelt, formulieren valideert, gebruikerscategorieën toewijst en e-mails verstuurt in één enkele promptketen

In plaats van het hele systeem opnieuw te ontwerpen, isoleer je alleen de workflow die nu al problemen vertoont.

Stap 2: Definieer rollen voordat je het framework gebruikt

Zodra je de rommelige logica hebt gevonden, splits je deze op in echte verantwoordelijkheden.

Als iets invoer valideert, is dat één agent. Als iets een externe actie uitvoert, is dat een andere.

Schrijf het uit in gewone taal — net genoeg om duidelijk te maken waar de overdrachten plaatsvinden.

En als alles voor je ligt, zie je wat echt gescheiden moet worden en wat samengevoegd kan blijven. Dit helpt je ook te bepalen welk type framework je nodig hebt.

Elke rol moet klinken als iets dat je apart zou kunnen testen.

Stap 3: Kies het framework

Kies een platform dat past bij jouw workflowstijl.

• Visueel: Botpress, als je node-gebaseerde flows en afgebakend geheugen wilt.
• Code-first: LangChain of CrewAI als je graag logica in Python programmeert.

Het framework bepaalt hoe agents worden geregistreerd, geactiveerd en verbonden.

Stap 4: Bouw de eerste workflow

Zet deze rollen nu om in agents. Definieer ze binnen je framework — geef elk een naam, een taak en de benodigde toegang tot tools of API’s.

Als ze klaarstaan, verbind je ze. Gebruik de routering die het framework biedt om van de ene agent naar de andere te gaan.

Het doel is om één complete workflow van begin tot eind te laten draaien, waarbij elke agent zich aan zijn taak houdt.

Stap 5: Draai het systeem en controleer elke overdracht

Start de volledige workflow — van begin tot eind — en volg wat er gebeurt. Kijk wat elke agent ontvangt, wat hij teruggeeft en of de flow soepel tussen de agents verloopt.

Als een agent verwarde input krijgt, heb je waarschijnlijk de scope verkeerd bepaald. Als de logica onverwacht springt, moet je de routering aanpassen.

Als de overdrachten soepel verlopen, heb je een werkend systeem.

Best Practices voor het Gebruik van Multi-Agent Frameworks

Het kiezen van een framework is slechts het begin. Belangrijker is hoe je de workflows ontwerpt, test en beheert die je ermee bouwt.

Naarmate AI-systemen modularer en autonomer worden, wordt traceerbaarheid lastiger.

Houd de kernlogica centraal

Voorkom dat cruciale beslissingen over meerdere agents worden verspreid. Het is makkelijker te onderhouden en te testen als het belangrijkste denkwerk op één plek gebeurt, in plaats van verdeeld over losse onderdelen.

Bepaal vooraf de input en output van elke agent

Elke agent moet een duidelijk contract hebben — wat hij ontvangt en wat hij teruggeeft. Zo kun je agents makkelijker vervangen of in nieuwe workflows gebruiken zonder de flowlogica te breken.

Log elk bericht dat tussen agents wordt uitgewisseld

Als je niet kunt zien wat agents elkaar sturen, kun je niets debuggen. Zorg dat elke input en output wordt gelogd met voldoende context om het verloop te kunnen volgen.

Gebruik afgebakend geheugen om ruis en kosten te beperken

Geef elke agent alleen de context die nodig is. Volledige geheugentoegang leidt tot opgeblazen prompts, hoger tokenverbruik en onvoorspelbaar gedrag van agents die juist gefocust moesten zijn.

Begin met het bouwen van AI die kan coördineren

De meeste systemen vallen uit elkaar zodra echte coördinatie nodig is. Met Botpress bepaal je zelf hoe agents taken overdragen — met duidelijke rollen en logica kun je testen en begrijpen.

Je kunt ook gegevens netjes tussen flows doorgeven. Je volgt elke stap met logs van meerdere beurten die laten zien welke tool werd aangeroepen, waarom, en hoe deze in de workflow werd gebruikt.

In plaats van prompt tuning en hallucinatiebeheersing focus je op echte functionaliteit — agents bouwen die zich gedragen als software.

Begin vandaag nog met bouwen — het is gratis.

Veelgestelde vragen

Hoe weet ik of mijn AI-project echt een multi-agent framework nodig heeft, of dat één agent voldoende is?

Je AI-project heeft waarschijnlijk een multi-agent framework nodig als de prompts of workflows van je enkele agent te lang of lastig te debuggen zijn, vooral bij meerdere verschillende taken. Voor eenvoudige toepassingen zoals basis Q&A of single-purpose bots is één agent vaak voldoende.

Is bouwen met een multi-agent framework alleen voor grote bedrijven, of is het ook geschikt voor kleine startups?

Bouwen met een multi-agent framework is niet alleen voor grote bedrijven — ook kleine startups profiteren ervan, omdat zelfs bescheiden projecten makkelijker te debuggen zijn als complexe taken verdeeld zijn over gespecialiseerde agents in plaats van alles in één grote, lastig te beheren lus te stoppen.

Betekent werken met een multi-agent systeem dat ik alles moet opsplitsen in aparte agents, of kan ik single- en multi-agent logica combineren?

Werken met een multi-agent systeem betekent niet dat je alles in aparte agents moet splitsen; je kunt single-agent logica gebruiken voor eenvoudige taken en multi-agent orchestratie reserveren voor complexe workflows.

Hoe verschilt een multi-agent systeem van het simpelweg gebruiken van meerdere API’s of microservices in mijn applicatie?

Een multi-agent systeem verschilt van het gebruik van meerdere API’s of microservices doordat het gespecialiseerde AI-agents met eigen rollen en redeneervermogen coördineert, die gestructureerde berichten en status uitwisselen, terwijl API’s en microservices losse functies uitvoeren maar niet zelfstandig complexe workflows aansturen.

Hoe verhouden de kosten van multi-agent systemen zich tot het draaien van één groot LLM?

De kosten van multi-agent systemen kunnen lager uitvallen dan het draaien van één groot LLM, omdat kleinere, gespecialiseerde agents specifieke taken efficiënt afhandelen zonder tokens te verspillen aan lange prompts of herhaalde context. Wel komt er extra overhead bij voor de orchestratie en communicatie tussen agents, dus de besparing hangt af van de complexiteit van je use case.