Zoekopdrachten voor 'ai agent maken' stegen met 271% in Nederland in 2024 (Google Trends). Dat is geen toeval. Developers willen weten hoe het werkt. Niet de marketingversie, niet de no-code demo met Botpress of Zapier, maar de technische uitleg die je daadwerkelijk verder brengt.
Een AI agent is een autonome softwarecomponent die een Large Language Model als redeneermotor gebruikt en beschikt over tools waarmee hij acties kan uitvoeren in de echte wereld. Het verschil met een chatbot: een chatbot antwoordt alleen, een agent handelt. Bestanden lezen, API-calls maken, databases bevragen, e-mails versturen. De agent beslist zelf welke tool wanneer nodig is om een taak te voltooien.
Ken je Python? Dan kun je vandaag nog je eerste agent bouwen. De Stack Overflow Developer Survey 2024 laat zien dat 51% van alle developers Python gebruikt, voor het vierde jaar op rij de meest populaire programmeertaal. Je hebt geen nieuw framework nodig, alleen een API-sleutel en een paar regels code.
Weet je nog niet precies wat een AI agent is? Lees dan eerst het artikel over wat AI agents zijn op Matfy. Dan valt alles in dit artikel beter op zijn plek.
TL;DR: Een AI agent maak je door een LLM te combineren met tools (functies die hij kan aanroepen) en een agentic loop die draait totdat de taak klaar is. De Claude Agent SDK en OpenAI Agents SDK verlagen de drempel enorm. Dit artikel legt de loop uit en geeft je een compleet werkend Python-voorbeeld. Geen no-code, geen abstractielagen. Alleen de technische kern.
Wat maakt een AI agent anders dan een chatbot?
Simon Willison, maker van Datasette en een van de meest gevolgde stemmen in de developer community rond AI tooling, formuleerde het scherp: "The key insight about AI agents is that they need to be able to call tools. Without tool calling, you just have a chatbot that can reason but cannot act." Dat is de kern van het onderscheid.
Een chatbot neemt input en genereert output. Klaar. Een agent heeft acties. Hij kan een API aanroepen, een bestand lezen, een database bevragen, een e-mail versturen, en beslist zelf welke actie wanneer nodig is. Dat beslisproces is wat een agent tot agent maakt.
Harrison Chase, CEO van LangChain, beschrijft het verschil zo: "Agents that can reliably use tools are fundamentally different from assistants. They're the difference between advice and action." Een agent geeft geen advies over hoe je een bestand hernoemt. Hij hernoemt het.
Dit klinkt eenvoudig, maar de implicaties zijn groot. Gartner voorspelt dat in 2028 33% van enterprise software-applicaties agentic AI bevat, vergeleken met minder dan 1% in 2024 (Gartner, Predicts 2025: Agentic AI). De overstap van chatbot naar agent is de overstap van passieve naar actieve AI-systemen.
Technisch gezien bestaat een AI agent uit vier componenten:
- Een LLM als redeneermotor
- Tools: functies die de agent kan aanroepen
- Conversation history als werkgeheugen
- Een systeemprompt die zijn rol en gedrag definieert
Meer is het niet. Er zit geen magie in een AI agent. Het is een LLM met een while-loop en toegang tot functies. Het McKinsey Global Survey on the State of AI 2024 laat zien dat 65% van organisaties generatieve AI al regelmatig gebruikt, verdubbeld ten opzichte van 33% in 2023. De meeste van die toepassingen zijn nog chatbots. De volgende stap zijn agents.
Wil je liever geen code schrijven maar toch agents bouwen? Bekijk dan het artikel over n8n uitgelegd op Matfy. Dit artikel richt zich op de code-aanpak, de developer route.
Hoe denkt en handelt een agent in de agentic loop?
De agentic loop is het herhalende uitvoeringspatroon van een AI agent: Reason (beredeneer welke actie nodig is), Act (roep de juiste tool aan), Observe (verwerk het resultaat), en dan opnieuw Reason. Deze cyclus herhaalt totdat de taak voltooid is. Het patroon is gebaseerd op het wetenschappelijk ReAct-principe (Yao et al., Princeton en Google Brain, 2022).
Concreet werkt elke iteratie van de loop zo:
- Reason: de LLM ontvangt je vraag plus de volledige conversation history. Hij denkt na: wat moet ik doen? Welke tool heb ik nodig?
- Act: de LLM geeft een tool call terug, een functienaam plus argumenten. Jouw code voert die functie uit.
- Observe: het resultaat van die functie voeg je toe aan de conversation history.
- Reason again: de LLM ziet het resultaat en beslist: klaar, of moet ik nog een tool aanroepen?
- Stop: zodra de LLM geen tools meer aanroept maar een eindantwoord geeft, stopt de loop.
Als developer kun je de agentic loop letterlijk lezen als een while True loop met een LLM als decision engine. Zolang de LLM zegt 'ik wil tool X aanroepen', draait de loop door. Zodra hij zegt 'hier is je antwoord', stopt de loop. Dat is het gehele mechanisme.
Yao et al. omschrijven het in het ReAct-paper (arxiv.org, 2022): "The agentic loop: reason, act, observe: is the minimal viable pattern every agent needs. Everything else is optimization." Alles wat je ziet in geavanceerdere agent frameworks, van planningmodules tot multi-agent orchestratie, is uitbreiding op dit basispatroon.
GitHub telde in 2024 meer dan 50.000 nieuwe repositories met het label 'ai-agent', een groei van 340% ten opzichte van 2023 (GitHub Octoverse Report 2024). Het overgrote deel van die repositories implementeert precies deze loop. De developer community heeft de shift al gemaakt. De tooling is er.
Sam Altman, CEO van OpenAI, zei bij de presentatie van de OpenAI Agents SDK in maart 2025: "In 2025, we will see AI agents doing the work of entire software engineering teams. The question is no longer whether AI can code, but whether it can plan, execute, and verify." Plan, execute, verify: dat zijn de drie fasen van de agentic loop.
Tool calling: hoe geef je een agent zijn handen?
Tool calling (ook: function calling) is het mechanisme waarmee een LLM communiceert dat hij een externe functie wil uitvoeren. De developer definieert tools als JSON schemas met naam, beschrijving en parameters. De LLM beslist wanneer en hoe hij ze aanroept op basis van de gebruikersvraag en de tool-beschrijvingen.
Denk aan tool calling als een contract tussen jou en het model: jij definieert functienaam X met parameter Y, de LLM beslist wanneer hij die functie aanroept, en jij voert hem uit en stuurt het resultaat terug. Dat contractmodel maakt tool calling minder magisch en meer ingenieurstechnisch. Precies het frame dat werkt als je het als developer benadert.
In de praktijk schrijf je een Python-functie en beschrijf je hem als JSON schema. Een simpele weerservice-tool ziet er zo uit:
# Definieer je tool als JSON schema voor de LLM
tools = [
{
"name": "haal_weer_op",
"description": "Haalt het huidige weer op voor een opgegeven stad.",
"input_schema": {
"type": "object",
"properties": {
"stad": {
"type": "string",
"description": "De naam van de stad."
}
},
"required": ["stad"]
}
}
]
# De bijbehorende Python-functie
def haal_weer_op(stad: str) -> str:
# In productie: echte API-call naar een weerdienst
return f"Het is 18 graden en bewolkt in {stad}."De LLM ziet de naam, de parameters en de description. Op basis daarvan beslist hij wanneer hij de tool aanroept. Jij voert de functie uit en stuurt het resultaat terug. Dat terugsturen is cruciaal. Vergeet je het, dan heeft de agent geen manier om zijn observatie te verwerken en gaat de loop verkeerd.
Voor geavanceerdere tool-ecosystemen bestaat er MCP, het Model Context Protocol. Maar tool calling via SDK is de fundering waarop alles rust. Lees het artikel over het MCP protocol op Matfy als je wilt begrijpen hoe tools als herbruikbaar ecosysteem kunnen worden gedeeld tussen agents.
De AI agent markt groeit van 7,8 miljard dollar in 2024 naar een verwachte 52,7 miljard dollar in 2030, een samengestelde jaarlijkse groei van 46,3% (MarketsandMarkets AI Agents Market Report 2024). Een groot deel van die groei is direct gebonden aan de adoptie van tool calling als standaardmechanisme voor agentic systemen.
Welke SDK gebruik je om een AI agent te maken?
Er bestaat geen Nederlandstalige bron die de drie grote SDK-opties eerlijk vergelijkt. Dat is een probleem, want de SDK-keuze is een projectkeuze, geen persoonlijke voorkeur. Hier is de vergelijking die tot nu toe ontbrak.
| Criteria | OpenAI Agents SDK | Claude Agent SDK | LangChain |
|---|---|---|---|
| Beginner-friendly | ✓ Minimale boilerplate (~20 regels) | ✓ Goed gedocumenteerd | ~ Steilere leercurve |
| Model support | OpenAI + compatible APIs | Claude modellen | ✓ Alle grote modellen |
| Licentie | Apache 2.0 (open-source) | MIT (open-source) | MIT (open-source) |
| Multi-agent | ✓ Ingebouwde handoffs | ✓ Subagents | ✓ LangGraph |
| Observability | ~ Basislogging | ✓ Hooks voor logging | ✓ LangSmith |
| Aanbevolen voor | Quick prototypes, beginners | Productie-agents, complexe taken | Model-agnostic systemen |
De OpenAI Agents SDK (uitgebracht maart 2025, Apache 2.0 gelicenseerd) is de keuze voor beginners en snelle prototypes. Je hebt een werkende agent in zo'n 20 regels Python. Als je al een OpenAI API-sleutel hebt, is dit het startpunt met de minste wrijving.
De Claude Agent SDK is de keuze voor productie-agents met complexe redeneerloops. Claude 3.5 Sonnet scoort 49% op SWE-bench Verified, het hoogste van alle modellen voor complexe codetaken (Anthropic Model Card, oktober 2024). Als je agent meerdere stappen moet plannen en uitvoeren in een complexe workflow, is dit je model.
LangChain heeft meer dan 25 miljoen maandelijkse downloads op PyPI in 2024 en is het meest gebruikte AI agent framework (PyPI Stats 2024). Maar voor beginners is het vaak overkill. De abstractielagen helpen als je al weet wat je doet, niet als je het patroon nog aan het leren bent.
In de code-voorbeelden verderop gebruiken we de Anthropic API direct, zonder de Claude Agent SDK abstractielaag. Zo zie je precies wat er gebeurt in de loop. Als je de SDK wilt gebruiken, werkt het principe identiek maar met minder boilerplate.
Hoe bouw je een AI agent in Python?
Hoe bouw je je eerste werkende AI agent in Python?
Genoeg theorie. Hieronder staat een complete werkende AI agent in Python. Geen Claude Agent SDK abstractielaag, want je moet zien wat er echt gebeurt. Dit is de minimale implementatie: een LLM, een tool, en de agentic loop.
Stap 1: installeer de library en stel je API-sleutel in.
# Installeer via pip:
# pip install anthropic
import anthropic
import os
import json
# Stel je API-sleutel in als environment variable:
# export ANTHROPIC_API_KEY="jouw-sleutel-hier"
client = anthropic.Anthropic()Stap 2: definieer je tool als JSON schema. Dit is wat de LLM te zien krijgt. De description bepaalt wanneer hij de tool aanroept.
# Het JSON schema dat de LLM leert kennen
tools = [
{
"name": "haal_weer_op",
"description": "Haalt het huidige weer op voor een opgegeven stad.",
"input_schema": {
"type": "object",
"properties": {
"stad": {
"type": "string",
"description": "De naam van de stad."
}
},
"required": ["stad"]
}
}
]
# De Python-functie die de tool uitvoert
def haal_weer_op(stad: str) -> str:
# In productie: echte API-call naar een weerdienst
return f"Het is 18 graden en bewolkt in {stad}."Stap 3: schrijf de agentic loop. Dit is het hart van de agent. Lees de comments om te begrijpen wat elke stap doet.
def run_agent(gebruikersvraag: str) -> str:
# Gespreksgeschiedenis: het enige geheugen van de agent
gespreksgeschiedenis = [
{"role": "user", "content": gebruikersvraag}
]
# De loop draait totdat de agent klaar is
while True:
# REASON: roep de LLM aan met de volledige gespreksgeschiedenis
antwoord = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
tools=tools,
messages=gespreksgeschiedenis
)
# Controleer of de agent klaar is (geen tools meer nodig)
if antwoord.stop_reason == "end_turn":
for blok in antwoord.content:
if hasattr(blok, 'text'):
return blok.text
# ACT: voer de tool calls uit
tool_resultaten = []
for blok in antwoord.content:
if blok.type == "tool_use":
if blok.name == "haal_weer_op":
resultaat = haal_weer_op(**blok.input)
tool_resultaten.append({
"type": "tool_result",
"tool_use_id": blok.id,
"content": resultaat
})
# OBSERVE: voeg BEIDE toe aan de gespreksgeschiedenis
# Stap 1: de response van de LLM (met de tool call)
gespreksgeschiedenis.append(
{"role": "assistant", "content": antwoord.content}
)
# Stap 2: de uitkomst van de tool
gespreksgeschiedenis.append(
{"role": "user", "content": tool_resultaten}
)
# Loop gaat door: REASON again
# Test je agent
if __name__ == "__main__":
antwoord = run_agent("Wat is het weer in Amsterdam?")
print(antwoord)Dat is een complete werkende agent. Zo'n 65 regels Python inclusief comments. Kopieer dit, voeg je API-sleutel toe als environment variable, en het werkt.
De sleutel zit in de OBSERVE-stap: je voegt zowel de assistant-response met de tool call als het tool-resultaat toe aan de gespreksgeschiedenis. Vergeet je de tool-resultaten toe te voegen, dan heeft de LLM geen manier om zijn observatie te verwerken. De loop eindigt dan vroegtijdig of geeft een verkeerd antwoord. Die fout verdient een eigen sectie.
Wat onthoudt je agent en wat niet in de conversation history?
Hier is iets dat vrijwel geen Nederlands artikel uitlegt: een AI agent heeft geen persistent geheugen. Hij onthoudt niets. Zijn enige geheugen is de conversation history die jij elke iteratie van de loop meestuurt aan de LLM-API.
Elke keer dat de loop een nieuwe LLM-call maakt, stuur je de volledige gespreksgeschiedenis opnieuw mee. De LLM ziet wat er eerder in de conversatie is gezegd, niet omdat hij het onthoudt, maar omdat jij het elke keer opnieuw meestuurt. Verwijder je een bericht uit de history, dan weet de LLM er niets meer van.
Dit heeft drie grote implicaties die beginners vaak pas laat ontdekken:
- Tokenkosten groeien per iteratie: hoe langer de loop draait, hoe meer tokens je per call gebruikt. Een agent die 10 tool calls doet, stuurt bij de 10e call de complete history van alle 9 voorgaande stappen opnieuw mee.
- Context limieten zijn reëel: bij lange agents kan de history de context window van het model bereiken. Zelfs Claude met 200k tokens heeft een limiet als een agent honderden stappen uitvoert.
- State gaat verloren bij crashes: als de loop crasht, verlies je de volledige staat tenzij je de history persistent opslaat in een database of bestand.
Voor korte agents met 3 tot 5 tool calls is dit geen probleem. Voor langlopende agents die tientallen stappen uitvoeren, heb je een strategie nodig: trim de oudste berichten, gebruik summarization, of sla de state op tussen runs.
IDC voorspelt dat wereldwijde AI-uitgaven 632 miljard dollar bereiken in 2028 (IDC Worldwide AI Spending Guide, 2024). Een substantieel deel van die investering gaat naar precies deze infrastructuur: conversation state management, memory-architecturen, observability voor agents.
Welke veelgemaakte fout maak je met tool resultaten?
Er is een fout die beginners bijna altijd maken bij hun eerste agent. De code crasht niet, geen foutmelding, maar de agent werkt niet zoals verwacht. Hij geeft vage antwoorden, herhaalt tool calls, of stopt te vroeg.
De fout: je voert de tool uit, maar voegt het resultaat niet toe aan de gespreksgeschiedenis. Je loop ziet er dan zo uit:
# FOUT: tool wordt uitgevoerd maar resultaat wordt niet teruggegeven
gespreksgeschiedenis.append(
{"role": "assistant", "content": antwoord.content}
)
# Tool resultaat wordt NIET toegevoegd
# De LLM ziet zijn eigen tool call maar weet niet wat het opleverdeWat er dan gebeurt: de LLM ziet zijn eigen tool call in de history, maar geen resultaat. Hij weet niet of de tool is uitgevoerd. Afhankelijk van het model gaat hij gokken, roept hij dezelfde tool nogmaals aan, of stopt hij met een vaag eindantwoord.
De correcte versie stuurt altijd beide terug:
# CORRECT: voeg BEIDE toe aan de gespreksgeschiedenis
gespreksgeschiedenis.append(
{"role": "assistant", "content": antwoord.content} # De tool call
)
gespreksgeschiedenis.append(
{"role": "user", "content": tool_resultaten} # Het resultaat
)Dit is de OBSERVE-stap van de ReAct-loop. Zonder observe geen correct reason. De loop werkt alleen als de LLM zijn eigen acties en de gevolgen ervan kan terugzien in de context.
IBM Institute for Business Value rapporteert dat 99% van bedrijven plant AI agents te implementeren in de komende drie jaar (IBM AI Agents Research 2024). Veel van die implementaties zullen stille fouten bevatten zoals deze, totdat iemand de loop echt begrijpt. Dat is precies waarom het de moeite waard is om het patroon goed te leren voordat je het uitrolt naar productie.
Veelgestelde vragen over AI agents maken
Hoe maak je een agent in ChatGPT?
In ChatGPT kun je een agent maken via de GPT Builder, maar die optie is alleen beschikbaar voor Plus- en Team-accounts. Ga naar 'Mijn GPTs', klik 'Maak een GPT' en configureer instructies, kennis en acties. Voor een volledig autonome agent met eigen tools en code heb je de OpenAI Agents SDK en een API-sleutel nodig. ChatGPT's ingebouwde agents zijn beperkt in wat ze kunnen uitvoeren; een SDK-gebaseerde agent geeft je volledige controle over de toolset en de loop.
Hoeveel kost een AI agent?
De kosten van een AI agent bestaan uit twee delen: development (eenmalig) en API-gebruik (doorlopend). Zelf bouwen met de Claude Agent SDK of OpenAI Agents SDK kost alleen API-credits: reken op 0,01 tot 0,10 euro per agentrun, afhankelijk van de complexiteit en het model. Een simpele agent met een paar tool calls draait voor minder dan 5 euro per maand bij normaal gebruik. Schaal je op naar honderdduizenden runs, dan wordt tokenoptimalisatie relevant.
Wat zijn de zeven soorten AI-agenten?
De zeven meest gebruikte typen zijn: (1) Reflex-agent, reageert op directe input zonder intern model; (2) Model-based agent, houdt een interne toestandsrepresentatie bij; (3) Goal-based agent, plant acties om een doel te bereiken; (4) Utility-based agent, optimaliseert op een waardecurve; (5) Lerende agent, verbetert via feedback en ervaring; (6) Multi-agent systeem, meerdere agents die samenwerken; (7) Tool-using agent, het meest praktisch voor developers: gebruikt APIs en functies via tool calling om taken autonoom uit te voeren.
Hoe maak je een Copilot agent?
Een Microsoft Copilot agent maak je via Copilot Studio: ga naar copilotstudio.microsoft.com, maak een nieuwe agent, definieer topics en acties, en publiceer naar Teams of andere Microsoft-kanalen. Voor developers die meer controle willen, biedt de Azure AI Agent Service een SDK-gebaseerde aanpak met Python. Copilot Studio is ideaal voor no-code agents binnen Microsoft-ecosystemen; de Azure AI Agent Service is de keuze voor custom ontwikkeling met volledige programmatische controle.
Waar moet je mee beginnen: bouwen?
De meeste Nederlandstalige artikelen over ai agent maken sturen je naar Botpress, Zapier of Copilot Studio. Prima als je geen code wilt schrijven. Maar als je hier bent, zoek je de developer aanpak.
Dit is wat je nu weet:
- Een agent is een LLM met tools en een while-loop. Meer is het niet.
- De agentic loop (Reason, Act, Observe) is het patroon achter elke agent, van simpele scripts tot productiesystemen.
- Tool calling is het contract tussen jou en het model: jij definieert de functie, de LLM beslist wanneer hij hem aanroept.
- Conversation history is het enige geheugen van een agent. Geen magie, gewoon een lijst messages die je elke call opnieuw meestuurt.
- De veelgemaakte fout: tool resultaten niet terugsturen naar de loop. Nu weet je hoe je dat voorkomt.
McKinsey Global Institute schat dat generatieve AI jaarlijks 4,4 biljoen dollar kan toevoegen aan de wereldeconomie. Een deel van die waarde wordt gecreëerd door developers die nu leren hoe agents werken en ze in productie zetten.
Begin klein. Pak de code uit dit artikel, voeg een tweede tool toe, en kijk wat er gebeurt. Agent bouwen leer je door te doen, niet door te lezen.
Wil je verder gaan? Voor de bredere context lees je op Matfy het artikel over wat AI automatisering is en hoe het werkt in de praktijk. En voor het volgende niveau in tool-ecosystemen is er het artikel over het MCP protocol, de standaard die tool sharing tussen agents mogelijk maakt.
AI Agent Builder. Bouwt AI agents en agentic systems voor Nederlandse bedrijven bij MBWorkers. Deelt op Matfy wat hij tegenkomt in de wereld van AI.