1~
2AI-agents zijn van onderzoeksdemo's uitgegroeid tot productiesystemen. Naar verwachting zullen meer dan 60% van de enterprise AI-toepassingen tegen 2026 agentische componenten bevatten. Maar agents vanaf nul bouwen  -  tool-loops, state, geheugen, foutafhandeling en multi-agent-coordinatie beheren  -  is complex. Daar komen frameworks om de hoek kijken.
3~
4Vier frameworks domineren in 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK** en **Claude Agent SDK**. Elk kiest een fundamenteel andere aanpak voor hetzelfde probleem: LLM's het vermogen geven om te redeneren, te plannen, tools te gebruiken en samen te werken.
5~
6## In een Oogopslag
7~
8| Aspect | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Door** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architectuur** | Graph-gebaseerd | Rolgebaseerd | Handoff-gebaseerd | Autonome loop |
12| **Filosofie** | Maximale controle | Teamsamenwerking | Minimale abstractie | Geef de agent een computer |
13| **Talen** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Modelondersteuning** | Alle (OpenAI, Claude, lokaal) | Alle | Alle (ondanks de naam) | Alleen Claude |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Best voor** | Complexe stateful workflows | Multi-agent-specialisatie | Routing en triage | Coding en bestandsintensieve taken |
17~
18## LangGraph: De Graph-Bouwer
19~
20LangGraph modelleert agent-workflows als **gerichte cyclische grafen**. Je definieert nodes (functies die werk verrichten) en edges (overgangen daartussen, optioneel conditioneel). State stroomt door de graaf en wordt gepersisteerd via checkpointing.
21~
22Dit is het meest expliciete en controleerbare framework  -  je bedraadt elke stap zelf.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Kernconcepten
35~
36- **StateGraph**: de graafdefinitie met getypeerde state
37- **Nodes**: Python-functies die state transformeren
38- **Edges**: verbindingen tussen nodes, kunnen conditioneel zijn
39- **Checkpointing**: ingebouwde persistentie voor langlopende workflows
40~
41### Codevoorbeeld
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Sterke punten
79~
80- Fijnmazige controle over elke stap en overgang
81- Ingebouwd checkpointing en human-in-the-loop
82- Volledige TypeScript-pariteit
83- Werkt met elke LLM-provider
84- Het beste voor complexe workflows met conditionele vertakkingen en loops
85~
86### Zwakke punten
87~
88- Steile leercurve  -  je moet concepten uit de grafentheorie begrijpen
89- Omslachtig voor eenvoudige use cases  -  een simpele agent vereist meer boilerplate dan andere frameworks
90- Het debuggen van graafstromen kan zonder LangSmith uitdagend zijn
91~
92### Prijzen
93~
94Open-source (MIT). LangSmith (beheerd observability-platform) heeft betaalde niveaus voor productiemonitoring.
95~
96## CrewAI: De Team-Samensteller
97~
98CrewAI gebruikt een menselijke metafoor: je stelt een **crew** samen van gespecialiseerde agents, elk met een **rol**, **doel** en **achtergrondverhaal**. Agents werken samen aan **taken** met **tools**, gecoordineerd door een **proces** (sequentieel, hierarchisch of consensusgebaseerd).
99~
100Zie het als het samenstellen van een team waarin elk lid een specifieke functietitel en specialisatie heeft.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Kernconcepten
114~
115- **Agent**: een persona met rol, doel, achtergrondverhaal en tools
116- **Task**: een opdracht met beschrijving, verwachte output en toegewezen agent
117- **Crew**: een groep agents die samenwerken
118- **Process**: uitvoeringsstrategie (sequentieel, hierarchisch, consensusgebaseerd)
119- **Flow**: event-driven orchestratielaag voor het verbinden van meerdere crews
120~
121### Codevoorbeeld
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Sterke punten
171~
172- Intuitieve rolgebaseerde abstractie  -  makkelijk te doorgronden
173- Meer dan 100 ingebouwde tool-integraties
174- Gedeeld geheugen over agents heen (kortetermijn, langetermijn, entity)
175- Grootste community (~40k GitHub stars)
176- Hierarchisch proces met een "manager"-agent die delegeert en valideert
177~
178### Zwakke punten
179~
180- Minder fijnmazige controle dan LangGraph  -  je definieert rollen, geen exacte uitvoeringspaden
181- Hierarchisch proces kan onvoorspelbaar zijn wanneer agents het oneens zijn
182- Het debuggen van multi-agent-conversaties is lastiger dan bij single-agent-flows
183~
184### Prijzen
185~
186Open-source core (gratis). CrewAI Platform: $99/maand (Teams) tot $120k/jaar (Enterprise). Prijzen gebaseerd op actieve crews en maandelijkse uitvoeringen.
187~
188## OpenAI Agents SDK: De Router
189~
190Het OpenAI Agents SDK (geestelijke opvolger van Swarm) richt zich op **handoffs**  -  agents die conversaties overdragen aan andere gespecialiseerde agents. Het is het meest minimale framework: agents, tools, handoffs en guardrails. Dat is alles.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Kernconcepten
204~
205- **Agent**: model + instructies + tools + handoffs
206- **Handoff**: een overdracht aan een andere agent (gemodelleerd als een tool die het LLM kan aanroepen)
207- **Guardrail**: invoer-/uitvoervalidatie die parallel met de agent draait
208- **Runner**: voert de agent-loop uit
209- **Tracing**: ingebouwde observability voor alle LLM-aanroepen, tool-uitvoeringen en handoffs
210~
211### Codevoorbeeld
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Sterke punten
258~
259- Schoon handoff-patroon  -  natuurlijk voor routing-/triage-workflows
260- Guardrails draaien parallel met uitvoering (fail-fast, niet blokkerend)
261- Ingebouwd tracing-dashboard voor debugging
262- Ondanks de naam worden ook niet-OpenAI-modellen ondersteund
263- Minimale abstractie  -  makkelijk te begrijpen en uit te breiden
264~
265### Zwakke punten
266~
267- Minder volwassen state management dan LangGraph
268- Geen ingebouwde persistentie of checkpointing
269- Ecosysteem van third-party tools is kleiner
270- Handoff-centrisch ontwerp past mogelijk niet bij elke architectuur
271~
272### Prijzen
273~
274Open-source (MIT). Je betaalt per token voor welk model je ook gebruikt.
275~
276## Claude Agent SDK: De Ontwikkelaar
277~
278Het Claude Agent SDK kiest een andere aanpak: in plaats van workflows of rollen te definieren, geef je de agent een **set tools en laat je hem uitzoeken hoe hij de taak moet volbrengen**. Het gebruikt dezelfde autonome loop die Claude Code aandrijft  -  lezen, handelen, verifieren, itereren.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Kernconcepten
291~
292- **query()**: het hoofdingangspunt dat de agent-loop start
293- **Ingebouwde tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Aangepaste tools via MCP**: tools definieren als in-process MCP-servers
295- **Sub-agents**: gespecialiseerde agents waaraan de bovenliggende agent kan delegeren
296- **Sessions**: context behouden over meerdere interacties
297~
298### Codevoorbeeld
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Sterke punten
336~
337- Eersteklas MCP-integratie  -  verbinding met elk MCP-server-ecosysteem
338- Ingebouwde tools voor bestandsoperaties, terminal en webtoegang
339- Automatische contextcompactie voor grote codebases
340- Sub-agent-parallellisme voor complexe taken
341- Dezelfde motor als Claude Code  -  beproefd in echte ontwikkelworkflows
342~
343### Zwakke punten
344~
345- Alleen Claude-modellen  -  geen multi-provider-ondersteuning
346- Nieuwer framework met een kleinere community
347- Vereist Node.js-runtime ook voor de Python SDK
348- Minder expliciete workflowcontrole vergeleken met LangGraph
349~
350### Prijzen
351~
352Open-source. Standaard Claude API-tokenprijzen. Managed Agents (gehoste versie): $0,08 per sessieuur bovenop tokenkosten.
353~
354## Wanneer welk framework kiezen
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Kies LangGraph als:
371- Je precieze controle over elke stap van de workflow nodig hebt
372- Je use case complexe conditionele logica en loops omvat
373- Je ingebouwde persistentie en human-in-the-loop checkpoints wilt
374- Je meerdere LLM-providers in dezelfde workflow moet gebruiken
375~
376### Kies CrewAI als:
377- Je een intuitieve, rolgebaseerde abstractie wilt
378- Je taak meerdere agents met verschillende specialisaties omvat
379- Je agents nodig hebt die samenwerken en context aan elkaar doorgeven
380- De grootste community en de meeste ingebouwde integraties belangrijk voor je zijn
381~
382### Kies OpenAI Agents SDK als:
383- Je primaire patroon het routeren van conversaties naar specialisten is
384- Je guardrails nodig hebt die invoer/uitvoer parallel valideren
385- Je de eenvoudigst mogelijke abstractie met minimale boilerplate wilt
386- Ingebouwd tracing en observability belangrijk zijn
387~
388### Kies Claude Agent SDK als:
389- Je agents code moeten lezen, schrijven en uitvoeren
390- Je eersteklas MCP-server-integratie wilt
391- Je autonome agents nodig hebt die itereren en zichzelf corrigeren
392- Je al Claude gebruikt en de diepste integratie wilt
393~
394## Kun je frameworks combineren?
395~
396Ja. Een veelvoorkomend patroon is het gebruik van een framework voor orchestratie en een ander voor individuele agents:
397~
398- **LangGraph** voor de gehele workflow-graaf
399- **CrewAI** voor een specifieke node die multi-agent-samenwerking vereist
400- **Claude Agent SDK** voor codeergerelateerde subtaken via MCP
401- **OpenAI Agents SDK** voor klantgerichte triage en routing
402~
403De frameworks sluiten elkaar niet uit. Gebruik wat past bij elk onderdeel van je systeem.
404~
405## Conclusie
406~
407Elk framework maakt een duidelijke keuze:
408~
409- **LangGraph** optimaliseert voor controle  -  jij bepaalt elke overgang
410- **CrewAI** optimaliseert voor samenwerking  -  agents werken als een team
411- **OpenAI Agents SDK** optimaliseert voor eenvoud  -  minimale abstractie, schone handoffs
412- **Claude Agent SDK** optimaliseert voor autonomie  -  geef het tools en laat het werken
413~
414De juiste keuze hangt af van je workflow, je team en je bestaande stack. Kies degene die bij je primaire use case past, leer het goed kennen en trek anderen erbij wanneer je hun sterke punten nodig hebt.
415~