AI agents leren vanaf nul: een praktisch stappenplan

Het pad in zes fasen

Om AI-agents vanaf nul te leren, doorloopt u de 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 datgene verbergt wat u had moeten zien.

Een AI-agent is een loop rond een taalmodel dat tools mag aanroepen. Die zin vormt het volledige onderwerp. Alles wat daarna komt, is een detail over wat er in de loop gaat, wat de tools mogen aanraken en hoe u de loop stopt wanneer het misgaat. Als u de loop aan iemand anders kunt uitleggen, hebt u het 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, maak het opzettelijk kapot en ga dan verder. Een fase die u alleen hebt gelezen, is een fase die u niet hebt 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 een lokaal 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 het aantal tokens in de respons. U begrijpt nu wat de eenheid van kosten en de eenheid van latentie is.

Leer vervolgens werken met tools. Dat is het enige werkelijk nieuwe idee 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 voert de handelingen uit. De code aan uw kant van die uitwisseling krijgt een naam zodra u ontwerpen gaat vergelijken: dit is het agent-harnas, de lus, de tools en de machtigingen rond een model dat zelf geen van deze zaken heeft.

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 dat 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 lus 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 geslaagde uitvoering print één alinea waarin uw bestandssystemen en hun vrije ruimte worden benoemd, omdat het model om df -h vroeg, uw code dit uitvoerde en de tweede doorgang die tabel omzette in een zin. Als er niets wordt geprint, eindigde de lus voordat er een tekstblok arriveerde. Voeg print(response.stop_reason) toe in de lus en bekijk hoe de waarden veranderen.

Breek het nu bewust. Verwijder de regel tool_use_id en lees de foutmelding, want een toolresultaat zonder bijbehorende id wordt door de API geweigerd en dit is de meest voorkomende fout bij beginners. Stel een vraag waarvoor twee commando's nodig zijn en zie hoe de lus twee keer wordt uitgevoerd. Vraag iets onmogelijks en kijk of het opgeeft of oneindig blijft draaien.

Eén waarschuwing bij dit voorbeeld. Het stuurt modeluitvoer rechtstreeks naar een shell met shell=True, wat acceptabel is op een testmachine die u opnieuw kunt opbouwen, maar overal elders onjuist is. Fase 6 lost dit op. De concepten onder de lus 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, voor elke agent, is niet schaalbaar.

Het Model Context Protocol (MCP) is de standaard 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 vereist slechts éé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 hiernaar en uw agent krijgt de mogelijkheid om bestanden te lezen en te schrijven die u zelf niet heeft geprogrammeerd. Het correct uitvoeren hiervan, onder een service-account en met de toegelichte transportkeuzes, wordt behandeld in MCP-servers draaien op een VPS voor AI-coding-agents. Voor een tweede server die naar echte data wijst in plaats van naar een tijdelijke directory, bevat openGym zelf hosten, een workout-tracker een read-only variant, zodat u kunt oefenen met het stellen van vragen over uw eigen trainingsgeschiedenis zonder de agent toegang te geven tot zaken die hij kan beschadigen.

De les van deze fase is dat het ontwerp van de 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 zaken kan verwijderen, zal uiteindelijk zaken verwijderen.

Fase 4: geheugen, wat meestal gewoon bestanden zijn

Beginners grijpen hier naar een vectordatabase. Doe dat niet, in ieder geval nog niet.

Een agent heeft geen geheugen tussen aanroepen door. U verstuurt elke keer het volledige gesprek opnieuw, wat de reden is dat 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, en dat is opslag.

Voor het tweede probleem is een simpel markdown-bestand dat de agent kan lezen en schrijven voor bijna elk eerste project beter dan een vectordatabase. Geef de agent één bestand, vertel het de structuur, instrueer het om dat bestand te lezen voordat het begint en het bij te werken wanneer het iets leert. U behaalt 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 alleen gelaten kan worden. Wat activeert de agent, zodat deze niet onnodig draait. Binnen welke grens opereert de agent, zodat een fout beperkt blijft. Hoe wordt het resultaat geverifieerd, omdat een agent die zijn eigen werk beoordeelt altijd slaagt. Welk budget stopt de agent, in tokens of in verstreken tijd. Het doelbewust 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 tokenrekening. 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 pas aan het einde omdat u het risico pas voelt zodra u iets heeft gebouwd dat werkt.

Voer de agent uit als een eigen gebruiker zonder privileges, nooit als root en nooit als 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, want alles wat zich in het contextvenster bevindt, kan via een tool-aanroep 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.

Als uw agent in een harness draait in plaats van in een script dat u zelf heeft geschreven, is een deel van deze fase configuratie in plaats van code. De DeepSeek Harness-plugins die het installeren waard zijn dekken grotendeels hetzelfde terrein met budgetlimieten, regels voor tool-rechten en scans op injecties.

Kosten verdienen één concreet getal. Sinds 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, schrijft degene die die tekst heeft geschreven ook instructies aan uw agent. Zoekopdrachten op het web zijn meestal de tool die deze deur als eerste opent, en een agent koppelen aan uw eigen SearXNG-instantie toont de configuratie en het injectie-oppervlak dat dit creëert in samenhang. De verdediging is geen slimmere systeem-prompt. Het 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 zijn minder geschikt als syllabus, omdat een lijst gesorteerd op sterren gebaseerd is op populariteit in plaats van op een didactische volgorde.

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 het beschrijven 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 mogelijkheid die u toevoegt deze fase opnieuw 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 het aanroepen van een model via een API en het koppelen van de tool-verzoeken aan echte functies; dit is reguliere applicatieprogrammering. 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. Machine learning-theorie 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 loop 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 nooit eerder heeft gezien. Na één eigen loop bespaart een framework u tijd in plaats van het mechanisme te verbergen.

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 loop 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 loop die u schrijft en gebruik een goedkoper model voor routinestappen. Het lokaal draaien van het model elimineert de token-rekening en vervangt deze door een hardwarevereiste.

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 deze uit, het resultaat gaat terug en het model beslist 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.