AI agents leren bouwen: een stappenplan van nul

Het pad in zes fasen

Om AI-agents vanaf nul te leren, doorloopt u zes fasen in de juiste volgorde: de concepten, uw eerste loop, tools, geheugen, loop-ontwerp en veiligheid. Bij elke fase bouwt u zelf iets met uw eigen handen. Overslaan is de meest voorkomende reden waarom mensen vastlopen, omdat een framework precies dat deel verbergt dat u had moeten zien.

Een AI-agent is een loop rond een taalmodel dat tools mag aanroepen. Die zin is het volledige onderwerp. Alles daarna is detail over wat er in de loop gaat, wat de tools mogen aanraken en hoe u de loop stopt als het misgaat. Als u de loop aan iemand anders kunt uitleggen, heeft u het geleerd. Als u alleen frameworks kunt opnoemen, heeft u dat niet.

Het onderstaande plan gaat ervan uit dat u leert door te bouwen. Lees een fase, bouw het kleine onderdeel, maak het opzettelijk kapot en ga dan verder. Een fase die u alleen heeft gelezen, is een fase die u niet heeft uitgevoerd.

Wat u daadwerkelijk nodig heeft voor fase 1

De eerlijke lijst met vereisten is kort, en korter dan de meeste cursuspagina's suggereren.

• U kunt Python of TypeScript lezen en schrijven op het niveau van een script van vijftig regels.
• U bent vertrouwd met een Linux-shell: een pakket installeren, een bestand bewerken, een logbestand lezen.
• U beschikt over een API-sleutel voor een gehost model, of een machine die lokaal een model kan draaien.

Dat is de volledige lijst. U heeft geen theorie over machine learning nodig en u hoeft geen model getraind te hebben. Niets in het werken met agents heeft te maken met gradiënten of trainingsdata. Een grafische kaart is alleen van belang als u besluit het model zelf te draaien; dit is een afzonderlijke vaardigheid die u later kunt oppikken via het hosten van Ollama op een VPS om zelf een LLM te draaien.

Wat mensen onderschatten is het shell-gedeelte. Agents falen door rechten, paden, omgevingsvariabelen en processen die geruisloos stoppen. Als een stack trace over PATH of een bestandsmodus u doet besluiten de terminal te sluiten, besteed dan eerst een weekend aan de basis van Linux. Dit bespaart u later een maand werk.

Fase 1: wat een agent is, en wat het niet is

Begin met één API-aanroep zonder loop. Verstuur een prompt, print het antwoord en bekijk de tokentellingen in de respons. U begrijpt nu de eenheid van kosten en de eenheid van latentie.

Leer vervolgens het gebruik van tools, wat het enige werkelijk nieuwe concept in dit hele vakgebied is. U beschrijft een functie aan het model als een naam, een beschrijving en een JSON (JavaScript object notation) schema voor de invoer. Het model voert zelf niets uit. Het antwoordt met een gestructureerd verzoek: roep run_command aan met deze argumenten. Uw code voert de functie uit, stuurt de uitvoer terug als een bericht en vraagt het model opnieuw om een reactie. Het model is een planner die tekst leest en tekst schrijft. Uw code is het onderdeel dat de acties uitvoert.

Een chatbot stopt na één antwoord. Een agent herhaalt die uitwisseling totdat het model niet langer om tools vraagt. Die herhaling is het enige verschil, en het is ook de reden waarom de faalmodi verschillen. Een chatbot geeft één keer een foutief antwoord. Een agent handelt meerdere keren op basis van een foutief antwoord voordat iemand het opmerkt.

Fase 2: schrijf de loop zelf, eenmalig

Begin niet met een framework. Schrijf ongeveer dertig regels Python zodat de structuur van het geheel van u is.

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

Voer het uit met python3 agent.py. Een succesvolle uitvoering print één alinea waarin uw bestandssystemen en de vrije ruimte worden benoemd, omdat het model vroeg om df -h, uw code dit uitvoerde en de tweede pass die tabel omzette in een zin. Als er niets wordt geprint, eindigde de loop voordat er een tekstblok arriveerde. Voeg print(response.stop_reason) toe in de loop en bekijk hoe de waarden veranderen.

Breek het nu bewust. Verwijder de regel tool_use_id en lees de foutmelding, want een resultaat van een tool zonder bijbehorende id wordt door de API geweigerd en dit is de meest voorkomende beginnersfout die er is. Stel een vraag waarvoor twee commando's nodig zijn en kijk hoe de loop twee keer draait. Stel een onmogelijke vraag en kijk of het opgeeft of voor eeuwig blijft draaien.

Eén waarschuwing bij dit voorbeeld. Het stuurt modeloutput rechtstreeks naar een shell met shell=True, wat acceptabel is op een testmachine die u opnieuw kunt opbouwen, maar overal elders fout is. Fase 6 lost dit op. De concepten onder de loop worden uitgebreider behandeld in uw eigen AI-agent bouwen op een VPS.

Fase 3: tools waarover de agent nog niet beschikte

Uw run_command-tool werkt, maar een echte agent heeft tools nodig die buiten de eigen omgeving treden: een ticketsysteem, een database, een repository. Het schrijven van een specifieke wrapper voor elke service en voor elke agent is niet schaalbaar.

Het Model Context Protocol (MCP) is de oplossing waar de industrie voor heeft gekozen. Een MCP-server stelt een set tools beschikbaar via een standaard transportlaag, en elke MCP-compatibele agent kan deze gebruiken zonder aangepaste koppelingen. De referentie-filesystem-server is één commando:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

Hiervoor moet Node zijn geïnstalleerd en het directory-argument is het enige pad dat de server zal benaderen. Dit is het beveiligingsmodel in het klein: de server bepaalt de grens, niet het model. Wijs een client naar deze server en uw agent krijgt de mogelijkheid om bestanden te lezen en te schrijven zonder dat u daar zelf code voor heeft geschreven. Het correct uitvoeren hiervan, onder een service-account en met de toegelichte transportkeuzes, wordt behandeld in het draaien van MCP-servers op een VPS voor AI-codeeragents.

De les van deze fase is dat het ontwerp van tools het eigenlijke werk is. Een vage beschrijving dwingt het model tot gissen. Een tool die veertigduizend tekens teruggeeft, vervuilt het contextvenster. Een tool die dingen kan verwijderen, zal uiteindelijk dingen verwijderen.

Fase 4: geheugen, wat in feite gewoon bestanden zijn

Beginners grijpen hier vaak naar een vector database. Doe dit niet, althans nog niet.

Een agent heeft geen geheugen tussen aanroepen door. U verstuurt elke keer het volledige gesprek opnieuw; dit is de reden waarom een lange sessie per beurt meer kost dan een korte. Geheugen valt daarom uiteen in twee problemen. Het eerste is wat er op dit moment in het contextvenster past. Dit beheert u door samen te vatten, door oude tool-output in te korten en door het stabiele voorvoegsel van uw prompt te cachen, zodat u slechts een fractie van de prijs betaalt. Het tweede is wat een herstart overleeft, oftewel opslag.

Voor het tweede probleem is een eenvoudig markdown-bestand dat de agent kan lezen en schrijven voor bijna elk eerste project beter dan een vector database. Geef de agent één bestand, instrueer het over het formaat, en vertel de agent om dat bestand te lezen voordat deze begint en het bij te werken wanneer er iets nieuws wordt geleerd. U behaalt hiermee het grootste deel van het voordeel en u kunt het bestand zelf openen om te zien wat uw agent gelooft. Stap pas over op embeddings en retrieval wanneer de notities niet meer in het contextvenster passen, en niet eerder.

Fase 5: de loop is het product

U kunt inmiddels een agent maken die werkt terwijl u toekijkt. Fase 5 draait om het laten werken van de agent wanneer u dat niet doet.

Vier vragen bepalen of een onbeheerde agent veilig is om alleen te laten. Wat is de trigger, zodat deze niet zonder aanleiding draait? Binnen welke grens opereert de agent, zodat een fout beperkt blijft? Hoe wordt het resultaat geverifieerd, aangezien een agent die zijn eigen werk beoordeelt altijd slaagt? Welk budget stopt de agent, in tokens of in verstreken tijd? Het bewust ontwerpen van deze vier punten is de discipline die wordt beschreven in loop engineering, en wat die definitie omvat.

De oefening: neem uw agent uit fase 2, geef deze een taak die vier of vijf stappen vereist en voeg een harde limiet toe aan het aantal iteraties. Verwijder daarna de limiet en observeer wat een onbegrensde loop doet met uw tokenverbruik. Doe dit één keer met een klein budget, zodat u dit nooit per ongeluk met een groot budget doet.

Fase 6: veiligheid, geheimen en kosten

Deze fase is niet optioneel en staat alleen als laatste omdat u het risico pas echt voelt nadat u iets heeft gebouwd dat werkt.

Voer de agent uit als een eigen gebruiker zonder privileges, nooit als root en nooit onder uw eigen account, zodat de impact beperkt blijft tot een map in plaats van de gehele machine. Houd inloggegevens buiten het bereik van het model, aangezien alles wat in het contextvenster staat via een tool-aanroep kan worden herhaald. De oplossing is het gebruik van kortstondige tokens achter een helper, zoals beschreven in geheimen buiten uw AI-agents houden. Stel een harde limiet in op de uitgaven, aangezien een onbeheerde lus elke iteratie factureert zonder dat er iemand toekijkt. De limieten en batchverwerking die dit beheersbaar houden, staan in AI-agent kostenbeheersing op een altijd actieve VPS.

Kosten verdienen één concreet getal. Per juli 2026 factureert Claude Opus 5 $5 per miljoen input-tokens en $25 per miljoen output-tokens. Een spraakzame agent die een groeiend gesprek opnieuw verstuurt, kan enkele honderden duizenden tokens door een enkele taak jagen. Prompt-caching en een kleiner model voor routinematige stappen veranderen die berekening veel sterker dan enige aanpassing aan de prompt.

Prompt-injectie hoort hier ook thuis. Als uw agent een webpagina, een issue-tracker of een inbox leest, dan schrijft degene die die tekst heeft geschreven ook instructies aan uw agent. De verdediging is geen slimmere systeemprompt. De verdediging is de grens, want een agent die geen repository kan verwijderen, kan er ook niet toe worden overgehaald om er een te verwijderen.

Welk curriculum moet u volgen?

Kies één curriculum en rond dit af in plaats van zes verschillende te proberen. De Microsoft ai-agents-for-beginners repository is de meest complete gratis optie; een cursus van achttien lessen die in juli 2026 de grens van 70.000 sterren is gepasseerd en die naadloos aansluit op de bovenstaande fasen. Overzichten van populaire agent-repositories zijn nuttig om te zien wat er bestaat, maar ze zijn minder geschikt als lesplan, omdat een lijst gesorteerd op sterren gebaseerd is op populariteit en niet op een logische leervolgorde.

Wanneer u een echt project zoekt om mee te oefenen, is een coding agent het beste eerste doel: de feedback is direct, de tools zijn duidelijk en fouten zijn eenvoudig te herstellen. Een coding AI agent draaien op een VPS doorloopt dit proces van begin tot eind. Als u liever werkende systemen bestudeert dan vanaf nul opbouwt, laat de vergelijking in de beste self-hosted AI agents zien hoe verschillende projecten dezelfde lus op uiteenlopende manieren oplossen.

Hoe lang duurt dit?

Voor iemand die al programmeert, kosten fase 1 en 2 één avond. Fase 3 kost een weekend, waarbij de meeste tijd gaat zitten in de beschrijvingen van tools in plaats van in het protocol. Fase 4 en 5 vergen enkele weken van daadwerkelijk gebruik, omdat u pas leert wat uw agent vergeet door te observeren wanneer hij het vergeet. Fase 6 is nooit echt af, in de zin dat elke nieuwe functionaliteit die u toevoegt deze fase weer opent.

Twee maanden aan consistente avonden brengt de meeste mensen tot een werkende, begrensde en nuttige agent. Degenen die er een jaar over doen, zijn meestal degenen die bleven lezen in plaats van bouwen.

FAQ

Moet ik machine learning kennen om een AI-agent te bouwen?

Nee. Het bouwen van een agent betekent dat u een model aanroept via een API en de verzoeken voor tools koppelt aan echte functies; dit is reguliere applicatieontwikkeling. U komt nooit in aanraking met training, gradiënten of datasets. De vaardigheden die bepalen of uw agent werkt, zijn het ontwerpen van schema's voor tools, foutafhandeling en Linux-rechten. Theorie over machine learning wordt pas relevant als u een model gaat finetunen, wat een andere taak is met andere vereisten.

Moet ik beginnen met een framework zoals LangChain of CrewAI?

Schrijf eerst één rauwe lus en stap daarna pas over op een framework. Een framework vervangt de dertig regels uit fase 2 door een configuratieobject; dit is handig zodra u weet wat het vervangt, maar verwarrend als u dat nog niet weet. Wanneer uw agent zich misdraagt, moet u direct kunnen redeneren over de berichtenlijst en de resultaten van de tools, en dat is veel lastiger als u deze nog nooit hebt gezien. Na één eigen lus bespaart een framework u tijd in plaats van dat het de werking verbergt.

Hoeveel kost het om AI-agents te leren?

Minder dan de meeste mensen verwachten, mits u een limiet instelt. Een gehoste API-sleutel en een kleine VPS dekken alles in deze zes fasen. Het werkelijke risico is niet het uurtarief, maar een onbegrensde lus die elke iteratie factureert terwijl u slaapt. Stel op de eerste dag een harde bestedingslimiet in op uw API-account, voeg een iteratielimiet toe aan elke lus die u schrijft en gebruik een goedkoper model voor routinestappen. Het lokaal draaien van het model elimineert de tokenkosten, maar vereist wel specifieke hardware.

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

Een chatbot geeft één antwoord. Een agent herhaalt een cyclus: het model vraagt om een tool, uw code voert deze uit, het resultaat gaat terug en het model bepaalt wat de volgende stap is. Die herhaling stelt een agent in staat om een taak met meerdere stappen te voltooien, en het is ook de reden waarom agents grenzen nodig hebben die chatbots niet hebben. Een fout antwoord van een chatbot is een slechte alinea. Een fout antwoord van een agent is een slechte alinea plus alles wat de agent op basis daarvan heeft ondernomen.