AI in productie

AI-agents bouwen in Python: zes ontwerpregels

Een agent die in een demo zelfstandig een taak afrondt, is indrukwekkend. Een agent die dat duizend keer per week foutloos doet, vraagt om ontwerpkeuzes die je vooraf maakt.

AI in productie3 min lezenRedactie Python People

Begin bij de taak, niet bij de agent

Veel agentprojecten beginnen met de keuze voor een framework. Begin liever bij de vraag of je een agent nodig hebt. Een agent is zinvol als de stappen niet vooraf vast te leggen zijn: het model moet zelf bepalen wat de volgende stap is.

Kun je het proces als vaste workflow tekenen, bouw dan een workflow, met een taalmodel alleen op de plekken waar taal nodig is. Dat is goedkoper, sneller en veel makkelijker te testen.

Zes ontwerpregels

  1. Smalle, getypeerde tools

    Geef de agent een klein aantal tools met strikt gedefinieerde invoer, bijvoorbeeld met Pydantic-schema's. Elke tool doet één ding en controleert zijn eigen invoer.

  2. Minimale rechten

    Een agent krijgt de rechten van de gebruiker namens wie hij werkt, nooit meer. Lezen is de standaard, schrijven een bewuste uitzondering.

  3. Een mens waar het telt

    Bepaal per actie of hij omkeerbaar is. Onomkeerbare of dure acties, zoals betalen, iets naar klanten sturen of gegevens verwijderen, wachten op goedkeuring.

  4. Begrens stappen en kosten

    Stel een maximum aan het aantal stappen, de looptijd en het budget per taak. Een agent die vastloopt, stopt en meldt dat hij hulp nodig heeft.

  5. Alles traceerbaar

    Log elke stap: welke tool, met welke invoer, wat er terugkwam en waarom. Zonder die trace kun je fouten niet verklaren en dus niet verbeteren.

  6. Evalueer op taakniveau

    Meet of de taak goed is afgerond, niet of de tekst overtuigend klinkt. Test met realistische scenario's, randgevallen en kwaadwillende invoer.

Prompt injection is een ontwerpprobleem

Een agent die e-mails, documenten of webpagina's leest, kan daarin instructies tegenkomen die niet van je gebruiker komen. Dat los je niet op met alleen een betere prompt.

Behandel alles wat van buiten komt als data, niet als opdracht. Beperk wat de agent met die data kan doen, en laat gevoelige acties langs een mens of een vaste controle lopen. Dan is een geslaagde injectie hinderlijk, maar niet schadelijk.

Waarom dit loont

Gartner verwacht dat meer dan 40% van de projecten met AI-agents eind 2027 is stopgezet, door oplopende kosten, onduidelijke waarde en onvoldoende risicobeheersing. Bron: SD Times over Gartner, 30 juni 2025 (opent in nieuw tabblad)

De regels hierboven gaan precies over die punten. Ze maken een agent niet slimmer, maar wel voorspelbaar, betaalbaar en uitlegbaar. Dat is wat een agent in productie houdt.

In Python: getypeerde tools en een stapbudget

Twee van de zes regels zie je direct terug in de code: tools met een strikt schema en een harde grens aan het aantal stappen. Een vereenvoudigd voorbeeld:

from pydantic import BaseModel, Field

class ZoekOrder(BaseModel):
    """Tool: zoek een order op. Alleen lezen."""
    order_id: str = Field(pattern=r"^ORD-[0-9]{6}$")

MAX_STAPPEN = 8

def draai_agent(taak, model, tools):
    for stap in range(MAX_STAPPEN):
        actie = model.volgende_actie(taak, tools)
        if actie.klaar:
            return actie.resultaat
        tools.voer_uit(actie)  # elke stap wordt gelogd
    raise RuntimeError("Stapbudget op: taak gaat naar een mens")

In de praktijk gebruik je hiervoor een framework zoals Pydantic AI, LangGraph of de OpenAI Agents SDK, en koppel je systemen via de Python-SDK van het Model Context Protocol. Voor tracing zijn Langfuse en OpenTelemetry gangbaar. Het principe blijft hetzelfde: het framework mag wisselen, de regels niet.

Een Python-developer nodig?

Bel ons of stuur je vacature. Binnen 48 uur hoor je welke developers uit ons netwerk passen en wat het kost.