Een van de meest gestelde vragen van technische teams die hun eerste productieagent plannen: "Welk framework moeten we gebruiken?" Begrijpelijk — GitHub staat vol projecten, elk met demo's die er goed uitzien, en vergelijkingsblogs spreken elkaar voortdurend tegen.
Kort antwoord: het framework is een secundaire beslissing. De primaire is de architectuur van de agent — het patroon waarvolgens de agent redeneert en handelt (ReAct, Plan-and-Execute, reflectie). Frameworks *implementeren* deze patronen; ze verzinnen ze niet. LangGraph, CrewAI, AutoGen en eigen code zijn vier manieren om dezelfde patronen in code te gieten. Elk heeft andere trade-offs. Dit artikel helpt u de juiste keuze te maken — of weerhoudt u van een frameworkkeuze op plaatsen waar die helemaal niet nodig is.
Wat frameworks doen (en wat niet)
Voordat we concrete projecten vergelijken, is het nuttig te verduidelijken wat een agentframework eigenlijk oplost. Typisch biedt het:
- Orchestratie van stappen — hoe de agent van de ene toestand naar de andere gaat (reason-act-observe-cyclus of plan → uitvoering → reflectie)
- Context- en toestandbeheer — waar geschiedenis, tussenresultaten en context tussen aanroepen worden opgeslagen
- Routing tussen agents — hoe een taak van de ene gespecialiseerde agent naar de andere wordt doorgegeven
- Tool-integratie — een gestandaardiseerde manier waarop de agent externe API's, vectordatabases en code aanroept
- Checkpointing en resumability — de mogelijkheid een agent na een fout te hervatten zonder voortgang te verliezen
Wat frameworks niet doen: ze nemen u de verantwoordelijkheid voor correcte prompts, toolkwaliteit, guardrails of observability niet uit handen. Dat blijft bij u, ongeacht uw keuze.
LangGraph: expliciete graaf, expliciete toestand
LangGraph bouwt een agent als een gerichte graaf — knopen zijn functies (LLM-aanroep, tool, conditie), kanten zijn overgangen tussen toestanden. De toestand is een expliciete Python-dataclass of dict die tussen knopen wordt doorgegeven.
Wat dat in de praktijk betekent:
- Elke overgang in de graaf is zichtbaar en geïsoleerd testbaar
- Checkpointing is ingebouwd — een agent kan pauzeren en hervatten vanuit de laatste knoop (belangrijk bij langlopende taken)
- HITL (human-in-the-loop) wordt geïmplementeerd via
interrupt()— de agent stopt, wacht op menselijke invoer en gaat daarna verder. Dit sluit aan op de eisen van EU AI Act art. 14 voor menselijk toezicht bij hoog-risicosystemen, verplicht vanaf augustus 2026 - Debugbaarheid is bovengemiddeld: u weet precies in welke knoop en met welke toestand de agent gefaald heeft
Wanneer LangGraph zinvol is:
- Productie-stateful agents met meerdere stappen (meer dan 3–4 tool-aanroepen per taak)
- U hebt checkpointing nodig — de agent loopt minuten of uren
- HITL bij kritieke acties (financiële operaties, verzenden van documenten)
- Het team wil een grafische visualisatie van de flow voor review en debugging
- Uitrol in een gereguleerde omgeving waar een audit trail op knoop-per-knoop niveau vereist is
Wanneer LangGraph overbodig is:
- Eenvoudige single-step RAG (embed → retrieve → generate) — hier is het overhead zonder meerwaarde
- Snel prototype waarbij u binnen een dag resultaat nodig hebt, niet binnen een week
- Het team is niet vertrouwd met graafgebaseerd programmeren — de leercurve is reëel
LangGraph wordt vandaag beschouwd als het productiestabilste framework voor enterprise stateful agents. Geen makkelijkste instap, maar wel de meest beheersbare uitkomst.
CrewAI: rollen, teams, snelle start
CrewAI denkt in termen van rollen en teams. U definieert agents met specifieke rollen (Researcher, Analyst, Writer), elk met een eigen doel en een set tools, en het framework coördineert hoe ze de taak aan elkaar overdragen.
De instapdrempel is laag — een basisteam met meerdere agents redt u met ~20–35 regels code. Dat is de voornaamste kracht van CrewAI: een werkend multi-agentsysteem als prototype in uren, niet in dagen.
Wat dat in de praktijk betekent:
- Snel prototypen is echt snel — de syntax is leesbaar, een nieuw teamlid is er binnen uren in thuis
- Op rollen gebaseerde abstractie is intuïtief voor teams die denken in termen van "wie doet wat"
- In productie heeft CrewAI minder middelen voor expliciet toestandbeheer en checkpointing in vergelijking met LangGraph
- Debugbaarheid is zwakker — bij een fout is het moeilijker precies te bepalen in welke stap en waarom
Wanneer CrewAI zinvol is:
- Proof-of-concept of intern prototype waarbij u snel waarde wilt aantonen
- Multi-agentscenario's waarbij rolgebaseerd denken van nature bij het probleem past (bijv. pipeline: data verzamelen → analyseren → rapporteren)
- Team zonder diepgaande achtergrond in graafgebaseerd programmeren
- Minder kritische systemen waarbij incidentele fouten acceptabel zijn
Wanneer CrewAI tekortschiet:
- Productiesystemen waar u betrouwbaar checkpointing en resumability nodig hebt
- HITL met gegarandeerde stop op kritieke punten
- Langlopende agentische taken (tientallen tool-aanroepen) waarbij de toestand expliciet beheerd moet worden
- Gereguleerde omgevingen met een eis voor audit trail
CrewAI is geen slecht framework. Het is het juiste gereedschap voor een prototype — maar de overgang van een CrewAI-prototype naar een productiesysteem betekent vaak een gedeeltelijke of volledige herschrijving in LangGraph of eigen code.
AutoGen: conversationele agents, onderzoekskarakter
AutoGen (nu AG2) denkt anders dan LangGraph of CrewAI. In plaats van een expliciete graaf of rollen heeft het een conversationele GroupChat — agents wisselen berichten uit en het framework beheert wie wanneer spreekt.
AutoGen bereikte in 2025 versie 1.0 GA, wat op volwassenheid wijst. Het is populair in onderzoeksomgevingen en bij het experimenteren met multi-agentdialoog.
Wat dat in de praktijk betekent:
- Sterk voor scenario's waarbij de oplossing ontstaat door conversatie tussen agents — bijv. één agent schrijft code, een andere controleert die en stelt verbeteringen voor
- Flexibel en expressief voor experimenten — u voegt eenvoudig een nieuwe agent aan de chat toe
- Minder voorspelbaar in productie — de conversatiestroom is moeilijker deterministisch te sturen dan een expliciete graaf
- Observability en checkpointing zijn zwakkere punten in vergelijking met LangGraph
Wanneer AutoGen zinvol is:
- Onderzoek naar en experimenteren met nieuwe agent-to-agent-patronen
- Systemen waarbij meerdere specialisten (agents) iteratief moeten samenwerken aan een antwoord
- Coding assistants en code review-pipelines
- Prototypes waarbij u lagere voorspelbaarheid kunt accepteren
Wanneer AutoGen tekortschiet:
- Productiesystemen met eisen aan deterministische flow
- Scenario's waarbij u een gegarandeerde stop (HITL) op specifieke acties nodig hebt
- Bedrijven met langdurige verantwoordelijkheid voor uitvoerkwaliteit — conversationele chaos is moeilijk te auditeren
Eigen code: soms de beste keuze
Dit is het antwoord dat mensen niet verwachten, maar in de praktijk zien we het vaker dan u zou denken: soms is er helemaal geen framework nodig.
Als uw agent een vaste reeks stappen uitvoert — bijv. een document ontvangen, 2–3 tools aanroepen, een gestructureerde uitvoer teruggeven — kan Python met directe SDK-aanroepen (Anthropic, OpenAI) en eigen retry-logica schoner, sneller en makkelijker te onderhouden zijn dan welk framework dan ook.
Wanneer eigen code zinvol is:
- De agentlogica is eenvoudig en stabiel — minder dan 3–4 stappen, geen vertakking
- Het team heeft een sterke Python-achtergrond en frameworks voegen meer complexiteit toe dan waarde
- U wilt een minimale set afhankelijkheden — elk framework voegt tientallen transitieve pakketten toe
- U bouwt een specifieke pipeline, geen generieke agent runtime
Let op deze valkuil:
Eigen code verandert snel in een onbeheersbaar "hobby-framework" — u voegt toestand, retry en checkpointing stap voor stap toe. Zodra een agent groeit naar 5+ stappen met vertakking, wordt LangGraph of een ander framework de rationele keuze. Eigen code is een goede start, maar niet altijd een goed eindpunt.
Besliskader
In plaats van een tabel (die onleesbaar zou worden) is hier de beslislogica uit de praktijk:
Begin met de vraag: Hoeveel stappen en welke complexiteit?
- Minder dan 3–4 stappen, vaste reeks → eigen code of CrewAI
- 5+ stappen, vertakking, behoefte aan resumability → LangGraph
- Multi-agentdialoog, onderzoek, coding review → AutoGen
Dan: Is het een prototype of productie?
- Prototype, PoC, demo → CrewAI of AutoGen (snelheid van instap)
- Productie, SLA, gereguleerde omgeving → LangGraph of eigen code (controle)
Dan: Is HITL nodig?
- Ja, met gegarandeerde stop → LangGraph (
interrupt()) of eigen code met expliciete await - Nee of "human-on-the-loop" volstaat → elk framework
Tot slot: Wat zijn de eisen aan observability?
Dit is het punt dat bedrijven het vaakst onderschatten. Zonder observability — het vastleggen van traces op het niveau van elke knoop en tool-aanroep — kunt u in productie fouten niet diagnosticeren. Voor LangGraph is de natuurlijke integratie LangSmith; voor andere frameworks werkt Langfuse (self-hostable, framework-agnostisch) of Arize Phoenix goed. Meer over dit onderwerp in het artikel over observability van AI-agenten.
Wat alle frameworks gemeen hebben: tool calling
Één patroon geldt ongeacht welk framework u kiest: betrouwbaarheid van tool calling is niet vanzelfsprekend. De meeste productie-incidenten bij agents ontstaan niet door slecht redeneren — ze ontstaan door verkeerd gevormde toolargumenten, niet-afgehandelde toolfouten of een agent die een tool aanroept met zinloze parameters.
Verplicht minimum voor productie:
- Strikte JSON-schemavalidatie van invoer en uitvoer van elke tool
- Retry-logica met exponentiële backoff voor transactionele fouten
- Maximaal aantal pogingen (bijv. 3) met fallback — de agent moet ook "opgeven" kunnen op een nette manier
- Logging van elke tool-aanroep met parameters en resultaat
Een diepgaandere behandeling van dit onderwerp vindt u in het artikel tool calling betrouwbaar inzetten.
Frameworks vs. patronen: de juiste volgorde
Terug naar het punt waarvan we zijn vertrokken. Beantwoord deze vragen vóórdat u een framework kiest:
- 1.Welk patroon heb ik nodig? ReAct (lus), Plan-and-Execute (eerst plannen), reflectie (zelfkritiek)? Meer over patronen in architecturen van AI-agenten.
- 2.Wat zijn de eisen aan betrouwbaarheid en auditeerbaarheid? Gereguleerde omgeving, financiële operaties, gezondheidszorg — hier geldt LangGraph of eigen code.
- 3.Wat is de horizon? Prototype voor 2 weken vs. systeem dat 2 jaar draait — dat zijn fundamenteel andere beslissingen.
Een framework is slechts een omhulsel. Een slecht patroon in een elegant framework faalt nog steeds. Het juiste patroon in eenvoudige eigen code kan jarenlang probleemlos draaien.
Veelgestelde vragen
Kan ik frameworks combineren?
Ja, maar voorzichtig. LangGraph voor orchestratie combineren met een CrewAI-crew binnen één knoop is technisch mogelijk, maar het debuggen wordt complexer. In de praktijk raden we aan één framework voor het hele systeem te kiezen. Als dat niet mogelijk is (bijv. wanneer u een bestaand CrewAI-prototype integreert in een nieuw LangGraph-systeem), isoleer de integratie dan in een dedicated knoop met een helder API-contract.
Moet ik van CrewAI naar LangGraph migreren als ik naar productie ga?
Niet noodzakelijk. Sommige productiesystemen draaien betrouwbaar op CrewAI — het hangt af van de complexiteit van de agent en de eisen. Vuistregel uit de praktijk: als uw agent langer dan een minuut loopt, meer dan 5 stappen heeft of gegarandeerde HITL nodig heeft, loont de migratie. Kortere, eenvoudigere agents kunnen op CrewAI blijven.
Is AutoGen geschikt voor productie?
AutoGen 1.0 GA (2025) is volwassener dan de 0.x-versies. Voor goed gedefinieerde use-cases (coding assistants, review-pipelines) is productie-uitrol realistisch. Voor scenario's met een eis op auditeerbaarheid van elke stap en gegarandeerde HITL blijft LangGraph de betere keuze.
Welk model gebruik ik met een framework?
Een framework is modelagnostisch — het werkt met elk model dat tool calling ondersteunt. In de praktijk raden we aan bij de ontwikkeling te testen met een frontier-model (Claude Sonnet, GPT-klasse), en als kosten kritisch zijn, geleidelijk goedkopere modellen (Haiku-tier, open-weight Qwen 3.x of Llama 4) te testen in de productieomgeving. De kosten van verschillende modellen in agentscenario's worden behandeld in kosten van een AI-agent in productie.
Hoe gaan frameworks om met beveiliging — guardrails?
Kort antwoord: dat doen ze niet — dat is uw verantwoordelijkheid. Een framework biedt structuur voor de flow, geen beveiligingslaag. Guardrails (invoervalidatie, detectie van prompt injection, tool permission scope, outputfiltering) moet u expliciet toevoegen — via dedicated tools (NeMo Guardrails, Guardrails AI) of eigen validatielogica. Meer in het artikel over guardrails voor AI-agenten.
*De keuze van het framework is een belangrijke beslissing, maar niet de belangrijkste bij het bouwen van een agent. Bij MP Industrial Solutions begeleiden we klanten het hele traject — van patroon- en frameworkkeuze via productie-uitrol tot monitoring en guardrails. Als u uw eerste productieagent plant of wilt beoordelen of uw prototype productieklaar is, bespreken we graag uw concrete use-case.*