Eén AI-agent die alles probeert te doen — het klinkt als een goed idee, tot je merkt dat je chatbot tegelijkertijd onderzoek moet doen, data moet analyseren, een rapport moet schrijven én kwaliteitscontrole moet uitvoeren. Het resultaat? Middelmatige output op alle fronten. Herkenbaar? Dan wordt het tijd om kennis te maken met multi-agent systemen.
De verschuiving van monolithische AI-agents naar gespecialiseerde, samenwerkende teams van agents is in 2026 een van de meest impactvolle trends in AI-engineering. Gartner rapporteerde een stijging van meer dan 1.400% in vragen over multi-agent systemen tussen Q1 2024 en Q2 2025. En eerlijk gezegd is dat niet zo gek: net zoals een softwareteam beter presteert wanneer iedereen een duidelijke rol heeft, presteren AI-agents beter wanneer ze gespecialiseerd zijn.
In deze handleiding bouwen we stap voor stap een multi-agent systeem met CrewAI — het populairste open-source framework voor multi-agent orkestratie, met meer dan 100.000 gecertificeerde ontwikkelaars. We beginnen bij de basis en werken toe naar een volledig werkend systeem dat je direct kunt aanpassen voor je eigen projecten.
Wat is een Multi-Agent AI Systeem?
Een multi-agent systeem (MAS) is een architectuur waarin meerdere gespecialiseerde AI-agents samenwerken om complexe taken uit te voeren. In plaats van één overbelaste agent die alles doet, verdeel je het werk over agents die elk een specifieke rol, expertise en set tools hebben.
Ik vergelijk het graag met een marketingbureau. Je hebt een researcher, een copywriter en een eindredacteur. Elk heeft een duidelijke verantwoordelijkheid. De researcher graaft diep in de data, de copywriter transformeert die inzichten naar pakkende tekst, en de eindredacteur polijst het eindresultaat. Niemand doet alles — en dat is precies waarom het werkt.
Hetzelfde principe geldt voor AI-agents. Een multi-agent aanpak biedt je:
- Specialisatie — Elke agent is geoptimaliseerd voor één taak en presteert daar beter in dan een generalist.
- Schaalbaarheid — Je kunt eenvoudig nieuwe agents toevoegen zonder het hele systeem te hertekenen.
- Betrouwbaarheid — Als één agent faalt, kan het systeem alsnog functioneren. Geen single point of failure.
- Betere output — Door taken op te splitsen krijg je gerichtere prompts, minder hallucinaties en hogere kwaliteit.
Waarom CrewAI? Een Vergelijking met Andere Frameworks
Er zijn in 2026 meerdere frameworks voor multi-agent orkestratie. De drie belangrijkste: CrewAI, LangGraph en AutoGen. Maar waarom zou je specifiek voor CrewAI kiezen?
CrewAI is een lichtgewicht, razendsnelle Python-framework dat volledig onafhankelijk is gebouwd — geen LangChain-afhankelijkheid, geen zware abstracties. Het draait om rolgebaseerde multi-agent orkestratie, waarbij je agents definieert met een rol, doel en achtergrondverhaal. Dit maakt het intuïtief en je bent snel productief.
LangGraph is technisch een stuk veeleisender. Het modelleert je workflow als een gerichte graaf met nodes, edges en conditionele logica. Krachtig voor complexe, niet-lineaire workflows, maar de leercurve is aanzienlijk steiler. Ideaal voor enterprise-teams die compliance-gevoelige systemen bouwen.
AutoGen (van Microsoft) focust op conversationele multi-agent patronen en iteratieve verfijning. Sterk in codegeneratie en onderzoeksscenario's, maar minder geschikt voor gestructureerde productie-workflows.
De vuistregel? Begin met CrewAI als je snel productief wilt zijn en denkt in rollen en verantwoordelijkheden. Stap over naar LangGraph wanneer je maximale controle en state management nodig hebt voor missiekritische systemen.
Installatie en Voorbereiding
Oké, laten we aan de slag gaan. Voordat we gaan bouwen, moeten we de ontwikkelomgeving opzetten. CrewAI vereist Python 3.10 tot 3.13.
Stap 1: Installeer CrewAI
# Maak een virtuele omgeving aan
python -m venv crewai-env
source crewai-env/bin/activate # Linux/Mac
# crewai-env\Scripts\activate # Windows
# Installeer CrewAI met tools
pip install crewai crewai-toolsStap 2: Stel je API-sleutel in
CrewAI werkt standaard met OpenAI-modellen, maar je kunt zonder problemen wisselen naar Claude, Gemini of lokale modellen. Stel je API-sleutel in als omgevingsvariabele:
# .env bestand
OPENAI_API_KEY=sk-jouw-api-sleutel-hier
# Of voor Anthropic Claude:
# ANTHROPIC_API_KEY=sk-ant-jouw-sleutel-hier# In je Python-code
import os
from dotenv import load_dotenv
load_dotenv() # Laadt variabelen uit .envStap 3: Verifieer de installatie
python -c "import crewai; print(f'CrewAI versie: {crewai.__version__}')"Als je een versienummer terugkrijgt, ben je klaar om te beginnen.
De Kernconcepten van CrewAI
Voordat we code gaan schrijven, is het handig om de vier bouwstenen van CrewAI te begrijpen. Dit klinkt misschien theoretisch, maar het maakt straks het verschil als je je eigen systeem gaat ontwerpen.
Agents
Een Agent is een autonome eenheid met een specifieke rol, een doel en een achtergrondverhaal (backstory). De rol bepaalt hoe de agent zich gedraagt; het doel geeft richting; de backstory biedt context die het LLM helpt om in karakter te blijven. Die backstory wordt vaak onderschat, maar daar kom ik later op terug.
Tasks
Een Task is een concrete opdracht die aan een agent wordt toegewezen. Elke taak heeft een beschrijving, een verwachte output en optioneel tools die de agent mag gebruiken. Taken kunnen sequentieel of parallel worden uitgevoerd.
Tools
Tools zijn externe mogelijkheden die agents kunnen gebruiken — denk aan webscraping, bestandsbeheer, het doorzoeken van databases of het aanroepen van API's. CrewAI biedt meer dan 100 ingebouwde tools, maar je kunt ook je eigen tools maken (en dat is makkelijker dan je denkt).
Crew
De Crew is het team: een verzameling agents met hun taken, een processtrategie (sequentieel of hiërarchisch) en optioneel gedeeld geheugen. Met crew.kickoff() start je de uitvoering.
Praktijkproject: Een Content Research Pipeline Bouwen
Genoeg theorie. Laten we het concreet maken. We bouwen een multi-agent systeem dat automatisch een onderwerp onderzoekt, een gestructureerd artikel schrijft en het resultaat controleert op kwaliteit. Drie agents, drie taken, één crew.
Het volledige script
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
# --- Tools instellen ---
zoek_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
# --- Agent 1: De Onderzoeker ---
onderzoeker = Agent(
role="Senior Onderzoeker",
goal="Vind de meest actuele en relevante informatie over {onderwerp}",
backstory="""Je bent een ervaren onderzoeker met een scherp oog voor
betrouwbare bronnen. Je graaft dieper dan het oppervlak en zoekt
altijd naar primaire bronnen, recente data en unieke inzichten
die anderen over het hoofd zien.""",
tools=[zoek_tool, scrape_tool],
verbose=True,
allow_delegation=False
)
# --- Agent 2: De Schrijver ---
schrijver = Agent(
role="Content Schrijver",
goal="Schrijf een helder, informatief en goed gestructureerd artikel over {onderwerp}",
backstory="""Je bent een ervaren technisch schrijver die complexe
onderwerpen toegankelijk maakt. Je schrijft in een directe,
conversationele stijl met concrete voorbeelden. Je structureert
artikelen logisch met duidelijke koppen en subkoppen.""",
verbose=True,
allow_delegation=False
)
# --- Agent 3: De Eindredacteur ---
eindredacteur = Agent(
role="Eindredacteur en Kwaliteitscontroleur",
goal="Controleer het artikel op feitelijke juistheid, structuur en leesbaarheid",
backstory="""Je bent een strenge maar eerlijke eindredacteur.
Je controleert feiten, verbetert onduidelijke passages en zorgt
ervoor dat het artikel logisch opgebouwd is. Je geeft specifieke,
actionable feedback.""",
verbose=True,
allow_delegation=False
)
# --- Taak 1: Onderzoek ---
onderzoek_taak = Task(
description="""Doe grondig onderzoek naar {onderwerp}. Zoek naar:
1. De meest recente ontwikkelingen en trends (2025-2026)
2. Praktische toepassingen en use cases
3. Relevante statistieken en data
4. Veelvoorkomende uitdagingen en oplossingen
5. Expert-meningen en best practices
Lever een gestructureerd onderzoeksrapport op met bronvermeldingen.""",
expected_output="""Een gedetailleerd onderzoeksrapport met secties voor
trends, toepassingen, statistieken, uitdagingen en best practices.
Inclusief URLs van gebruikte bronnen.""",
agent=onderzoeker
)
# --- Taak 2: Schrijven ---
schrijf_taak = Task(
description="""Schrijf een uitgebreid artikel op basis van het
onderzoeksrapport. Het artikel moet:
- Een pakkende introductie hebben
- Duidelijke H2 en H3 koppen bevatten
- Praktische voorbeelden en codeblokken bevatten waar relevant
- Minimaal 1500 woorden zijn
- Een samenvatting hebben aan het einde""",
expected_output="""Een volledig, publicatieklaar artikel in Markdown-formaat
met koppen, subkoppen, voorbeelden en een samenvatting.""",
agent=schrijver
)
# --- Taak 3: Review ---
review_taak = Task(
description="""Controleer het artikel op:
1. Feitelijke juistheid — kloppen alle claims en cijfers?
2. Structuur — is het logisch opgebouwd?
3. Leesbaarheid — is het toegankelijk voor de doelgroep?
4. Volledigheid — ontbreken er belangrijke aspecten?
Lever het definitieve, verbeterde artikel op.""",
expected_output="""Het definitieve artikel, verbeterd waar nodig,
klaar voor publicatie.""",
agent=eindredacteur
)
# --- De Crew samenstellen ---
content_crew = Crew(
agents=[onderzoeker, schrijver, eindredacteur],
tasks=[onderzoek_taak, schrijf_taak, review_taak],
process=Process.sequential, # Taken worden na elkaar uitgevoerd
verbose=True
)
# --- Crew starten ---
resultaat = content_crew.kickoff(
inputs={"onderwerp": "AI-agents in de gezondheidszorg"}
)
print("=" * 60)
print("EINDRESULTAAT:")
print("=" * 60)
print(resultaat)Wat gebeurt er achter de schermen?
Wanneer je crew.kickoff() aanroept, gebeurt er eigenlijk best veel:
- CrewAI vervangt de
{onderwerp}variabele in alle agent-doelen en taakbeschrijvingen. - De onderzoeker ontvangt zijn taak en gebruikt de zoek- en scrape-tools om informatie te verzamelen. Het LLM bepaalt zelf wanneer en hoe het de tools inzet — dat is het mooie van agents.
- Zodra het onderzoek klaar is, ontvangt de schrijver zowel zijn eigen taakbeschrijving als de output van de onderzoeker als context.
- Ten slotte controleert de eindredacteur het artikel en levert de definitieve versie op.
Dit is de kracht van het sequentiële proces: elke volgende agent bouwt voort op het werk van de vorige. Een beetje zoals een estafetteloop, maar dan met tekst in plaats van een stokje.
Geavanceerd: Custom Tools en Geheugen
De basisversie werkt prima, maar voor productiesystemen wil je vaak eigen tools toevoegen en geheugen activeren. Laten we beide bekijken.
Een eigen tool bouwen
Stel je wilt dat je agent een interne database kan doorzoeken. Met CrewAI maak je daar vrij eenvoudig een custom tool voor:
from crewai.tools import BaseTool
from pydantic import Field
class DatabaseZoekTool(BaseTool):
name: str = "Database Zoeker"
description: str = """Doorzoekt de interne kennisdatabase op basis
van een zoekterm. Retourneert relevante documenten en hun metadata."""
def _run(self, zoekterm: str) -> str:
# Hier komt je eigen logica — bijvoorbeeld een
# vectordatabase-query of SQL-zoekopdracht
import sqlite3
conn = sqlite3.connect("kennisbank.db")
cursor = conn.cursor()
cursor.execute(
"SELECT titel, inhoud FROM documenten WHERE inhoud LIKE ?",
(f"%{zoekterm}%",)
)
resultaten = cursor.fetchall()
conn.close()
if not resultaten:
return f"Geen resultaten gevonden voor: {zoekterm}"
output = []
for titel, inhoud in resultaten:
output.append(f"## {titel}\n{inhoud[:500]}...")
return "\n\n".join(output)
# Gebruik de tool bij een agent
onderzoeker = Agent(
role="Interne Kennisspecialist",
goal="Doorzoek onze kennisbank naar relevante informatie",
backstory="Je kent onze interne documentatie als geen ander.",
tools=[DatabaseZoekTool()],
verbose=True
)Zoals je ziet is het concept vrij simpel: je erft van BaseTool, geeft een naam en beschrijving op, en implementeert de _run methode. CrewAI regelt de rest.
Geheugen activeren
CrewAI biedt een geïntegreerd geheugensysteem waarmee agents informatie delen en onthouden tussen taken. Dit is vooral waardevol bij langlopende workflows:
crew_met_geheugen = Crew(
agents=[onderzoeker, schrijver, eindredacteur],
tasks=[onderzoek_taak, schrijf_taak, review_taak],
process=Process.sequential,
memory=True, # Activeert gedeeld geheugen
verbose=True
)Met memory=True krijgen agents toegang tot vier typen geheugen:
- Korte-termijngeheugen — Context uit de huidige uitvoering.
- Lange-termijngeheugen — Lessen uit eerdere uitvoeringen die blijven bewaard.
- Entiteitsgeheugen — Informatie over specifieke entiteiten (personen, producten, concepten).
- Contextueel geheugen — Gedeelde context tussen agents in dezelfde crew.
In de praktijk merkte ik dat het activeren van geheugen vooral verschil maakt als je dezelfde crew herhaaldelijk op vergelijkbare taken loslaat. De agents leren dan van eerdere runs en presteren meetbaar beter.
Hiërarchisch Proces: Een Manager-Agent Toevoegen
In het sequentiële proces voeren agents hun taken in vaste volgorde uit. Maar soms wil je meer flexibiliteit — een manager die taken toewijst en de voortgang coördineert. Dat kan met het hiërarchische proces:
from crewai import Crew, Process
hierarchische_crew = Crew(
agents=[onderzoeker, schrijver, eindredacteur],
tasks=[onderzoek_taak, schrijf_taak, review_taak],
process=Process.hierarchical,
manager_llm="gpt-4o", # Het model voor de manager-agent
verbose=True
)
resultaat = hierarchische_crew.kickoff(
inputs={"onderwerp": "De toekomst van quantum computing"}
)In het hiërarchische proces maakt CrewAI automatisch een manager-agent aan die:
- Taken toewijst aan de meest geschikte agent.
- De volgorde dynamisch bepaalt op basis van afhankelijkheden.
- Resultaten evalueert en eventueel taken opnieuw toewijst.
- De eindoutput samenstelt uit alle deelresultaten.
Dit is vooral handig wanneer taken niet strikt sequentieel zijn, of wanneer de optimale volgorde pas duidelijk wordt na het zien van tussenresultaten. Het voelt een beetje als het verschil tussen een vaste agenda en een agile standup.
CrewAI Flows: Productieklare Orkestratie
Voor echt productieklare toepassingen biedt CrewAI Flows — event-driven workflows met expliciete state management. Even eerlijk: als je net begint met CrewAI heb je dit nog niet nodig. Maar zodra je serieuzer wordt, zijn Flows onmisbaar.
Flows geven je fijnmazige controle over de gehele applicatielogica, terwijl Crews de autonome taken afhandelen:
from crewai.flow.flow import Flow, listen, start
class ContentPipelineFlow(Flow):
"""Een productieklare content-pipeline met Flows."""
@start()
def onderwerp_valideren(self):
"""Valideer en verrijk het onderwerp voordat agents beginnen."""
onderwerp = self.state.get("onderwerp", "")
if len(onderwerp) < 5:
raise ValueError("Onderwerp is te kort")
# Verrijk met metadata
self.state["onderwerp_verrijkt"] = {
"titel": onderwerp,
"taal": "nl",
"max_woorden": 2000
}
return self.state["onderwerp_verrijkt"]
@listen(onderwerp_valideren)
def onderzoek_uitvoeren(self, verrijkt_onderwerp):
"""Start de research crew."""
research_crew = Crew(
agents=[onderzoeker],
tasks=[onderzoek_taak],
process=Process.sequential
)
resultaat = research_crew.kickoff(
inputs={"onderwerp": verrijkt_onderwerp["titel"]}
)
self.state["onderzoek"] = str(resultaat)
return self.state["onderzoek"]
@listen(onderzoek_uitvoeren)
def artikel_schrijven(self, onderzoek_resultaat):
"""Start de schrijf- en review crew."""
schrijf_crew = Crew(
agents=[schrijver, eindredacteur],
tasks=[schrijf_taak, review_taak],
process=Process.sequential
)
resultaat = schrijf_crew.kickoff(
inputs={"onderwerp": self.state["onderwerp"]}
)
self.state["definitief_artikel"] = str(resultaat)
return self.state["definitief_artikel"]
# Gebruik de Flow
flow = ContentPipelineFlow()
eindresultaat = flow.kickoff(
inputs={"onderwerp": "Machine learning in de landbouw"}
)
print(eindresultaat)Het grote verschil met een simpele Crew? Flows geven je expliciete controle over state, error handling en conditionele logica tussen stappen. Je kunt validatie toevoegen, tussenresultaten opslaan, en meerdere Crews combineren in één gecoördineerde pipeline. Kortom: Crews zijn je werknemers, Flows zijn je bedrijfsprocessen.
Best Practices voor Productiesystemen
Na het bouwen van je eerste multi-agent systeem wil je het robuust genoeg maken voor productie. Hier zijn de belangrijkste lessen die ik uit de praktijk heb geleerd:
1. Houd agents gefocust
Geef elke agent één duidelijke verantwoordelijkheid. Een agent die zowel onderzoek doet, schrijft én redigeert presteert slechter dan drie gespecialiseerde agents. De vuistregel: als je de rol niet in één zin kunt beschrijven, splits hem dan op.
2. Schrijf gedetailleerde backstories
De backstory is niet zomaar decoratie — het stuurt hoe het LLM de agent interpreteert en welke output het genereert. Een onderzoeker met als backstory "Je bent een wetenschapper met 20 jaar ervaring in peer-reviewed onderzoek" levert fundamenteel andere output dan "Je zoekt dingen op internet." Dit lijkt een klein detail, maar het verschil in kwaliteit is opvallend groot.
3. Definieer verwachte output expliciet
De expected_output parameter in taken is cruciaal. Hoe specifieker je bent over het verwachte formaat en de inhoud, hoe beter het resultaat. Vergelijk:
- Vaag: "Een onderzoeksrapport"
- Specifiek: "Een gestructureerd rapport met 5 secties: Samenvatting (100 woorden), Trends (3-5 punten met bronvermelding), Statistieken (tabel), Uitdagingen (genummerde lijst) en Aanbevelingen (3 concrete actiepunten)"
Je raadt het al — de specifieke variant levert consequent betere resultaten op.
4. Gebruik het juiste proces
- Sequentieel — Gebruik dit wanneer taken duidelijk op elkaar voortbouwen (onderzoek → schrijven → review).
- Hiërarchisch — Gebruik dit wanneer de optimale taakvolgorde niet vaststaat of wanneer dynamische delegatie nodig is.
- Flows — Gebruik dit voor productieklare applicaties met complexe conditionele logica en state management.
5. Implementeer foutafhandeling
LLM-calls kunnen falen door rate limits, netwerktimeouts of onverwachte output. Klinkt voor de hand liggend, maar ik zie het regelmatig misgaan. Bouw altijd foutafhandeling in:
from crewai import Crew
try:
resultaat = content_crew.kickoff(
inputs={"onderwerp": "Duurzame technologie"}
)
print(f"Succes: {len(str(resultaat))} tekens gegenereerd")
except Exception as e:
print(f"Fout opgetreden: {e}")
# Implementeer fallback-logica of herstart6. Monitor kosten en tokens
Multi-agent systemen versturen meerdere LLM-calls per uitvoering. Dat tikt aan. Met verbose=True kun je elke call volgen. Overweeg voor productie een budgetlimiet per uitvoering in te stellen en gebruik waar mogelijk kleinere modellen voor agents met eenvoudige taken.
Veelgestelde Vragen
Wat is het verschil tussen een AI-agent en een multi-agent systeem?
Een AI-agent is een individuele autonome eenheid die taken kan uitvoeren, tools kan gebruiken en beslissingen kan nemen. Een multi-agent systeem combineert meerdere van zulke agents die samenwerken, elk met een eigen specialisatie. Het verschil is vergelijkbaar met een freelancer versus een team: de freelancer doet alles zelf, terwijl het team taken verdeelt op basis van expertise. Multi-agent systemen presteren beter bij complexe taken die verschillende vaardigheden vereisen.
Hoeveel kost het om een multi-agent systeem te draaien met CrewAI?
De kosten hangen af van het gebruikte LLM en het aantal agents en taken. Een typische crew met drie agents die GPT-4o gebruikt, kost tussen de €0,05 en €0,30 per uitvoering, afhankelijk van de complexiteit. Je kunt kosten verlagen door kleinere modellen te gebruiken voor eenvoudige agents (bijvoorbeeld GPT-4o-mini voor de eindredacteur) of door lokale modellen in te zetten via Ollama.
Kan ik CrewAI gebruiken met Claude of lokale modellen?
Ja, absoluut. CrewAI ondersteunt een breed scala aan LLM-providers. Je kunt Anthropic Claude, Google Gemini, AWS Bedrock en lokale modellen via Ollama of LiteLLM gebruiken. Stel het juiste model in bij de agent-configuratie: Agent(llm="anthropic/claude-sonnet-4-20250514", ...). Je kunt zelfs verschillende modellen per agent gebruiken — een krachtig model voor complexe redeneertaken en een sneller, goedkoper model voor eenvoudige taken.
Wanneer moet ik een multi-agent systeem gebruiken in plaats van een enkele agent?
Gebruik een multi-agent systeem wanneer je taak zich natuurlijk laat opsplitsen in deeltaken die verschillende expertise vereisen, wanneer de kwaliteit van een enkele agent niet voldoet voor complexe workflows, of wanneer je schaalbaarheid nodig hebt. Maar — en dit is belangrijk — begin altijd met de simpelste aanpak. Als één agent met goede prompts het werk prima doet, voeg dan geen onnodige complexiteit toe. De gouden regel: gebruik de eenvoudigste setup die je probleem effectief oplost.
Hoe debug ik een multi-agent systeem als de output niet klopt?
Zet verbose=True aan bij zowel de agents als de crew — dit toont elke stap, tool-aanroep en tussenresultaat. Controleer vervolgens per agent of de individuele output klopt. Vaak (vaker dan je denkt) zit het probleem in een onduidelijke taakbeschrijving of een te vage expected_output. Begin met het isoleren van de problematische agent door hem apart te testen met dezelfde input. CrewAI biedt ook logging-integraties voor monitoring in productie.