AI-agent bouwen in Python: stap-voor-stap handleiding (76 regels)

👁 119 keer gelezen

Een AI-agent in Python is in essentie een lus: het model krijgt een taak en een lijst met tools, kiest een tool, jouw code voert deze uit, het resultaat gaat terug naar het model en het model bepaalt de volgende stap. Ik heb zo’n agent gebouwd in 76 regels code, zonder enig framework: hij doorzoekt bestanden, rekent, leest webpagina’s, hanteert een staplimiet en houdt een beslissingslogboek bij. Daarna heb ik hem herschreven naar de OpenAI Agents SDK en de Claude Agent SDK. Alle onderstaande runs zijn echt en uitgevoerd op 4 oktober 2026. Dit is de derde stap in de reeks AI-agents vanaf de basis.

Een agent kiest zelf de volgorde van de stappen

Een standaard AI-script volgt vooraf vastgelegde stappen: “haal de e-mail op, vat samen, sla op”. Het model vult slechts één tussenstap in. Bij een agent bepaalt het model zelf de volgorde van de stappen. Het krijgt een doel (“bereken de uitgaven uit de facturen”) en tools aangereikt, waarna het zelf bepaalt om eerst de bestanden te bekijken, vervolgens de wisselkoers op te vragen en tot slot het totaalbedrag op te tellen. Meer over wat een agent is en waar het mis kan gaan, lees je in het artikel AI-agent: wat is het?.

Technisch is een agent function calling in een lus. Heb je nog nooit een model via de API aangeroepen, begin dan met je eerste AI-API-aanroep in Python.

De agent-lus in vier stappen

1. Model leest de opdracht en de tot dan toe opgebouwde gespreksgeschiedenis.
2. Beslissing: vraagt om een tool (met argumenten) of stelt vast dat de taak voltooid is en formuleert het eindantwoord.
3. Tool: jouw Python-code voert de functie uit.
4. Observatie: het functieresultaat wordt toegevoegd aan de geschiedenis, en de lus begint opnieuw bij stap 1.

Daarnaast zijn er twee veiligheidsmechanismen ingebouwd waar ik nooit zonder werk: een staplimiet (zodat de agent niet eindeloos ronddraait en onnodig API-tegoed verbruikt) en een beslissingslogboek (zodat je achteraf precies weet wat de agent deed en waarom).

Stap 1: De omgeving inrichten

1. Installeer Python 3.11-3.13 via python.org (vink “Add python.exe to PATH” aan).
2. Maak een virtuele omgeving aan in de projectmap: python -m venv .venv, gevolgd door .venv\Scripts\activate.
3. Installeer de benodigde packages: pip install openai requests beautifulsoup4 python-dotenv.
4. Maak een API-sleutel aan op OpenRouter en voeg deze toe aan het bestand .env als OPENROUTER_API_KEY=.... Stel op de sleutel een kredietlimiet in, bijvoorbeeld 2 USD. Hoe OpenRouter werkt en wat het kost, lees je in OpenRouter: prijzen en verschillen tussen providers.
5. Plaats enkele tekstbestanden in de map dane/faktury (in mijn testpakket zaten fictieve facturen met verschillende valuta’s, waaronder één van 120 EUR).

Stap 2: Tools definiëren als reguliere functies

De agent krijgt de beschikking over drie tools. Elk daarvan is een gewone Python-functie die tekst retourneert:

• szukaj_plikow (zoek_bestanden) toont .txt-bestanden uit de map dane/. De agent heeft geen toegang buiten deze map;
• kalkulator (rekenmachine) voert berekeningen uit via de ast-module (zonder het onveilige eval). Taalmodellen maken nog steeds rekenfouten, dus laat je ze via een tool rekenen;
• czytaj_strone (lees_pagina) haalt een webpagina of API-antwoord op en kapt dit af op 4000 tekens, omdat elk teken als betaalde tokens terugkeert naar het model.

Stap 3: De complete agent in 76 regels

"""02 - AI-agent zonder framework: lus model -> tool -> observatie -> beslissing.
Starten via: python 02_agent_bez_frameworka.py "Bereken het totaalbedrag aan facturen in de map dane/faktury."
"""
import ast, json, operator, os, pathlib, sys, time
import requests
from bs4 import BeautifulSoup
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
MODEL, MAX_KROKOW = os.getenv("MODEL", "openai/gpt-5.6-luna"), int(os.getenv("MAX_KROKOW", 8))
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
KATALOG = pathlib.Path("dane").resolve()  # agent heeft alleen toegang tot deze map

def szukaj_plikow(fraza: str = "") -> str:
    """Toont bestanden in dane/ (met inhoud), optioneel gefilterd op een zoekterm."""
    wynik = []
    for p in sorted(KATALOG.rglob("*.txt")):
        tekst = p.read_text(encoding="utf-8")
        if fraza.lower() in tekst.lower() or fraza.lower() in p.name.lower():
            wynik.append(f"== {p.relative_to(KATALOG)} ==\n{tekst[:1500]}")
    return "\n".join(wynik) or "geen bestanden gevonden"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def kalkulator(wyrazenie: str) -> str:
    def licz(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](licz(n.left), licz(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](licz(n.operand))
        raise ValueError("alleen getallen en + - * /")
    return str(round(licz(ast.parse(wyrazenie, mode="eval").body), 4))

def czytaj_strone(url: str) -> str:
    r = requests.get(url, timeout=20, headers={"User-Agent": "helder-ai-agents-starter/1.0"})
    tekst = BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)
    return tekst[:4000]  # afkappen: lange pagina's verspillen tokens

NARZEDZIA = {"szukaj_plikow": szukaj_plikow, "kalkulator": kalkulator, "czytaj_strone": czytaj_strone}
def opis(nazwa, tekst, param, typ="string"):
    return {"type": "function", "function": {"name": nazwa, "description": tekst,
            "parameters": {"type": "object", "properties": {param: {"type": typ}}, "required": [param]}}}
TOOLS = [opis("szukaj_plikow", "Toont .txt-bestanden uit de map dane/ en hun inhoud. Lege zoekterm = alle bestanden.", "fraza"),
         opis("kalkulator", "Berekent een expressie, bijv. 2214+1180.8. Reken altijd met deze tool.", "wyrazenie"),
         opis("czytaj_strone", "Haalt webpaginatekst of een API-respons op vanaf een URL.", "url")]

def agent(zadanie: str) -> str:
    messages = [{"role": "system", "content": "Je bent een agent. Los de taak op met de beschikbare tools. Schrijf "
                 "voor elke tool-aanroep in één zin waarom je deze gebruikt. Wisselkoersen haal je op via een wisselkoers-API. "
                 "Geef een duidelijk gestructureerd antwoord."},
                {"role": "user", "content": zadanie}]
    log = open("agent_log.jsonl", "a", encoding="utf-8")
    koszt = 0.0
    for krok in range(1, MAX_KROKOW + 1):
        r = client.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS)
        koszt += 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 {krok} stappen, kosten: {koszt:.5f} USD")
            return msg.content
        if msg.content: print(f"[stap {krok}] GEDACHTE: {msg.content.strip()[:300]}")
        for call in msg.tool_calls:
            args = json.loads(call.function.arguments or "{}")
            try:
                obs = NARZEDZIA[call.function.name](**args)
            except Exception as e:
                obs = f"FOUT: {e}"
            print(f"[stap {krok}] ACTIE: {call.function.name}({json.dumps(args, ensure_ascii=False)})")
            print(f"[stap {krok}] OBSERVATIE: {obs[:160]!r}")
            log.write(json.dumps({"t": time.strftime("%H:%M:%S"), "krok": krok, "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_KROKOW} stappen bereikt (kosten: {koszt:.5f} USD)."

if __name__ == "__main__":
    print("\nRESULTAAT:\n" + agent(" ".join(sys.argv[1:]) or "Bereken de totaalbedragen van de facturen in de map dane/faktury."))

De belangrijkste onderdelen in deze code:

• for krok in range(1, MAX_KROKOW + 1) vormt de agent-lus met een harde limiet (standaard 8 stappen);
• if not msg.tool_calls: het model vraagt niet om tools, wat betekent dat het eindantwoord gegenereerd is;
• een fout in een tool stopt het programma niet, maar keert terug naar het model als observatie (“FOUT: …”). Het model herstelt dit doorgaans zelfstandig;
• elke stap wordt weggeschreven naar agent_log.jsonl (tijdstip, stap, tool, argumenten, resultaat);
• de system prompt verplicht het model om in één zin te motiveren waarom het een bepaalde tool aanroept. Dit is de zichtbare “gedachte” in het logboek, wat essentieel is voor debugging.

Run 1: Facturen en wisselkoersen via API

De run is uitgevoerd in het Pools, met de wisselkoers-API van de Poolse centrale bank (NBP); de facturen zijn in złoty. Hieronder staat de vertaling van het logboek. Voor een Nederlandse administratie gebruik je de referentiekoersen van de ECB.

> python 02_agent_bez_frameworka.py "Bereken hoeveel ik in totaal heb uitgegeven op basis van de facturen in de map dane. Reken de eurofactuur om via de koers van vandaag."
[stap 1] GEDACHTE: Eerst lees ik alle factuurbestanden uit de map `dane` en haal ik de actuele EUR-koers op via de API om de bedragen samen te kunnen voegen.
[stap 1] ACTIE: szukaj_plikow({"fraza": ""})
[stap 1] OBSERVATIE: '== faktury\\FV_2026_09_014.txt ==\nFactuur nr FV/2026/09/014 (voorbeelddata)\nFactuurdatum: 2026-09-12\nVerkoper: Voorbeeld BV\nKoper'
[stap 1] ACTIE: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[stap 1] OBSERVATIE: '{"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}'
[stap 2] GEDACHTE: Nu reken ik de factuur van 120 EUR om tegen de koers van 4,3745 en tel dit op bij de twee facturen van 2 214,00 en 1 180,80.
[stap 2] ACTIE: kalkulator({"wyrazenie": "2214+1180.8+120*4.3745"})
[stap 2] OBSERVATIE: '3919.74'
--- klaar na 3 stappen, kosten: 0.00104 USD

RESULTAAT:
In totaal heb je **3 919,74** uitgegeven.

Berekening:
- Factuur 1: 2 214,00
- Factuur 2: 1 180,80
- Factuur in EUR: 120 × 4,3745 = 524,94

Totaal: 2 214,00 + 1 180,80 + 524,94 = 3 919,74
Gebruikte EUR-wisselkoers: 4,3745 (van 2026-10-02).

De agent bepaalde zelfstandig het stappenplan: in stap 1 las hij parallel de bestanden en haalde hij de wisselkoers op via de API. In stap 2 berekende hij alles in één keer via de rekenmachine-tool. In stap 3 formuleerde hij het antwoord. Drie aanroepen van het model kostten samen 0,00104 USD.

Run 2: Webpagina combineren met lokale bestanden

(Vertaling van de oorspronkelijke testuitvoering in het Pools)

> python 02_agent_bez_frameworka.py "Lees de pagina https://pl.wikipedia.org/wiki/Model_Context_Protocol en vat in 3 punten samen waar MCP voor dient. Controleer daarna in de map dane of er een notitie met een deadline staat, en bereken hoeveel dagen er nog resten vanaf 4 oktober 2026."
[stap 1] GEDACHTE: Ik ga de opgegeven Wikipediapagina lezen om in 3 punten samen te vatten waar MCP voor dient.
[stap 1] ACTIE: czytaj_strone({"url": "https://pl.wikipedia.org/wiki/Model_Context_Protocol"})
[stap 1] OBSERVATIE: 'Model Context Protocol - Wikipedia... Ga naar navigatie Hoofdmenu vastzetten Navigatie Hoofdpagina Willekeurig artikel'
[stap 2] GEDACHTE: Ik doorzoek de map dane om een notitie met een datum of deadline te vinden.
[stap 2] ACTIE: szukaj_plikow({"fraza": ""})
[stap 2] OBSERVATIE: '== faktury\\FV_2026_09_014.txt ==\nFactuur nr...'
[stap 3] GEDACHTE: Ik bereken het verschil tussen 4 en 7 oktober 2026 om het exacte aantal dagen te bepalen.
[stap 3] ACTIE: kalkulator({"wyrazenie": "7-4"})
[stap 3] OBSERVATIE: '3'
--- klaar na 4 stappen, kosten: 0.00130 USD

RESULTAAT:
MCP dient voor:
1. Het standaardiseren van de manier waarop AI-systemen verbinding maken met externe tools en databronnen.
2. Het bieden van een universele interface voor modellen om bestanden te lezen en functies uit te voeren.
3. De integratie van AI met bedrijfsapplicaties, CRM-systemen en ontwikkelomgevingen.

In het bestand `dane/faktury/notatka.txt` staat de deadline: facturen over september naar de boekhouder sturen uiterlijk 7 oktober 2026.
Vanaf 4 oktober 2026 resteert er nog 3 dagen.

Hier combineerde de agent twee onafhankelijke bronnen. Opvallend in het logbestand: het begin van de Wikipediapagina bestaat uit menunavigatie. Met een limiet van 4000 tekens bleef er genoeg ruimte over voor de eigenlijke inhoud, maar bij langere pagina’s is het verstandig om alleen de <main>- of <article>-tag te parsen. Dat de agent 7 - 4 via de calculator berekende lijkt overdreven, maar is precies de bedoeling: het model rekent systematisch via tools in plaats van uit het hoofd.

Run 3: De agent bereikt de staplimiet

Hier werd de limiet ingesteld op 2 stappen, met een extra omrekening naar USD:

> MAX_KROKOW=2 python 02_agent_bez_frameworka.py "Bereken de uitgaven uit de facturen. Reken de eurofactuur om en bereken daarna ook het totaal in USD."
[stap 1] GEDACHTE: Eerst haal ik de inhoud van alle bestanden op en vraag ik gelijktijdig de koersen voor EUR en USD op via de API.
[stap 1] ACTIE: szukaj_plikow({"fraza": ""})
[stap 1] OBSERVATIE: '== faktury\\FV_2026_09_014.txt == ...'
[stap 1] ACTIE: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"})
[stap 1] OBSERVATIE: '{"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}'
[stap 1] ACTIE: czytaj_strone({"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"})
[stap 1] OBSERVATIE: '{"table":"A","currency":"dolar","code":"USD","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":3.8881}]}'
[stap 2] GEDACHTE: Ik reken nu de eurofactuur om en bereken het subtotaal.
[stap 2] ACTIE: kalkulator({"wyrazenie": "2214+1180.80+120*4.3745"})
[stap 2] OBSERVATIE: '3919.74'

RESULTAAT:
Afgebroken: limiet van 2 stappen bereikt (kosten: 0.00079 USD).

De agent had onvoldoende stappen, waardoor het script de lus afbrak en een nette melding gaf in plaats van oneindig door te gaan. In een productieomgeving stel ik de limiet ruimer in (8-15 stappen) en log ik bij overschrijding de volledige status zodat de taak hervat kan worden. Zo ziet het beslissingslogbestand van deze run eruit:

> type agent_log.jsonl   (laatste 3 regels)
{"t": "13:50:52", "krok": 1, "tool": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/eur/?format=json"}, "observatie": "{\"table\":\"A\",\"currency\":\"euro\",\"code\":\"EUR\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":4.3745}]}"}
{"t": "13:50:52", "krok": 1, "tool": "czytaj_strone", "args": {"url": "https://api.nbp.pl/api/exchangerates/rates/a/usd/?format=json"}, "observatie": "{\"table\":\"A\",\"currency\":\"dolar\",\"code\":\"USD\",\"rates\":[{\"no\":\"192/A/NBP/2026\",\"effectiveDate\":\"2026-10-02\",\"mid\":3.8881}]}"}
{"t": "13:50:56", "krok": 2, "tool": "kalkulator", "args": {"wyrazenie": "2214+1180.80+120*4.3745"}, "observatie": "3919.74"}

Vijf problemen die je bij agents tegenkomt

Dezelfde agent met OpenAI Agents SDK

Zodra je de basislus begrijpt, verliest een framework zijn magie. De OpenAI Agents SDK doet exact hetzelfde als mijn 76 regels Python: het model aanroepen, functies uitvoeren, de limiet (max_turns) bewaken en loggen. Tool-beschrijvingen worden automatisch gegenereerd op basis van de type-hints en docstrings via de @function_tool-decorator. Dit werkt ook met modellen van andere aanbieders via OpenRouter:

"""03 - Dezelfde agent, gebouwd met de OpenAI Agents SDK (package openai-agents).
De lus, tool-uitvoering en staplimiet worden verzorgd door de Runner.
Starten via: python 03_agent_openai_sdk.py "Bereken de uitgaven uit de facturen in map dane."
"""
import asyncio, os, sys
from dotenv import load_dotenv
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled

import importlib
narz = importlib.import_module("02_agent_bez_frameworka")  # hergebruik dezelfde functies

load_dotenv()
set_tracing_disabled(True)  # tracing stuurt telemetrie naar OpenAI - bij OpenRouter uitschakelen
model = OpenAIChatCompletionsModel(
    model=os.getenv("MODEL", "openai/gpt-5.6-luna"),
    openai_client=AsyncOpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))

@function_tool
def szukaj_plikow(fraza: str = "") -> str:
    """Toont bestanden in dane/ en hun inhoud. Lege zoekterm = alle bestanden."""
    return narz.szukaj_plikow(fraza)

@function_tool
def kalkulator(wyrazenie: str) -> str:
    """Berekent een rekenkundige expressie. Reken altijd met deze tool."""
    return narz.kalkulator(wyrazenie)

@function_tool
def czytaj_strone(url: str) -> str:
    """Haalt webpaginatekst of een API-respons op vanaf een URL."""
    return narz.czytaj_strone(url)

agent = Agent(
    name="Factuur-assistent",
    instructions="Los de taak op met de tools. Wisselkoersen via API. Geef een helder gestructureerd antwoord.",
    model=model, tools=[szukaj_plikow, kalkulator, czytaj_strone])

async def main():
    zadanie = " ".join(sys.argv[1:]) or "Bereken het totaalbedrag aan facturen in de map dane."
    wynik = await Runner.run(agent, zadanie, max_turns=8)
    for item in wynik.new_items:
        if item.type == "tool_call_item":
            print("ACTIE:", item.raw_item.name, item.raw_item.arguments)
        elif item.type == "tool_call_output_item":
            print("OBSERVATIE:", str(item.output)[:120].replace("\n", " "))
    u = wynik.context_wrapper.usage
    print(f"\nRESULTAAT:\n{wynik.final_output}\n\nmodelaanroepen: {u.requests}, tokens: {u.input_tokens} in / {u.output_tokens} uit")

asyncio.run(main())

> python 03_agent_openai_sdk.py "Bereken de totale factuuruitgaven in de map dane. Reken de eurofactuur om."
ACTIE: szukaj_plikow {"fraza":""}
ACTIE: czytaj_strone {"url":"https://api.nbp.pl/api/exchangerates/rates/a/EUR/?format=json"}
OBSERVATIE: == faktury\FV_2026_09_014.txt == Factuur nr FV/2026/09/014 Data wystawienia: 2026-09-12
OBSERVATIE: {"table":"A","currency":"euro","code":"EUR","rates":[{"no":"192/A/NBP/2026","effectiveDate":"2026-10-02","mid":4.3745}]}
ACTIE: kalkulator {"wyrazenie":"2214+1180.8"}
ACTIE: kalkulator {"wyrazenie":"120*4.3745"}
ACTIE: kalkulator {"wyrazenie":"2214+1180.8+120*4.3745"}
OBSERVATIE: 3394.8
OBSERVATIE: 524.94
OBSERVATIE: 3919.74

RESULTAAT:
In totaal heb je 3 919,74 uitgegeven.

Berekening:
- Facturen: 2 214,00 + 1 180,80 = 3 394,80
- Factuur in euro: 120 EUR × wisselkoers 4,3745 = 524,94
- Totaal: 3 394,80 + 524,94 = 3 919,74

modelaanroepen: 3, tokens: 1970 in / 323 uit

Het resultaat is identiek: 3 modelaanroepen, 1970 invoertokens en 323 uitvoertokens. Twee praktische aandachtspunten:

• set_tracing_disabled(True): de SDK probeert standaard telemetry naar OpenAI te sturen. Zonder OpenAI-sleutel op OpenRouter levert dit consolefouten op, en bij bedrijfsdata wil je dit sowieso uitschakelen;
• OpenAIChatCompletionsModel: de SDK richt zich standaard op de Responses API van OpenAI. Externe providers (waaronder OpenRouter) ondersteunen doorgaans Chat Completions, vandaar deze wrapper.

Versie op Claude Agent SDK

De Claude Agent SDK is de engine achter Claude Code, verpakt als bibliotheek. Het bevat ingebouwde tools voor bestandstoegang en de terminal; je eigen functies koppel je via een interne MCP-server. Op Windows bracht dit tijdens de tests twee specifieke valkuilen met zich mee:

• De SDK start het claude-programma als subproces en weigert om veiligheidsredenen het batchbestand claude.cmd uit te voeren dat door npm wordt aangemaakt. Je moet via cli_path direct naar claude.exe verwijzen of Claude Code native installeren;
• De SDK leest instellingen uit ~/.claude/settings.json. Als daar een aangepaste ANTHROPIC_BASE_URL in staat, gaan aanroepen daarnaartoe in plaats van naar het eindpunt in je code. Dit los je op met setting_sources=[].

Met Claude Haiku 4.5 via OpenRouter duurde de facturentaak 15-18 seconden en kostte die 0,013 tot 0,018 USD (3 runs). Mijn eigen lus zonder framework deed er met hetzelfde Haiku-model 7,1 seconden over en kostte 0,007 USD. Dat verschil ontstaat door de extra systeeminstructies en redeneerstappen van de Claude Code-engine. Daar staat tegenover dat je direct toegang hebt tot geavanceerde bestandsbewerking, permissiebeheer, sessies en subagents.

Zelf schrijven of een SDK kiezen?

• Zelf bouwen: ideaal om de basisprincipes echt te doorgronden, perfect voor lichte agents met 2-5 tools en maximale controle over elk token.
• OpenAI Agents SDK: aanbevolen wanneer je behoefte hebt aan taken overdragen tussen agents (handoffs), guardrails en ingebouwde tracing.
• Claude Agent SDK: uitstekend geschikt wanneer de agent direct in het bestandssysteem en de terminal moet opereren, vergelijkbaar met Claude Code.
• LangGraph: voor complexe workflows met vertakkingen, checkpoints en menselijke goedkeuringsstappen (“human-in-the-loop”).
• Zonder code: n8n, Make of Gumloop als je liever visueel bouwt.

Veelgestelde vragen

Moet je kunnen programmeren om een AI-agent te bouwen?

Om te begrijpen hoe het werkt, is basiskennis van code voldoende. Het script in dit artikel telt slechts 76 regels en werkt direct. Wil je liever zonder code aan de slag, kijk dan naar n8n of Gumloop.

Wat kost het draaien van een AI-agent?

Dat hangt af van het gekozen model en het aantal stappen. Mijn agent met een klein model kostte ongeveer 0,001 USD per taak, met Claude Haiku 0,007 tot 0,018 USD. Met een groot model als Claude Opus 5.5 (4 USD per miljoen invoertokens en 20 USD per miljoen uitvoertokens) loopt dat snel op. Omdat bij elke stap de hele geschiedenis opnieuw wordt meegestuurd, stijgen de kosten per stap naarmate de taak langer duurt.

Welk AI-model is het meest geschikt voor agents?

Kies een model dat uitstekende scores behaalt op function calling. Om te testen volstaat een goedkoop model via OpenRouter met het filter “tools”. Voor complexe taken met veel tussenstappen en ongestructureerde data zijn krachtigere modellen betrouwbaarder, omdat ze minder snel afwijken van het geplande stappenplan.

Kan een agent draaien op een lokaal model?

Ja. Ollama biedt een API die compatibel is met OpenAI (http://localhost:11434/v1). In de code hoef je alleen de base_url en modelnaam aan te passen. Houd er wel rekening mee dat kleinere lokale modellen sneller fouten maken in de syntaxis van tool-argumenten.

Hoe voorkom je dat een agent ongewenste acties uitvoert?

Geef de agent uitsluitend de minimaal noodzakelijke tools, bij voorkeur met alleen leesrechten. Beperk bestandstoegang strikt tot specifieke mappen (zoals in mijn voorbeeld alleen de map dane/). Bouw voor acties die data overschrijven of verzenden altijd een handmatige bevestiging in en log elke stap.

// lees verderFLUX 3 Video via API gebruiken: handleiding met Python-scriptHandleidingenWarp terminal handleiding: AI-agent, blokken en commando’sHandleidingenAI voor advocaten: tools, beroepsgeheim en regelsHandleidingen

Kinetyra