Agentic AI Frameworks Vergeleken: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

AI-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.

Vier 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.

In een Oogopslag

LangGraph: De Graph-Bouwer

LangGraph 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.

Dit is het meest expliciete en controleerbare framework - je bedraadt elke stap zelf.

Kernconcepten

• StateGraph: de graafdefinitie met getypeerde state
• Nodes: Python-functies die state transformeren
• Edges: verbindingen tussen nodes, kunnen conditioneel zijn
• Checkpointing: ingebouwde persistentie voor langlopende workflows

Codevoorbeeld

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Sterke punten

• Fijnmazige controle over elke stap en overgang
• Ingebouwd checkpointing en human-in-the-loop
• Volledige TypeScript-pariteit
• Werkt met elke LLM-provider
• Het beste voor complexe workflows met conditionele vertakkingen en loops

Zwakke punten

• Steile leercurve - je moet concepten uit de grafentheorie begrijpen
• Omslachtig voor eenvoudige use cases - een simpele agent vereist meer boilerplate dan andere frameworks
• Het debuggen van graafstromen kan zonder LangSmith uitdagend zijn

Prijzen

Open-source (MIT). LangSmith (beheerd observability-platform) heeft betaalde niveaus voor productiemonitoring.

CrewAI: De Team-Samensteller

CrewAI 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).

Zie het als het samenstellen van een team waarin elk lid een specifieke functietitel en specialisatie heeft.

Kernconcepten

• Agent: een persona met rol, doel, achtergrondverhaal en tools
• Task: een opdracht met beschrijving, verwachte output en toegewezen agent
• Crew: een groep agents die samenwerken
• Process: uitvoeringsstrategie (sequentieel, hierarchisch, consensusgebaseerd)
• Flow: event-driven orchestratielaag voor het verbinden van meerdere crews

Codevoorbeeld

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Sterke punten

• Intuitieve rolgebaseerde abstractie - makkelijk te doorgronden
• Meer dan 100 ingebouwde tool-integraties
• Gedeeld geheugen over agents heen (kortetermijn, langetermijn, entity)
• Grootste community (~40k GitHub stars)
• Hierarchisch proces met een "manager"-agent die delegeert en valideert

Zwakke punten

• Minder fijnmazige controle dan LangGraph - je definieert rollen, geen exacte uitvoeringspaden
• Hierarchisch proces kan onvoorspelbaar zijn wanneer agents het oneens zijn
• Het debuggen van multi-agent-conversaties is lastiger dan bij single-agent-flows

Prijzen

Open-source core (gratis). CrewAI Platform: $99/maand (Teams) tot $120k/jaar (Enterprise). Prijzen gebaseerd op actieve crews en maandelijkse uitvoeringen.

OpenAI Agents SDK: De Router

Het 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.

Kernconcepten

• Agent: model + instructies + tools + handoffs
• Handoff: een overdracht aan een andere agent (gemodelleerd als een tool die het LLM kan aanroepen)
• Guardrail: invoer-/uitvoervalidatie die parallel met de agent draait
• Runner: voert de agent-loop uit
• Tracing: ingebouwde observability voor alle LLM-aanroepen, tool-uitvoeringen en handoffs

Codevoorbeeld

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Sterke punten

• Schoon handoff-patroon - natuurlijk voor routing-/triage-workflows
• Guardrails draaien parallel met uitvoering (fail-fast, niet blokkerend)
• Ingebouwd tracing-dashboard voor debugging
• Ondanks de naam worden ook niet-OpenAI-modellen ondersteund
• Minimale abstractie - makkelijk te begrijpen en uit te breiden

Zwakke punten

• Minder volwassen state management dan LangGraph
• Geen ingebouwde persistentie of checkpointing
• Ecosysteem van third-party tools is kleiner
• Handoff-centrisch ontwerp past mogelijk niet bij elke architectuur

Prijzen

Open-source (MIT). Je betaalt per token voor welk model je ook gebruikt.

Claude Agent SDK: De Ontwikkelaar

Het 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.

Kernconcepten

• query(): het hoofdingangspunt dat de agent-loop start
• Ingebouwde tools: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Aangepaste tools via MCP: tools definieren als in-process MCP-servers
• Sub-agents: gespecialiseerde agents waaraan de bovenliggende agent kan delegeren
• Sessions: context behouden over meerdere interacties

Codevoorbeeld

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Sterke punten

• Eersteklas MCP-integratie - verbinding met elk MCP-server-ecosysteem
• Ingebouwde tools voor bestandsoperaties, terminal en webtoegang
• Automatische contextcompactie voor grote codebases
• Sub-agent-parallellisme voor complexe taken
• Dezelfde motor als Claude Code - beproefd in echte ontwikkelworkflows

Zwakke punten

• Alleen Claude-modellen - geen multi-provider-ondersteuning
• Nieuwer framework met een kleinere community
• Vereist Node.js-runtime ook voor de Python SDK
• Minder expliciete workflowcontrole vergeleken met LangGraph

Prijzen

Open-source. Standaard Claude API-tokenprijzen. Managed Agents (gehoste versie): $0,08 per sessieuur bovenop tokenkosten.

Wanneer welk framework kiezen

Kies LangGraph als:

• Je precieze controle over elke stap van de workflow nodig hebt
• Je use case complexe conditionele logica en loops omvat
• Je ingebouwde persistentie en human-in-the-loop checkpoints wilt
• Je meerdere LLM-providers in dezelfde workflow moet gebruiken

Kies CrewAI als:

• Je een intuitieve, rolgebaseerde abstractie wilt
• Je taak meerdere agents met verschillende specialisaties omvat
• Je agents nodig hebt die samenwerken en context aan elkaar doorgeven
• De grootste community en de meeste ingebouwde integraties belangrijk voor je zijn

Kies OpenAI Agents SDK als:

• Je primaire patroon het routeren van conversaties naar specialisten is
• Je guardrails nodig hebt die invoer/uitvoer parallel valideren
• Je de eenvoudigst mogelijke abstractie met minimale boilerplate wilt
• Ingebouwd tracing en observability belangrijk zijn

Kies Claude Agent SDK als:

• Je agents code moeten lezen, schrijven en uitvoeren
• Je eersteklas MCP-server-integratie wilt
• Je autonome agents nodig hebt die itereren en zichzelf corrigeren
• Je al Claude gebruikt en de diepste integratie wilt

Kun je frameworks combineren?

Ja. Een veelvoorkomend patroon is het gebruik van een framework voor orchestratie en een ander voor individuele agents:

• LangGraph voor de gehele workflow-graaf
• CrewAI voor een specifieke node die multi-agent-samenwerking vereist
• Claude Agent SDK voor codeergerelateerde subtaken via MCP
• OpenAI Agents SDK voor klantgerichte triage en routing

De frameworks sluiten elkaar niet uit. Gebruik wat past bij elk onderdeel van je systeem.

Conclusie

Elk framework maakt een duidelijke keuze:

• LangGraph optimaliseert voor controle - jij bepaalt elke overgang
• CrewAI optimaliseert voor samenwerking - agents werken als een team
• OpenAI Agents SDK optimaliseert voor eenvoud - minimale abstractie, schone handoffs
• Claude Agent SDK optimaliseert voor autonomie - geef het tools en laat het werken

De 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.