AI-agents vanaf nul: hoe ze werken en zelf bouwen

👁 119 keer gelezen

Een AI-agent is een programma waarin een taalmodel in een lus gereedschappen kiest, de uitvoer bekijkt en beslist wat de volgende stap is, totdat de taak is afgerond. Om je eerste agent te bouwen en echt te begrijpen wat er onder de motorkap gebeurt, doorloop je drie fasen: model-API’s, automatiseringen en agents. Op deze pagina vind je de routekaart, een leerplan van 30 dagen, code die ik op 4 oktober 2026 op mijn eigen computer heb uitgevoerd en een overzicht van de beste gratis cursussen en kanalen. Voor kleine, snelle tussenbeslissingen zijn beslissingsmodellen erg nuttig. Een kant-en-klare agent voor bedrijven werd op 8 oktober door Google gepresenteerd in het artikel over de Gemini agent.

Routekaart: van API naar je eigen agent

De meest gemaakte fout bij de start is direct in een agent-framework duiken. Dat werkt prima totdat er een fout optreedt en je geen idee hebt waar de bug zit. Daarom bestaat dit traject uit drie fasen, waarbij elke fase voortbouwt op de vorige:

Fase 1 wordt behandeld in de handleiding AI-API. Hier richten we ons op fase 2 en 3. Werk je liever visueel zonder te coderen, dan kun je fase 3 ook afronden in Gumloop of via de AI Agent-node in n8n. Het diepere inzicht ontstaat echter veel sneller zodra je de lus eenmaal in 76 regels Python-code hebt zien draaien.

Hoe een agent werkt: de lus in vier stappen

Elke agent, van een minimalistisch script tot Claude Code, volgt exact hetzelfde principe. Een LLM voert zelf niets uit: het verzoekt enkel om een gereedschap (tool), waarna jouw code die functie aanroept en de uitvoer teruggeeft.

In Python-code ziet dit er als volgt uit (fragment uit mijn agent, de volledige implementatie staat in de handleiding over het bouwen van een agent):

    for stap in range(1, MAX_STAPPEN + 1):
        r = client.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS)
        kosten += getattr(r.usage, "cost", 0) or 0
        msg = r.choices[0].message
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            print(f"--- klaar na {stap} stappen, kosten: {kosten:.5f} USD")
            return msg.content
        if msg.content: print(f"[stap {stap}] GEDACHTE: {msg.content.strip()[:300]}")
        for call in msg.tool_calls:
            args = json.loads(call.function.arguments or "{}")
            try:
                obs = TOOLS_MAP[call.function.name](**args)
            except Exception as e:
                obs = f"FOUT: {e}"
            print(f"[stap {stap}] ACTIE: {call.function.name}({json.dumps(args, ensure_ascii=False)})")
            print(f"[stap {stap}] OBSERVATIE: {obs[:160]!r}")
            log.write(json.dumps({"t": time.strftime("%H:%M:%S"), "stap": stap, "tool": call.function.name,
                                  "args": args, "observatie": obs[:500]}, ensure_ascii=False) + "\n")
            messages.append({"role": "tool", "tool_call_id": call.id, "content": obs})
    return f"Afgebroken: limiet van {MAX_STAPPEN} stappen bereikt (kosten: {kosten:.5f} USD)."

Drie kernpunten om altijd te onthouden:

• Tools zijn gewone functies voorzien van een JSON Schema-beschrijving. Dit mechanisme heet function calling.
• Elke stap stuurt de volledige chathistorie mee, waardoor de tokenkosten progressief stijgen. Beperk daarom de omvang van de tool-outputs.
• Een agent zonder staplimiet en logboek is riskant. In mijn code hanteer ik een limiet van 8 stappen en wordt elke actie weggeschreven naar een JSONL-logbestand.

Leerplan voor 30 dagen

Dit traject gaat uit van één uur studie per dag en basiskennis van Python (variabelen, functies en for-lussen). Ontbreekt die basis nog, plan dan vooraf een week in voor een introductiecursus Python.

Wat ik heb gebouwd en de bijbehorende kosten

In plaats van enkel theorie heb ik elke component lokaal gedraaid. Als standaardmodel (buiten de Claude Agent SDK) gebruikte ik openai/gpt-5.6-luna via OpenRouter (ca. 0,18 EUR (0,20 USD) per miljoen inputtokens, berekend volgens de ECB-referentiekoers van 1 EUR = 1,1181 USD per 12-10-2026). Embeddings berekende ik lokaal via Ollama op een RTX 4090.

Frameworks en tools: wat kies je wanneer?

Een uitgebreide vergelijking van de vijf codebibliotheken (regels code, latentie, kosten en dependencies) vind je in het artikel over AI-agent frameworks. Gehoste agents van OpenAI komen aan bod in OpenAI Agents API, en gespecialiseerde programmeerhulpjes in AI-agents voor code.

Praktische aandachtspunten bij meertaligheid

Mijn oorspronkelijke tests zijn uitgevoerd in het Pools: de instructies, functiebeschrijvingen, brondocumenten en antwoorden waren Pools. Grote taalmodellen gaan hier moeiteloos mee om, maar let op deze factoren:

• Documenten doorzoeken: het embedding-model moet je doeltaal uitstekend beheersen. Bij meertalige juridische teksten presteert een model als bge-m3 aanzienlijk beter dan puur op het Engels gerichte modellen (vergelijking).
• Lokale data: specifieke feestdagen, nationale bankkoersen of lokale wetgeving kent het model vaak niet betrouwbaar uit het hoofd. Bied deze gegevens altijd via een tool aan.
• Functienamen: houd functienamen in ASCII (Latijnse letters, cijfers en underscores) zonder leestekens of diakrieten, aangezien API’s speciale tekens in functienamen blokkeren.

Aanbevolen gratis cursussen en bronnen (gecontroleerd op 4.10.2026)

Hieronder vind je geverifieerde bronnen waarin de werking van API’s, automatisering en agents stap voor stap wordt uitgelegd. Alle koppelingen zijn gecontroleerd op 4 oktober 2026.

Officiële cursussen en documentatie

Engelstalige videokanalen

• freeCodeCamp: uitgebreide gratis trainingen, waaronder “AI Agents For Beginners” (3 uur, juli 2026) en “Learn Python and Build Autonomous Agents” (6 uur).
• Dave Ebbelaar: diepgaande video’s over het bouwen van AI-systemen in Python vanuit een engineering-invalshoek (RAG, FastAPI en back-end automatiseringen).
• LangChain: beknopte toelichtingen van concepten en demonstraties van LangGraph.
• Sam Witteveen: technische analyses van nieuwe modellen en agent-frameworks met praktische codevoorbeelden.
• Anthropic en OpenAI: productaankondigingen en conferentiesessies.

Mijn aanbevolen volgorde: start met het overzichtsartikel van Anthropic over agents, bestudeer vervolgens de onderstaande code, volg de Hugging Face Agents Course of Andrew Ng’s Agentic AI, en specialiseer je daarna pas in een specifiek framework.

Starterspakket agent-starter-archief

Alle broncode uit dit traject is gebundeld in één archief, inclusief Engelstalige README en een .env.example-configuratiebestand:

• 01_function_calling.py: demonstratie van functies voor weerdata, berekeningen en Wikipedia;
• 02_agent_bez_frameworka.py: minimalistische agent in 76 regels met staplimiet en logfunctionaliteit;
• 03_agent_openai_sdk.py: dezelfde logica herschreven voor de OpenAI Agents SDK;
• 04_rag.py: document-chat over PDF-bestanden met lokale embeddings in Ollama;
• 05_serwer_mcp.py: MCP-server met maatwerktools;
• 06_webhook.py: FastAPI-webhook gekoppeld aan LLM-classificatie;
• frameworki/: vergelijkende implementaties van één agenttaak in 5 frameworks;
• dane/: testbestanden en voorbeelddocumenten.

Download agent-starter-archief.zip (2,1 MB, 25 bestanden). MIT-licentie. Voeg je eigen OpenRouter-sleutel toe aan het .env-bestand en commit deze nooit naar publieke repositories.

Veelgestelde vragen

Hoe bouw je stap voor stap een AI-agent?

1. Leer betrouwbare API-aanroepen doen naar een taalmodel.
2. Implementeer function calling voor externe tools.
3. Bouw een programmalus met een strikte staplimiet.
4. Voeg uitsluitend lees- en analysefuncties toe en log elke interactie.
5. Valideer de agent tegen testcases met een bekende uitkomst.

Het volledige implementatieproces staat uitgelegd in Een AI-agent bouwen in Python.

Moet je kunnen programmeren om een agent te maken?

Nee, met no-code platforms zoals n8n, Make en Gumloop kun je agents visueel opzetten. Echter, om werkelijk te doorgronden waarom een agent ontspoort of fouten maakt, helpt het enorm om eenmaal de 70 tot 80 regels code van een basislus te ontleden.

Wat kost het om te leren werken met AI-agents?

De aanbevolen online cursussen zijn gratis toegankelijk. De API-kosten tijdens mijn tests bedroegen in totaal ca. 0,13 EUR (0,15 USD). Een starttegoed van ca. 1,79-4,47 EUR (2-5 USD) met een harde bestedingslimiet volstaat voor alle basisoefeningen.

Wat is het verschil tussen een automatisering en een AI-agent?

Bij klassieke automatisering ligt de volgorde van alle stappen vooraf vast. Bij een AI-agent bepaalt het model dynamisch welke stap volgt op basis van de uitkomst van eerdere acties. De meeste bedrijfstoepassingen zijn hybride: een vaste flow met één agentische beslisstap.

Waarmee beginnen: n8n of Python?

Zoek je snel een operationele workflow binnen bestaande softwarekoppelingen, start dan met n8n of Make. Wil je begrijpen hoe API’s, context windows en function calling technisch functioneren, kies dan voor Python.

Welk model is het meest geschikt voor een eerste agent?

Kies een snel en betaalbaar model met ondersteuning voor function calling (bij OpenRouter filterbaar via de tag “tools”). In mijn tests volstond openai/gpt-5.6-luna tegen ca. 0,18 EUR (0,20 USD) per miljoen inputtokens. Stap pas over naar zwaardere modellen wanneer de logica faalt.

Wat is MCP en is het noodzakelijk?

MCP (Model Context Protocol) is een open standaard om externe tools en databronnen uniform te koppelen aan AI-toepassingen. Het is niet verplicht voor je eerste script, maar bijzonder handig zodra je eigen tools wilt ontsluiten binnen clients zoals Claude Code of Cursor. Zie ook Een eigen MCP-server in 15 minuten en Wat is MCP?.

Kan een AI-agent lokaal draaien zonder internetverbinding?

Ja, via een lokale modelserver zoals Ollama, die een OpenAI-compatibele API biedt. Houd er rekening mee dat kleinere lokale modellen sneller fouten maken in JSON-argumenten bij tool-aanroepen.

Bronnen en controledatum

• Alle code-uitvoeringen: lokaal getest op Windows 11 met Python 3.13 en een RTX 4090 op 4 oktober 2026.
• Pakketversies geverifieerd via PyPI en npm op 4.10.2026. Prijzen van Make, Zapier en n8n gecontroleerd op officiële websites op 4.10.2026. Valutaconversie gebaseerd op de referentiekoers van de Europese Centrale Bank van 1 EUR = 1,1181 USD per 12-10-2026 (bron: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml).
• Externe leermiddelen en documentatie geverifieerd op 4.10.2026.
• Aanvullende achtergrondartikelen: Wat is een AI-agent?, AI-agents testen en evalueren, Automatiseren met AI, RAG-architectuur en Fine-tuning.

// lees verderCLAUDE.md en AGENTS.md: wat ik na 42 projecten invulMagazineEuropese steden zetten NVIDIA AI-agents in voor stadsbeheerNieuwsKling 4.0 Flash: early access vanaf 28 september, voor wie?AI-tools

Kinetyra