AI-agents bouwen en invoeren: zo pak je het aan

Wat is een AI-agent?

Een AI-agent is software op basis van een taalmodel die zelfstandig taken uitvoert. Hij leest bestanden, werkt in je systemen, maakt een taak af en meldt het resultaat. Een chatbot geeft antwoord in een gesprek. Een agent voert ook de handeling uit, en omdat hij zelf iets doet, moet vastliggen wat hij mag en hoe je controleert wat hij deed.

AI-agents bouwen is daarom maar voor een deel techniek. Het grootste deel is vastleggen hoe je organisatie werkt, zo precies dat een ander het kan uitvoeren.

Stap 1: kies werk dat zich herhaalt

Kies voor het eerste proces werk dat aan deze voorwaarden voldoet:

• het komt vaak terug en verloopt elke keer ongeveer hetzelfde;
• de invoer is digitaal, zoals mail, documenten of gegevens in een systeem;
• iemand kan het resultaat snel beoordelen;
• een fout is terug te draaien voordat een klant er last van heeft.

Voorbeelden die in veel sectoren passen: binnenkomende mail sorteren en beantwoorden, offerteteksten opstellen, rapportages samenstellen en gegevens tussen systemen overzetten.

Stap 2: leg per stap vast wat de agent zelf mag

Deel het proces op in stappen en geef elke stap een van drie niveaus:

• Zelf: de agent voert de stap uit en meldt wat hij deed.
• Voorstel: de agent zet de stap klaar en wacht op akkoord.
• Mens: de agent bereidt hooguit voor, een mens beslist en voert uit.

Een vuistregel die bij Growrs goed werkt: wat geld kost of naar buiten gaat, is minstens een voorstel. Wat terug te draaien is en binnen de opdracht valt, mag de agent zelf. Twijfel je, kies dan voorstel. Je kunt een stap later altijd een niveau opschuiven.

Stap 3: schrijf instructies per taak

Schrijf per taak een eigen instructie: het doel, de stappen, de uitzonderingen en wat het resultaat moet zijn. Houd de regels die voor elke taak gelden kort en apart; een lange lijst algemene regels raakt een agent halverwege kwijt.

Laat de agent alleen de instructie laden die bij zijn taak hoort, en achtergrondinformatie alleen als die instructie ernaar verwijst. Bij Growrs staan ruim negentig van zulke instructies in één repository, met een inhoudsopgave die de agent eerst leest.

Stap 4: bouw controles buiten het model

Een taalmodel kan een regel vergeten. Leg regels die je echt niet wilt zien breken daarom vast in software die buiten het model om draait. Een script dat een mail tegenhoudt tot een mens hem verstuurt, of dat een wachtwoord in een tekst blokkeert, werkt ook als het model er niet aan denkt.

Zet daarnaast een tweede agent in als tegenlezer voor werk dat naar buiten gaat. Geef die alleen het resultaat en de criteria, niet de redenering van de schrijver; anders keurt hij de redenering goed in plaats van het werk.

Vraag ten slotte bewijs. Een agent die zegt dat iets werkt, laat een testrun, een uitvoer of een bron zien. Kan dat niet, dan meldt hij dat het niet getest is.

Stap 5: geef toegang, stap voor stap

Geef een agent een eigen toegang met alleen de rechten die hij voor zijn taak nodig heeft, en nooit het account van een beheerder. Begin met lezen; schrijfrechten komen pas als de stap op het niveau zelf staat. Wachtwoorden en sleutels horen in een kluis of afgeschermd bestand, niet in de instructies en niet in het gesprek met het model.

Stap 6: train de mensen die ermee werken

De medewerkers die met agents werken, moeten twee dingen kunnen: een opdracht helder geven en het resultaat beoordelen. Leer ze ook wat ze doen als een agent iets fout doet. Een correctie in het gesprek helpt voor die ene keer; een aanpassing in de instructie voorkomt dat dezelfde fout terugkomt.

Wijs per proces een eigenaar aan die de instructies bijhoudt. Zonder eigenaar raken instructies verouderd, en een agent volgt een verouderde instructie net zo trouw als een goede.

Stap 7: meet en stuur elke week bij

Kijk elke week terug naar wat de agents deden. Bij Growrs leest een script daarvoor de sessies van de afgelopen week. We letten op werk waarvoor nog geen instructie bestond, op instructies die niet gebruikt werden en op correcties die we vaker gaven zonder dat er een regel voor is. Elke bevinding krijgt een voorstel, en in het weekoverleg besluiten we wat we aanpassen.

Pas als het eerste proces een paar weken stabiel draait, is het tijd voor het volgende.

Waarmee wij bouwen

Bij Growrs werken de agents in Claude Code. Daarin leest en schrijft een agent bestanden en voert hij commando's uit. Daaromheen staan vier dingen:

• per taak een instructiebestand, met een korte inhoudsopgave die de agent eerst leest;
• scripts die Claude Code op vaste momenten aanroept: voordat een commando draait, nadat een bestand is geschreven en voordat een sessie afsluit;
• aparte agents die werk nalezen, met alleen het resultaat en de criteria als invoer;
• n8n met Supabase voor werk dat elke keer hetzelfde verloopt en geen taalmodel nodig heeft.

Een werkinstructie hoeft niet ingewikkeld te zijn. Een algemeen voorbeeld:

Taak: opvolging van offertes klaarzetten
Doel: elke offerte die vijf werkdagen open staat, krijgt een conceptmail.
Stappen:
1. Haal de openstaande offertes op uit het CRM.
2. Schrijf per offerte een korte conceptmail in de toon van het bedrijf.
3. Zet de mail als concept klaar. Versturen doet een mens.
Uitzondering: geen mail bij een offerte met de status "in onderhandeling".
Klaar als: elke conceptmail staat klaar en de lijst staat in de taak.

Een controlescript is vaak maar een paar regels. Dit voorbeeld draait voordat een agent een commando uitvoert en houdt een sleutel in dat commando tegen:

commando = invoer["commando"]
if bevat_sleutel(commando):
    weiger("Er staat een sleutel in dit commando. "
           "Lees hem uit een afgeschermd bestand.")

Het script legt ook uit wat de agent in plaats daarvan moet doen. Zo leert de agent de juiste route, en hoeft een mens niet in te grijpen.

Veelgemaakte fouten

• Beginnen bij een tool in plaats van bij een proces.
• Alle regels in één lange instructie zetten.
• Regels die belangrijk zijn alleen in tekst vastleggen, zonder controle in software.
• Een agent zijn eigen werk laten goedkeuren.
• Een proces zonder eigenaar, zodat niemand de instructies bijhoudt.
• Te snel uitbreiden naar meerdere processen voordat het eerste stabiel draait.

Wil je zien hoe dit er in de praktijk uitziet? Lees AI-agents in de praktijk. Wil je hulp bij de invoering, kijk dan naar AI-implementatie of laat een AI-consultant bij je meewerken.