AI agent frameworks: LangGraph, CrewAI en OpenAI Agents SDK

Update (9 november 2026): Claude Fable 5.2 en Mythos 5.2 zijn uit - prijzen, toegang en benchmarks in mijn gids over Claude Fable 5.2.

👁 114 keer gelezen

Ik heb exact dezelfde AI-agent vijf keer gebouwd: zonder framework, met OpenAI Agents SDK, LangGraph, CrewAI en Claude Agent SDK. Elke versie kreeg dezelfde drie tools en dezelfde opdracht, waarna ik de regels code, doorlooptijd, het aantal modelaanroepen en de API-kosten heb gemeten. De korte conclusie: voor leerdoeleinden en eenvoudige agents volstaat een eigen loop of de OpenAI Agents SDK; LangGraph blinkt uit bij complexe workflows; CrewAI is ideaal voor teams van agents met afzonderlijke rollen; en de Claude Agent SDK past het best wanneer een agent direct op bestanden moet werken, vergelijkbaar met Claude Code. Dit artikel maakt deel uit van de serie AI-agents vanaf de basis.

De testopdracht

De taak van de agent is het berekenen van de totale uitgaven aan facturen in de map dane/. Het testmateriaal bevatte Poolse facturen en een factuur van 120 EUR, waarbij vreemde valuta via een wisselkoers-API omgerekend moesten worden. De tools zijn voor alle implementaties identiek en ondergebracht in een apart modulebestand. We hebben de agent in het Pools getest:

• szukaj_plikow: leest de inhoud van .txt-bestanden uit de gegevensmap;
• kalkulator: veilige evaluatie van wiskundige expressies;
• czytaj_strone: ophalen van webpagina’s of API-antwoorden.

"""Gemeenschappelijke tools voor alle agent-versies (reguliere Python-functies, framework-onafhankelijk)."""
import ast, operator, pathlib
import requests
from bs4 import BeautifulSoup

KATALOG = (pathlib.Path(__file__).parent.parent / "dane").resolve()
# Vertaalde weergave van de geteste Poolse prompt:
ZADANIE = ("Bereken hoeveel ik in totaal heb uitgegeven aan facturen in de map dane. "
           "Reken de factuur in euro's om via de actuele NBP-wisselkoers.")
INSTRUKCJA = ("Los de taak op met tools. Wisselkoersen: https://api.nbp.pl/api/exchangerates/rates/a/{kod}/?format=json. "
              "Berekeningen altijd uitvoeren met de rekenmachine. Antwoord kort.")

def szukaj_plikow(fraza: str = "") -> str:
    """Toont .txt-bestanden uit dane/ en hun inhoud. Lege zoekterm = alle bestanden."""
    out = [f"== {p.relative_to(KATALOG)} ==\n{p.read_text(encoding='utf-8')[:1500]}"
           for p in sorted(KATALOG.rglob("*.txt")) if fraza.lower() in p.read_text(encoding="utf-8").lower()]
    return "\n".join(out) or "geen bestanden gevonden"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def kalkulator(wyrazenie: str) -> str:
    """Berekent een rekenkundige expressie, bijv. 2214+1180.8."""
    def licz(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](licz(n.left), licz(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](licz(n.operand))
        raise ValueError("alleen getallen en + - * /")
    return str(round(licz(ast.parse(wyrazenie, mode="eval").body), 4))

def czytaj_strone(url: str) -> str:
    """Haalt de tekst van een webpagina of API-antwoord op."""
    r = requests.get(url, timeout=20, headers={"User-Agent": "agent-starter/1.0"})
    return BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)[:4000]

Door deze opzet meten we uitsluitend de overhead van het framework en niet de implementatie van de tools. Hoe de interne lus van een agent technisch werkt, lees je in een AI-agent bouwen in Python.

Resultaten van de meting

Prijzen omgerekend via ECB-referentiekoers van 12-10-2026 (1 EUR = 1,1181 USD):

Meetmethodiek:

• Regels code: niet-lege regels zonder commentaar en exclusief het externe toolbestand;
• Tijd: gemeten vanaf het opstarten van het Python-proces tot het eindresultaat, inclusief imports. Gemiddelde over 3 runs;
• Packages: aantal dependencies dat pip installeert bij het toevoegen van het framework (voor Python 3.13);
• Kosten: optelsom van het veld cost dat OpenRouter per API-call retourneert.

Belangrijkste inzichten:

• Bij een eenvoudige agent heeft het framework nauwelijks invloed op de tokenkosten. De runs met Luna bleven tussen € 0,0005 en € 0,0008 (0,0006 en 0,0009 USD). De OpenAI Agents SDK en CrewAI vereisten af en toe een extra aanroep (losse stappen voor de rekenmachine), wat het gemiddelde marginaal verhoogde.
• Claude Agent SDK is aanzienlijk trager en kostbaarder, wat voornamelijk toe te schrijven is aan het model. De controlemeting toont de verhouding aan: dezelfde Haiku kostte in een eigen loop 0,0071 USD (ca. € 0,0063) tegenover 0,0149 USD (ca. € 0,0133) via de Claude Agent SDK. Ongeveer de helft van dit verschil komt voort uit de runtime van Claude Code zelf (uitgebreidere systeeminstructies en ingebouwde redeneerstappen).
• CrewAI brengt de zwaarste voetafdruk met zich mee (137 packages, circa 790 MB aan schijfruimte) en heeft de langste opstarttijd. Een geïsoleerde virtual environment is aan te raden om conflicten te voorkomen.

1. Zonder framework: 16 regels code

import json, os
from openai import OpenAI
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
FUNKCJE = {f.__name__: f for f in (szukaj_plikow, kalkulator, czytaj_strone)}
TOOLS = [{"type": "function", "function": {"name": n, "description": f.__doc__, "parameters": {"type": "object",
          "properties": {p: {"type": "string"} for p in f.__annotations__ if p != "return"}}}} for n, f in FUNKCJE.items()]

messages = [{"role": "system", "content": INSTRUKCJA}, {"role": "user", "content": ZADANIE}]
for krok in range(8):
    msg = client.chat.completions.create(model=os.environ["MODEL"], messages=messages, tools=TOOLS).choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        print(msg.content); break
    for c in msg.tool_calls:
        wynik = FUNKCJE[c.function.name](**json.loads(c.function.arguments or "{}"))
        messages.append({"role": "tool", "tool_call_id": c.id, "content": wynik})

De logica is volledig transparant: het beheer van berichten, de afhandelingslus en de functieaanroepen. De tool-definities worden automatisch gegenereerd op basis van docstrings. Foutafhandeling, automatische retries bij netwerkproblemen en validatie ontbreken hier nog; in een productieomgeving vraagt dat om 30 tot 50 extra regels code, zoals beschreven in de uitgebreide agent-architectuur.

2. OpenAI Agents SDK: 10 regels code

import os
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

set_tracing_disabled(True)
model = OpenAIChatCompletionsModel(model=os.environ["MODEL"], openai_client=AsyncOpenAI(
    base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))
agent = Agent(name="Facturen", instructions=INSTRUKCJA, model=model,
              tools=[function_tool(f) for f in (szukaj_plikow, kalkulator, czytaj_strone)])
print(Runner.run_sync(agent, ZADANIE, max_turns=8).final_output)

De meest compacte en leesbare variant. De helper function_tool genereert het JSON-schema rechtstreeks uit de functiedefinitie, terwijl Runner.run_sync de uitvoeringslus aanstuurt met een beveiliging via max_turns. Je krijgt out-of-the-box functionaliteit voor handoffs tussen agents, guardrails, sessies en tracing. Bij gebruik via OpenRouter moet tracing worden uitgeschakeld en is OpenAIChatCompletionsModel vereist, aangezien de SDK standaard de Responses API van OpenAI verwacht.

3. LangGraph: 19 regels code

import os
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

narzedzia = [szukaj_plikow, kalkulator, czytaj_strone]
llm = ChatOpenAI(model=os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
                 api_key=os.environ["OPENROUTER_API_KEY"]).bind_tools(narzedzia)

def model(stan: MessagesState):
    return {"messages": [llm.invoke(stan["messages"])]}

graf = StateGraph(MessagesState)
graf.add_node("model", model)
graf.add_node("tools", ToolNode(narzedzia))
graf.add_edge(START, "model")
graf.add_conditional_edges("model", tools_condition)  # Zijn er tool-calls? -> "tools", anders -> einde
graf.add_edge("tools", "model")
agent = graf.compile()

wynik = agent.invoke({"messages": [("system", INSTRUKCJA), ("user", ZADANIE)]}, {"recursion_limit": 16})
print(wynik["messages"][-1].content)

Deze variant vereist de meeste code, omdat de state graph hier handmatig is opgebouwd in plaats van via een abstractie met één functie. Hierdoor wordt het kernconcept van LangGraph zichtbaar: state (de berichtenlijst), nodes (model, tools) en edges (beslisregels). Voor een enkelvoudige agent levert dit overhead op, maar bij complexe flows met menselijke goedkeuring (human-in-the-loop), conditionele vertakkingen en state-persistentie na crashes biedt deze grafenstructuur aanzienlijke voordelen. De maximale diepte wordt ingesteld via recursion_limit.

4. CrewAI: 10 regels code

import os
from crewai import Agent, Task, Crew, LLM
from crewai.tools import tool
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

llm = LLM(model="openrouter/" + os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
          api_key=os.environ["OPENROUTER_API_KEY"])
ksiegowy = Agent(role="Boekhouder", goal="Factuuruitgaven berekenen", backstory=INSTRUKCJA, llm=llm,
                 tools=[tool(f) for f in (szukaj_plikow, kalkulator, czytaj_strone)], max_iter=8, verbose=False)
zadanie = Task(description=ZADANIE, expected_output="Totaalbedrag met een beknopte berekening", agent=ksiegowy)
print(Crew(agents=[ksiegowy], tasks=[zadanie]).kickoff().raw)

CrewAI werkt met een rolgebaseerde architectuur: elke agent heeft een rol, een doel en een achtergrondverhaal, terwijl taken een duidelijke omschrijving en verwachte output specificeren. Voor een geïsoleerde agent voelt dit omslachtig, maar bij collaboratieve opstellingen (zoals een onderzoeker die gegevens verzamelt, een schrijver die formuleert en een redacteur die controleert) is dit model intuïtief voor niet-technische teamleden. Het model wordt gespecificeerd met een provider-prefix (hier openrouter/). CrewAI ondersteunt Python 3.10 tot en met 3.13.

5. Claude Agent SDK: 24 regels code

import asyncio, os
from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, create_sdk_mcp_server, query, tool
from narzedzia import ZADANIE, INSTRUKCJA, szukaj_plikow, kalkulator, czytaj_strone

def owin(f, param):  # Python-functie -> SDK-tool (retourneert content blocks)
    @tool(f.__name__, f.__doc__, {param: str})
    async def t(args):
        return {"content": [{"type": "text", "text": f(args.get(param, ""))}]}
    return t

serwer = create_sdk_mcp_server("facturen", tools=[owin(szukaj_plikow, "fraza"), owin(kalkulator, "wyrazenie"),
                                                 owin(czytaj_strone, "url")])
opcje = ClaudeAgentOptions(system_prompt=INSTRUKCJA, model=os.environ.get("CLAUDE_MODEL", "anthropic/claude-haiku-4.5"),
                           mcp_servers={"facturen": serwer}, strict_mcp_config=True,
                           tools=[],  # Schakel standaard Claude Code-tools uit (Bash, Edit etc.)
                           allowed_tools=["mcp__facturen__szukaj_plikow", "mcp__facturen__kalkulator",
                                          "mcp__facturen__czytaj_strone"], max_turns=8,
                           cli_path=os.getenv("CLAUDE_CLI"),  # Windows: pad naar claude.exe (niet claude.cmd)
                           setting_sources=[],  # Voorkom inlezen van ~/.claude/settings.json
                           env={"ANTHROPIC_BASE_URL": "https://openrouter.ai/api",  # Claude via OpenRouter
                                "ANTHROPIC_AUTH_TOKEN": os.environ["OPENROUTER_API_KEY"], "ANTHROPIC_API_KEY": ""})

async def main():
    async for m in query(prompt=ZADANIE, options=opcje):
        if isinstance(m, ResultMessage):
            print(m.result)
asyncio.run(main())

Deze optie vereist de meeste configuratie, omdat de Claude Agent SDK in feite de complete runtime van Claude Code als bibliotheek aanbiedt. Aangepaste functionaliteit wordt gekoppeld via een in-memory MCP-server (create_sdk_mcp_server), terwijl standaardtools (zoals bash-toegang en bestandsbewerking) expliciet zijn gedeactiveerd via tools=[]. Enkele belangrijke aandachtspunten:

• Onder Windows voert de SDK claude.cmd vanuit npm niet betrouwbaar uit; het exacte pad naar claude.exe moet via cli_path worden opgegeven;
• Zonder setting_sources=[] worden lokale instellingen uit ~/.claude/settings.json ingeladen, wat kan leiden tot 403-fouten door overschreven base-URL’s;
• Via OpenRouter communiceert Claude Code met een Anthropic-compatibel endpoint (ANTHROPIC_BASE_URL=https://openrouter.ai/api), waarbij de sleutel via ANTHROPIC_AUTH_TOKEN wordt doorgegeven.

Overzicht: welk framework kies je wanneer?

Er bestaan uiteraard meer opties in het ecosysteem: Google biedt de ADK (Agent Development Kit, versie 2.11.0 op PyPI), Hugging Face heeft smolagents (1.26.0) en Microsoft ontwikkelt het Agent Framework. Wie de voorkeur geeft aan no-code alternatieven, kan kijken naar platforms zoals n8n (met de AI Agent-node) of Gumloop.

Praktisch advies

1. Begin met het bouwen van een agent zonder framework. Eén middag experimenteren met een eigen loop bespaart je later weken aan zoekwerk naar wat een framework op de achtergrond precies uitvoert.
2. Kies voor je eerste serieuze implementatie de OpenAI Agents SDK. Deze werkt probleemloos met OpenRouter en lokale modellen met minimale boilerplate.
3. Stap over op LangGraph zodra je workflowdiagrammen met vertakkingen, herhaallussen en checkpoints op papier begint uit te tekenen.
4. Gebruik CrewAI en de Claude Agent SDK voor specifieke scenario’s: multi-agent rolverdelingen of intensieve interactie met het lokale bestandssysteem.

Veelgestelde vragen

LangChain of LangGraph?

LangChain levert de bouwstenen (modellen, tool-integraties, parsers), terwijl LangGraph de orchestratie en execution flow via grafen verzorgt. In moderne 1.x-versies maakt LangChain onder de motorkap gebruik van LangGraph voor agent-architecturen. Voor agents start je het best bij LangGraph en importeer je waar nodig specifieke integraties zoals langchain-openai.

Zijn agent frameworks gratis te gebruiken?

Alle vijf geteste bibliotheken zijn open source en gratis beschikbaar. Je betaalt uitsluitend voor het daadwerkelijke tokenverbruik bij de modelaanbieder. Optionele commerciële toevoegingen omvatten platforms zoals LangSmith (observability voor LangGraph) of CrewAI Enterprise Cloud.

Welk framework werkt met lokale modellen?

Een eigen loop, de OpenAI Agents SDK, LangGraph en CrewAI functioneren naadloos met lokale servers zoals Ollama via een OpenAI-compatibele API. De Claude Agent SDK vereist specifiek Anthropic-modellen.

Verhoogt een framework de uitvoerkwaliteit van de agent?

In onze meting niet. Alle implementaties behaalden een identiek, correct eindresultaat. De redeneerkwaliteit wordt primair bepaald door het gekozen LLM, de kwaliteit van de functiebeschrijvingen en de context. Een framework biedt structuur, state-beheer en logging rondom de interactielus.

Wat kostte het uitvoeren van alle tests?

De 16 runs (15 meetruns en 1 controle-uitvoering) kostten in totaal circa € 0,054 (0,060 USD), waarvan ongeveer € 0,047 (0,052 USD) toe te schrijven was aan de Claude Haiku-aanroepen.

Waar vind je degelijk studiemateriaal?

Aanraders zijn de gratis cursussen van LangChain Academy (Intro to LangGraph) en DeepLearning.AI (AI Agents in LangGraph, Multi AI Agent Systems with crewAI), naast de officiële documentatie van de OpenAI Agents SDK en Claude Agent SDK. Meer verwijzingen vind je in de kennisbank.

Bronnen en controle

• OpenAI Agents SDK, LangChain Academy: Intro to LangGraph, CrewAI documentatie, Claude Agent SDK (gecontroleerd op 4 oktober 2026).
• Packageversies geverifieerd via PyPI op 4 oktober 2026.
• Metingen uitgevoerd op een testsysteem (Windows 11, Python 3.13) op 4 oktober 2026 tussen 13:53 en 13:57. De broncode van alle varianten is te vinden in het starterspakket onder de map frameworki/.

// lees verderOpenAI-agents kaapten Duitse website en maakten meer dan 15.000 bewerkingenAI-toolsNiet-beveiligde OpenAI-agents plaatsten 53 gebruikersafbeeldingen publiek op internetNieuwsOpenAI-agents hacken Australische overheidswebsite bij datazoektaakNieuws

Kinetyra