AI-agents leren vanaf nul: een praktisch stappenplan

Het traject in zes fasen

Als u AI-agents vanaf de basis wilt leren, doorloopt u de zes fasen in deze volgorde: de concepten, uw eerste lus, tools, geheugen, lusontwerp en veiligheid. In elke fase bouwt u zelf één onderdeel. Vooruitgaan naar een volgende fase is de meest voorkomende reden waarom mensen vastlopen. Een framework verbergt namelijk precies het onderdeel dat u moest zien.

Een AI-agent is een lus rond een taalmodel dat tools mag aanroepen. Dat is het hele onderwerp. Alles daarna gaat over wat er in de lus zit, waartoe de tools toegang mogen hebben en hoe u de lus stopt als er iets misgaat. Als u de lus aan iemand anders kunt uitleggen, hebt u de kern geleerd. Als u alleen frameworks kunt opnoemen, hebt u dat niet.

Het onderstaande plan gaat ervan uit dat u leert door te bouwen. Lees een fase, bouw het kleine onderdeel, laat het expres mislukken en ga daarna verder. Een fase die u alleen hebt gelezen, hebt u nog niet uitgevoerd.

Wat u daadwerkelijk nodig hebt vóór fase 1

De lijst met vereisten is kort en korter dan de meeste cursuspagina's doen vermoeden.

• 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 en een log lezen.
• U hebt een API-sleutel voor een gehost model of een machine waarop u een lokaal model kunt uitvoeren.

Dat is de volledige lijst. U hebt geen theoretische kennis van machine learning nodig en u hoeft geen model te hebben getraind. Bij agentwerk komen geen gradiënten of trainingsgegevens kijken. Een grafische kaart is alleen relevant als u besluit het model zelf uit te voeren. Dat is een afzonderlijke vaardigheid die u later kunt leren via Ollama hosten op een VPS om een LLM zelf te hosten.

Wat mensen onderschatten, is het shellgedeelte. Agents lopen vast door machtigingen, paden, omgevingsvariabelen en processen die stilvallen. Als u een stacktrace over PATH of een bestandsmodus ertoe brengt de terminal te sluiten, besteed dan eerst een weekend aan de basisprincipes van Linux. Dat bespaart u later een maand.

Fase 1: wat een agent is en wat niet

Begin met één API-aanroep en zonder lus. Stuur een prompt, druk het antwoord af en bekijk de tokenaantallen in de response. U begrijpt nu de kosteneenheid en de eenheid van latentie.

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

Een chatbot stopt na één antwoord. Een agent herhaalt deze uitwisseling totdat het model niet langer om tools vraagt. Dat is het volledige verschil. Daarom verschillen ook de foutscenario's. Een chatbot geeft één keer een verkeerd antwoord. Een agent handelt meerdere keren op basis van een verkeerd antwoord voordat iemand dat merkt.

Fase 2: schrijf de lus zelf, één keer

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

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. Bij een geslaagde uitvoering wordt één alinea afgedrukt met de namen van uw bestandssystemen en de beschikbare ruimte. Het model vroeg om df -h, uw code voerde dit uit en de tweede doorgang zette die tabel om in een zin. Als er niets wordt afgedrukt, is de lus beëindigd voordat er een tekstblok beschikbaar was. Voeg print(response.stop_reason) toe binnen de lus en controleer hoe de waarden veranderen.

Laat het nu bewust misgaan. Verwijder de regel tool_use_id en lees de foutmelding. Een toolresultaat zonder overeenkomende id wordt door de API geweigerd. Dit is de meest voorkomende fout bij beginners. Stel een vraag waarvoor twee opdrachten nodig zijn en controleer of de lus tweemaal wordt uitgevoerd. Stel vervolgens een onmogelijke vraag en controleer of de lus stopt of oneindig blijft draaien.

Een waarschuwing bij dit voorbeeld. Het geeft modeluitvoer met shell=True rechtstreeks door aan een shell. Dat is acceptabel op een testmachine die u opnieuw kunt opbouwen, maar is overal elders onjuist. Fase 6 behandelt dit. De concepten achter de lus worden uitgebreider behandeld in uw eigen AI-agent op een VPS bouwen.

Fase 3: tools die de agent nog niet had

Uw run_command-tool werkt, maar een echte agent heeft tools nodig die toegang bieden tot systemen buiten de eigen omgeving: een ticketsysteem, een database en een repository. Voor elke service en elke agent een aangepaste wrapper schrijven, is niet schaalbaar.

Het Model Context Protocol (MCP) is het antwoord waarop de sector zich heeft verenigd. Een MCP-server stelt een set tools beschikbaar via een standaardtransport. Elke MCP-bewuste agent kan deze gebruiken zonder aangepaste integratie. De referentieserver voor het bestandssysteem bestaat uit één commando:

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

Hiervoor moet Node zijn geïnstalleerd. Het directoryargument is het enige pad dat de server mag gebruiken. Dit is het beveiligingsmodel in het klein: de server bepaalt de grens, niet het model. Richt een client erop en uw agent krijgt mogelijkheden voor het lezen en schrijven van bestanden waarvoor u zelf geen code hebt geschreven. Hoe u dit correct uitvoert, onder een serviceaccount en met uitleg over de transportkeuzes, wordt behandeld in MCP-servers uitvoeren op een VPS voor AI-codeagents.

De les van deze fase is dat het ontwerpen van tools het echte werk is. Een vage beschrijving dwingt het model om te raden. Een tool die veertigduizend tekens retourneert, vervuilt het contextvenster. Een tool waarmee dingen kunnen worden verwijderd, zal uiteindelijk dingen verwijderen.

Fase 4: geheugen, dat grotendeels uit bestanden bestaat

Beginners grijpen hier naar een vectordatabase. Doe dat voorlopig niet.

Een agent heeft tussen aanroepen geen geheugen. U verstuurt elke keer het volledige gesprek opnieuw. Daarom kost een lange sessie per beurt meer dan een korte sessie. Geheugen valt daarom uiteen in twee problemen. Het eerste is wat nu in het contextvenster past. Dat beheert u door samen te vatten, oude tooluitvoer in te korten en het stabiele begin van uw prompt te cachen, zodat u er maar een fractie van de prijs voor betaalt. Het tweede is wat een herstart overleeft. Dat is opslag.

Voor het tweede probleem werkt een eenvoudig markdown-bestand dat de agent kan lezen en schrijven voor bijna elk eerste project beter dan een vectordatabase. Geef de agent één bestand, leg het formaat uit, laat de agent dat bestand lezen voordat hij begint en het bijwerken wanneer hij iets leert. U krijgt het grootste deel van het voordeel en kunt het bestand openen om te zien wat uw agent denkt. Gebruik embeddings en retrieval pas wanneer de notities niet meer in het contextvenster passen. Niet eerder.

Fase 5: de lus is het product

U kunt inmiddels een agent maken die werkt terwijl u meekijkt. In fase 5 zorgt u ervoor dat de agent ook werkt wanneer u niet meekijkt.

Vier vragen bepalen of u een agent veilig onbeheerd kunt laten werken. Wat activeert de agent, zodat deze niet zonder aanleiding wordt uitgevoerd? Binnen welke grenzen werkt de agent, zodat een fout beperkt blijft? Hoe wordt het resultaat gecontroleerd? Een agent die zijn eigen werk beoordeelt, keurt het immers altijd goed. Welk budget begrenst de agent, in tokens of verstreken tijd? Het bewust ontwerpen van deze vier aspecten is de discipline die wordt beschreven in lus-engineering en wat die definitie omvat.

De oefening: neem uw agent uit fase 2, geef deze een taak waarvoor vier of vijf stappen nodig zijn en voeg een harde limiet voor het aantal iteraties toe. Verwijder daarna de limiet en controleer wat een onbegrensde lus met uw tokenkosten doet. Doe dit eenmalig 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. De fase komt pas als laatste omdat u het risico pas kunt inschatten nadat u iets hebt gebouwd dat werkt.

Voer de agent uit met een eigen gebruiker zonder beheerdersrechten. Gebruik nooit root en nooit uw eigen account. Zo blijft de mogelijke schade beperkt tot een directory in plaats van een volledige machine. Houd referenties buiten het bereik van het model. Alles wat in het contextvenster staat, kan via een toolaanroep worden teruggestuurd. Gebruik daarom kortdurende tokens met een beperkte scope achter een helper, zoals beschreven in geheimen buiten uw AI-agents houden. Stel een harde bestedingslimiet in. Een onbeheerde lus brengt voor elke iteratie kosten in rekening zonder dat iemand meekijkt. De limieten en batchverwerking die dit beheersbaar houden, worden beschreven in AI-agentkosten beheersen op een always-on VPS.

Kosten verdienen één concreet getal. In juli 2026 brengt Claude Opus 5 $5 per miljoen invoertokens en $25 per miljoen uitvoertokens in rekening. Een breedsprakige agent die een groeiend gesprek telkens opnieuw verstuurt, kan voor één taak enkele honderdduizenden tokens verwerken. Caching van prompts en een kleiner model voor routinematige stappen veranderen die berekening veel sterker dan welke aanpassing aan een prompt ook.

Promptinjectie hoort hier ook bij. Als uw agent een webpagina, issue tracker of inbox leest, schrijft degene die die tekst heeft opgesteld ook instructies voor uw agent. De verdediging is niet een slimmere systeemprompt. Het is de begrenzing. Een agent die een repository niet kan verwijderen, kan er ook niet toe worden aangezet deze te verwijderen.

Welke route moet u volgen?

Kies één leertraject en voltooi dat, in plaats van zes trajecten slechts gedeeltelijk te volgen. De ai-agents-for-beginners-repository van Microsoft is de meest complete gratis optie: een cursus van achttien lessen die in juli 2026 meer dan 70,000 sterren had en goed aansluit op de bovenstaande fasen. Overzichten van populaire agent-repositories zijn nuttig om te zien wat er bestaat, maar veel minder geschikt als syllabus. Een lijst die op sterren is gesorteerd, is namelijk op populariteit gesorteerd en niet op leerorde.

Als 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 ongedaan te maken. Een coding AI agent op een VPS uitvoeren behandelt één volledig voorbeeld. Als u liever werkende systemen bestudeert dan vanaf nul bouwt, laat de vergelijking in de beste self-hosted AI-agents zien hoe verschillende projecten dezelfde lus op verschillende manieren implementeren.

Hoe lang duurt dit?

Voor iemand die al programmeert, nemen fase 1 en 2 een avond in beslag. Fase 3 duurt een weekend. Het grootste deel daarvan besteedt u aan toolbeschrijvingen en niet aan het protocol. Voor fase 4 en 5 hebt u enkele weken praktisch gebruik nodig. U leert namelijk pas wat uw agent vergeet door te observeren dat hij iets vergeet. Fase 6 is nooit helemaal afgerond. Elke nieuwe mogelijkheid die u toevoegt, maakt een nieuwe evaluatie ervan noodzakelijk.

Met twee maanden lang consequent enkele avonden werken, beschikken de meeste mensen over een werkende, afgebakende en nuttige agent. Wie er een jaar over doet, is meestal blijven lezen in plaats van bouwen.

FAQ

Moet ik machinelearning kennen om een AI-agent te bouwen?

Nee. Een agent bouwen betekent dat u via een API een model aanroept en de toolaanvragen ervan koppelt aan echte functies. Dat is gewone applicatieprogrammering. U werkt nooit met training, gradients of datasets. Of uw agent goed werkt, wordt bepaald door het ontwerpen van schema's voor tools, foutafhandeling en Linux-machtigingen. Theorie over machinelearning wordt pas relevant als u een model verder gaat fine-tunen. Dat is ander werk met andere vereisten.

Moet ik beginnen met een framework zoals LangChain of CrewAI?

Schrijf eerst één onbewerkte lus en gebruik daarna een framework. Een framework vervangt de dertig regels in fase 2 door een configuratieobject. Dat is handig zodra u weet wat het heeft vervangen, maar verwarrend als u dat nog niet weet. Wanneer uw agent zich verkeerd gedraagt, moet u rechtstreeks redeneren over de berichtenlijst en de toolresultaten. Dat is veel moeilijker als u die nog nooit hebt gezien. Na één zelfgeschreven lus bespaart een framework u tijd in plaats van dat het de werking verbergt.

Hoeveel kost het om AI-agents te leren bouwen?

Minder dan de meeste mensen verwachten, als u de kosten begrenst. Een gehoste API-sleutel en een kleine VPS zijn voldoende voor alle 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 voor uw API-account, voeg aan elke lus die u schrijft een limiet voor het aantal iteraties toe en gebruik een goedkoper model voor routinestappen. Als u het model lokaal uitvoert, vervallen de tokenkosten, maar hebt u wel geschikte hardware nodig.

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

Een chatbot geeft één keer antwoord. Een agent herhaalt een cyclus: het model vraagt om een tool, uw code voert die uit, het resultaat gaat terug en het model bepaalt wat het vervolgens doet. Door die herhaling kan een agent een taak met meerdere stappen voltooien. Daarom hebben agents ook grenzen nodig die chatbots niet nodig 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 naar aanleiding daarvan heeft gedaan.