Hoe bouw je een AI-agent? [Video en quiz]

Kort antwoord: Om een ​​AI-agent te bouwen die in de praktijk werkt, moet je deze behandelen als een gecontroleerde lus: ontvang invoer, bepaal de volgende actie, roep een tool met een beperkte reikwijdte aan, observeer het resultaat en herhaal dit totdat een duidelijke "klaar"-controle is geslaagd. De agent is nuttig wanneer de taak uit meerdere stappen bestaat en toolgestuurd is; als één prompt de taak oplost, sla de agent dan over. Voeg strikte toolschema's, staplimieten, logging en een validator/criticus toe, zodat de agent, wanneer tools falen of invoer dubbelzinnig is, de volgende stap zet in plaats van in een lus te blijven hangen.

Belangrijkste conclusies:

Controllerlus: Implementeer een herhaling van invoer → actie → observatie met expliciete stopvoorwaarden en maximale stappen.

Ontwerp van tools: Houd tools beperkt, getypeerd, voorzien van toegangsrechten en gevalideerd om chaos te voorkomen waarbij tools zomaar alles kunnen doen.

Geheugenhygiëne: gebruik compacte kortetermijngeheugenopslag in combinatie met langetermijngeheugenopslag; vermijd het opslaan van volledige transcripten.

Bescherming tegen misbruik: Voeg whitelists, snelheidslimieten, idempotentie en een "dry-run" toe voor risicovolle acties.

Testbaarheid: Stel een reeks scenario's samen (fouten, onduidelijkheden, injecties) en voer deze bij elke wijziging opnieuw uit.

---

1) Wat een AI-agent is, in begrijpelijke taal 🧠

Een AI-agent is een lus. LangChain "Agents"-documentatie

Dat is alles. Een lus met een brein in het midden.

Input → denken → handelen → observeren → herhalen. ReAct-papier (redeneren + handelen)

Waar:

• Input is een gebruikersverzoek of een gebeurtenis (nieuwe e-mail, supportticket, sensormelding).

• Denken is een taalmodel dat redeneert over de volgende stap.

• Act is het aanroepen van een tool (interne documentatie doorzoeken, code uitvoeren, een ticket aanmaken, een antwoord opstellen). OpenAI-handleiding voor het aanroepen van functies

• Observe leest de uitvoer van de tool.

• Het herhalen van de code zorgt ervoor dat het "agentisch" aanvoelt in plaats van "praatgraag". LangChain "Agents"-documentatie

Sommige agenten zijn in feite slimme macro's. Andere gedragen zich meer als een junior operator die meerdere taken tegelijk kan uitvoeren en fouten kan herstellen. Beide zijn waardevol.

Je hebt ook geen volledige autonomie nodig. Sterker nog… waarschijnlijk wil je dat niet eens 🙃

---

2) Wanneer je een agent moet bouwen (en wanneer niet) 🚦

Bouw een agent wanneer:

• Het werk bestaat uit meerdere stappen en verandert afhankelijk van wat er halverwege gebeurt.

• Voor deze functie is het gebruik van tools vereist (databases, CRM's, code-uitvoering, bestandsgeneratie, browsers, interne API's). Zie de LangChain "Tools"-documentatie.

• Je wilt herhaalbare resultaten met vangrails, niet zomaar eenmalige antwoorden.

• Je kunt "klaar" zo definiëren dat een computer het kan controleren, zij het in grote lijnen.

Bouw geen agent wanneer:

• Een simpele vraag plus antwoord is voldoende (maak het niet te ingewikkeld, anders krijg je er later spijt van).

• Je hebt perfect determinisme nodig (agenten mogen enigszins consistent zijn, maar niet robotachtig).

• Als je geen hulpmiddelen of gegevens hebt om verbinding te maken, dan draait het vooral om gevoel.

Laten we eerlijk zijn: de helft van de "AI-agentprojecten" zou een workflow met een paar vertakkingsregels kunnen zijn. Maar ja, soms is de sfeer ook belangrijk 🤷♂️

---

3) Wat maakt een goede versie van een AI-agent ✅

Hier is het gedeelte 'Wat maakt een goede versie van' waar je om vroeg, alleen zal ik er wat directer over zijn:

Een goede versie van een AI-agent is niet degene die het hardst nadenkt. Het is degene die:

• Weet wat het wel en niet mag doen (bereikgrenzen)

• Maakt betrouwbaar gebruik van tools (gestructureerde aanroepen, herhaalpogingen, time-outs) OpenAI Function calling guide AWS “Timeouts, retries, and backoff with jitter”

• Houdt de status schoon (geheugen dat niet veroudert) LangChain "Geheugenoverzicht"

• Legt zijn acties uit (audit trails, geen geheime redeneringen) NIST AI RMF 1.0 (betrouwbaarheid en transparantie)

• Stopt op de juiste momenten (voltooiingscontroles, maximale stappen, escalatie) LangChain “Agents”-documentatie

• Faalt veilig (vraagt ​​om hulp, hallucineert geen autoriteit) NIST AI RMF 1.0

• Is testbaar (je kunt het uitvoeren met vooraf gedefinieerde scenario's en de resultaten beoordelen)?

Als je agent niet getest kan worden, is het eigenlijk een gokautomaat met enorm veel zelfvertrouwen. Leuk op feestjes, maar doodeng tijdens een productie 😬

---

4) De belangrijkste bouwstenen van een agent (de “anatomie” 🧩)

De meeste vaste stoffen bevatten de volgende onderdelen:

A) De controllerlus 🔁

Dit is de orkestrator:

• doel stellen

• vraag het model naar de volgende stap

• uitvoeren tool

• observatie toevoegen

• Herhaal dit totdat het klaar is. LangChain “Agents” documentatie

B) Hulpmiddelen (oftewel mogelijkheden) 🧰

De tools maken een agent effectief: LangChain "Tools" documentatie

• databasequery's

• e-mails versturen

• bestanden ophalen

• uitvoerende code

• interne API's aanroepen

• Schrijven naar spreadsheets of CRM-systemen

C) Geheugen 🗃️

Twee soorten zijn van belang:

• Kortetermijngeheugen: de huidige uitvoeringscontext, recente stappen, huidig ​​plan

• Langetermijngeheugen: gebruikersvoorkeuren, projectcontext, opgehaalde kennis (vaak via embeddings + een vectoropslag) RAG-document

D) Planning- en besluitvormingsbeleid 🧭

Ook al noem je het geen 'planning', je hebt een methode nodig:

• checklists

• ReAct-achtig "denk-en-doe"-hulpmiddel : ReAct-papier

• taakgrafieken

• patronen tussen leidinggevenden en werknemers

• supervisor-werknemer patronen Microsoft AutoGen (multi-agent framework)

E) Leuningen en evaluatie 🧯

• toestemmingen

• veilige toolschema's OpenAI gestructureerde outputs

• uitvoervalidatie

• stapgrenzen

• logboek

• tests NIST AI RMF 1.0

Ja, het is meer techniek dan prompting. Wat... eigenlijk ook de bedoeling is.

---

5) Vergelijkingstabel: populaire manieren om een ​​agent te bouwen 🧾

Hieronder een realistische "vergelijkingstabel" - met een paar eigenaardigheden, want echte teams zijn nu eenmaal eigenzinnig 😄

Hulpmiddel / Kader	Publiek	Prijs	Waarom het werkt	Notities (kleine chaos)
LangChain	bouwers die van Lego-achtige onderdelen houden	vrijwel gratis + infra	Groot ecosysteem voor tools, geheugen en blockchains	Het kan snel een spaghetti-chaos worden als je de dingen niet duidelijk benoemt
LlamaIndex	RAG-zware teams	vrijwel gratis + infra	sterke zoekpatronen, indexering, connectoren	Geweldig als je makelaar in principe alleen "zoeken en handelen" doet... wat vaak voorkomt
OpenAI Assistants-achtige aanpak	teams die een snellere installatie willen	gebruiksgebaseerd	ingebouwde tool-aanroeppatronen en uitvoeringsstatus	Op sommige punten minder flexibel, maar wel overzichtelijk voor veel apps	OpenAI voert API- aanroepen uit voor OpenAI Assistants
Semantische kern	ontwikkelaars die gestructureerde orchestratie willen	min of meer gratis	een nette abstractie voor vaardigheden/functies	Het voelt "zakelijk netjes" aan - soms is dat een compliment 😉
AutoGen	multi-agent experimenten	min of meer gratis	samenwerkingspatronen tussen agenten	kunnen door elkaar heen praten; stel strikte beëindigingsregels in
CrewAI	“teams van agenten” fans	min of meer gratis	Rollen, taken en overdrachten zijn gemakkelijk uit te drukken	Werkt het beste wanneer taken duidelijk en helder zijn, niet vaag
Hooiberg	zoeken + pijplijnen mensen	min of meer gratis	solide pijpleidingen, ophalen, componenten	Minder "agententheater", meer "praktische fabriek"
Zelf oprollen (aangepaste lus)	controlefreaks (liefkozend)	jouw tijd	minimale magie, maximale helderheid	Meestal de beste investering op de lange termijn... totdat je alles opnieuw uitvindt 😅

Er is geen eenduidige winnaar. De beste keuze hangt af van de hoofdtaak van uw agent: het ophalen van gegevens, het uitvoeren van tools, de coördinatie van meerdere agentenof het automatiseren van workflows.

---

6) Stap voor stap een AI-agent bouwen (het eigenlijke recept) 🍳🤖

Dit is het gedeelte dat de meeste mensen overslaan, waarna ze zich afvragen waarom de agent zich als een wasbeer in een voorraadkast gedraagt.

Stap 1: Omschrijf de functie in één zin 🎯

Voorbeelden:

• "Stel een antwoord voor de klant op, rekening houdend met het beleid en de context van het ticket, en vraag vervolgens om goedkeuring."

• “Onderzoek een bugrapport, reproduceer het probleem en stel een oplossing voor.”

• "Zet onvolledige notulen van vergaderingen om in taken, verantwoordelijken en deadlines."

Als je het niet eenvoudig kunt definiëren, kan je agent dat ook niet. Ik bedoel, het kán wel, maar dan improviseren, en improvisatie is waar budgetten sneuvelen.

Stap 2: Bepaal je autonomieniveau (laag, gemiddeld, pittig) 🌶️

• Beperkte autonomie: er worden stappen voorgesteld, de gebruiker klikt op "goedkeuren".

• Medium: voert tools uit, stelt output op, meldt problemen bij onzekerheid.

• Hoog: voert de volledige procedure uit, er wordt alleen bij uitzondering contact opgenomen met de gebruiker.

Begin met een lagere stand dan je wilt. Je kunt het later altijd nog verhogen.

Stap 3: Kies je modelstrategie 🧠

Je kiest doorgaans:

• één sterk model voor alles (eenvoudig)

• één sterk model + kleiner model voor goedkope stappen (classificatie, routering)

• gespecialiseerde modellen (visie, code, spraak) indien nodig

Beslis ook:

• max tokens

• temperatuur

• Of je intern lange redeneersporen toestaat (dat kan, maar toon de volledige gedachtegang niet aan eindgebruikers)

Stap 4: Definieer tools met strikte schema's 🔩

De gereedschappen moeten zijn:

• smal

• getypt

• toestemming

• gevalideerde OpenAI gestructureerde outputs

In plaats van een tool genaamd do_anything(input: string), gebruik je het volgende:

• search_kb(query: string) -> results[]

• create_ticket(title: string, body: string, priority: enum) -> ticket_id

• send_email(to: string, subject: string, body: string) -> status OpenAI Functieaanroephandleiding

Als je de makelaar een kettingzaag geeft, wees dan niet verbaasd als hij daarbij ook de schutting omver zaagt tijdens het snoeien van de heg.

Stap 5: Bouw de controllerlus 🔁

Minimale lus:

1. Begin met het doel + de initiële context

2. Vraag het model: "Wat is de volgende stap?"

3. Als er een tool wordt aangeroepen, voer de tool dan uit

4. Observatie toevoegen

5. Controleer de stopconditie

6. Herhaal (met maximaal aantal stappen) de LangChain “Agents”-documentatie.

Toevoegen:

• time-outs

• herhaalpogingen (let op: herhaalpogingen kunnen in een oneindige lus terechtkomen) AWS "Time-outs, herhaalpogingen en terugval met jitter"

• Foutopmaak van de tool (duidelijk, gestructureerd)

Stap 6: Voeg voorzichtig geheugen toe 🗃️

Korte termijn: houd een compact "statusoverzicht" bij dat bij elke stap wordt bijgewerkt. LangChain "Geheugenoverzicht"
Lange termijn: bewaar duurzame feiten (gebruikersvoorkeuren, organisatieregels, stabiele documentatie).

Vuistregel:

• Als het vaak verandert, houd het dan op korte termijn

• Als het stabiel is, bewaar het dan voor langere tijd

• Als het om gevoelige informatie gaat, bewaar het dan zo min mogelijk (of helemaal niet)

Stap 7: Voeg validatie en een 'criticus'-pas toe 🧪

Een voordelig en praktisch patroon:

• agent genereert resultaat

• De validator controleert de structuur en de beperkingen

• Optionele kritische modelbeoordelingen voor ontbrekende stappen of beleidsschendingen NIST AI RMF 1.0

Niet perfect, maar het filtert een schokkende hoeveelheid onzin eruit.

Stap 8: Noteer alles wat je later spijt zult hebben als je het niet noteert 📜

Logboek:

• toolaanroepen + invoer + uitvoer

• beslissingen genomen

• fouten

• eindresultaten

• Tokens en latentie OpenTelemetry-observatiehandleiding

Je toekomstige zelf zal je dankbaar zijn. Je huidige zelf zal het vergeten. Zo is het leven nu eenmaal 😵💫

---

7) Een tool die je ziel niet breekt 🧰😵

Het aanroepen van tools is waar "Hoe bouw je een AI-agent?" echt software-engineering wordt.

Zorg ervoor dat gereedschap betrouwbaar is (betrouwbaarheid is goed)

Betrouwbare hulpmiddelen zijn:

• deterministisch

• beperkt in omvang

• makkelijk te testen

• Het is veilig om Stripe "Idempotente verzoeken"

Voeg vangrails toe op het niveau van de tool, niet alleen prompts

Aanwijzingen zijn beleefde suggesties. Validatie van de tool is een gesloten deur. OpenAI gestructureerde outputs

Doen:

• whitelists (welke tools mogen worden uitgevoerd)

• invoervalidatie

• richtlijnen voor snelheidslimieten

• Toegangscontroles per gebruiker/organisatie

• “Proefmodus” voor risicovolle acties

Ontwerp voor gedeeltelijke mislukking

Hulpmiddelen falen. Netwerken haperen. Authenticatie verloopt. Een agent moet:

• fouten interpreteren

• Opnieuw proberen met een backoff-periode wanneer nodig. Google Cloud-herhalingsstrategie (backoff + jitter)

• kies alternatieve gereedschappen

• Escaleren wanneer je vastloopt

Een subtiele maar effectieve truc: geef gestructureerde foutmeldingen terug, zoals:

• type: auth_error

• type: niet_gevonden

• type: rate_limited
  Zodat het model intelligent kan reageren in plaats van in paniek te raken.

---

8) Een herinnering die je helpt in plaats van je te kwellen 👻🗂️

Het geheugen is krachtig, maar het kan ook een rommelbak worden.

Kortetermijngeheugen: houd het compact

Gebruik:

• laatste N stappen

• een doorlopende samenvatting (die bij elke lus wordt bijgewerkt)

• huidig ​​plan

• huidige beperkingen (budget, tijd, beleid)

Als je alles in context plaatst, krijg je:

• hogere kosten

• lagere latentie

• nog meer verwarring (ja, zelfs toen)

Langetermijngeheugen: ophalen van informatie in plaats van 'opstoppen'

Het meeste "langetermijngeheugen" is eerder zoiets als:

• inbeddingen

• vectoropslag

• retrieval augmented generation (RAG) RAG-artikel

De agent onthoudt niets. Hij haalt de meest relevante fragmenten op tijdens de uitvoering. LlamaIndex “Inleiding tot RAG”

Praktische geheugenregels

• Sla "voorkeuren" op als expliciete feiten: "Gebruiker houdt van opsommingstekens en heeft een hekel aan emoji's" (haha, maar hier niet hoor 😄)

• Bewaar "beslissingen" met tijdstempels of versies (anders ontstaan ​​er tegenstrijdigheden)

• Bewaar nooit geheimen, tenzij het echt noodzakelijk is

En hier is mijn onvolmaakte metafoor: het geheugen is als een koelkast. Als je hem nooit schoonmaakt, smaakt je boterham uiteindelijk naar uien en spijt.

---

9) Planningspatronen (van eenvoudig tot complex) 🧭✨

Planning is niets meer dan gecontroleerde ontbinding. Maak er geen mystiek van.

Patroon A: Checklistplanner ✅

• Het model geeft een lijst met stappen als uitvoer

• Voert stap voor stap uit

• Updates checkliststatus

Uitstekend voor onboarding. Eenvoudig en testbaar.

Patroon B: ReAct-lus (reden + actie) 🧠→🧰

• model bepaalt volgende gereedschapsoproep

• observeert de uitvoer

• herhaalt ReAct-artikel

Dit is het klassieke agentengevoel.

Patroon C: Leidinggevende-medewerker 👥

• De supervisor verdeelt het doel in taken

• werknemers voeren gespecialiseerde taken uit

• Supervisor voegt resultaten samen Microsoft AutoGen (multi-agent framework)

Dit is handig wanneer taken parallel uitgevoerd kunnen worden, of wanneer je verschillende "rollen" wilt toewijzen, zoals:

• onderzoeker

• programmeur

• editor

• QA-controleur

Patroon D: Plannen, uitvoeren en vervolgens bijplannen 🔄

• plan opstellen

• uitvoeren

• Als de resultaten van het instrument de werkelijkheid veranderen, moet het plan worden herzien

Dit voorkomt dat de agent koppig vasthoudt aan een slecht plan. Mensen doen dit ook, tenzij ze moe zijn, in welk geval ze ook slechte plannen volgen.

---

10) Veiligheid, betrouwbaarheid en niet ontslagen worden 🔐😅

Als uw agent acties kan ondernemen, heeft u een veiligheidsontwerp nodig. Niet iets wat "leuk is om te hebben", maar iets wat noodzakelijk is. NIST AI RMF 1.0

Harde limieten

• maximaal aantal stappen per run

• maximaal aantal toolaanroepen per minuut

• maximale uitgaven per sessie (tokenbudget)

• beperkte tools achter goedkeuring

Gegevensverwerking

• Verberg gevoelige gegevens voordat u gaat loggen

• aparte omgevingen (ontwikkelomgeving versus productieomgeving)

• machtigingen voor tools met minimale bevoegdheden

Gedragsmatige beperkingen

• Dwing de agent om fragmenten van intern bewijsmateriaal aan te halen (geen externe links, alleen interne referenties)

• Vraag onzekerheidsvlaggen aan wanneer het vertrouwen laag is

• Vraag om verduidelijking als de invoer onduidelijk is

Een betrouwbare agent is niet per se de meest zelfverzekerde. Het is degene die weet wanneer hij gokt... en dat ook zegt.

---

11) Testen en evalueren (het onderdeel dat iedereen vermijdt) 🧪📏

Je kunt niet verbeteren wat je niet kunt meten. Ja, dat klinkt misschien cliché, maar het is helaas wel waar.

Stel een scenario-set samen

Maak 30-100 testgevallen aan:

• gelukkige paden

• randgevallen

• gevallen waarin het gereedschap faalt

• dubbelzinnige verzoeken

• vijandige prompts (pogingen tot promptinjectie) OWASP Top 10 voor LLM-apps OWASP LLM01 Promptinjectie

Score-uitkomsten

Gebruik meetwaarden zoals:

• succespercentage van de taak

• tijd tot voltooiing

• Herstelpercentage van gereedschapsfouten

• Hallucinatiepercentage (beweringen zonder bewijs)

• goedkeuringspercentage door mensen (indien in de modus onder toezicht)

Regressietests voor prompts en tools

Elke keer dat je iets verandert:

• gereedschapsschema

• systeeminstructies

• ophaallogica

• Geheugenformatteren.
  Voer de suite opnieuw uit.

Agenten zijn gevoelige beestjes. Net als kamerplanten, maar dan duurder.

---

12) Implementatiepatronen die je budget niet overbelasten 💸🔥

Begin met één enkele dienst

• agent controller API

• de bijbehorende tools en services

• Logboekregistratie + monitoring OpenTelemetry-observatie-handleiding

Voeg vroegtijdig kostenbeheersingsmaatregelen toe

• cachen van ophaalresultaten

• Het samenvatten van de gespreksstatus

• kleinere modellen gebruiken voor routering en extractie

• Het beperken van de "diepgaande denkmodus" tot de moeilijkste stappen

Een veelvoorkomende architectuurkeuze

• Stateless controller + externe statusopslag (DB/Redis)

• Toolaanroepen zijn waar mogelijk idempotent. Stripe "Idempotente verzoeken".

• Zet taken die lang duren in de wachtrij (zodat een webverzoek niet oneindig lang open blijft staan)

En vergeet niet een noodstop in te bouwen. Je hebt hem pas nodig als je hem echt, echt nodig hebt 😬

---

13) Afsluitende opmerkingen - de korte versie van Hoe bouw je een AI-agent 🎁🤖

Als je verder niets onthoudt, onthoud dan dit:

• Het bouwen van een AI-agent draait voornamelijk om het creëren van een veilige lus rond een model. Zie de LangChain-documentatie over "Agents".

• Begin met een helder doel, beperkte autonomie en strikte hulpmiddelen. OpenAI gestructureerde outputs

• Voeg geheugen toe via het ophalen van gegevens, niet door eindeloos context te vullen. RAG-document

• Plannen maken hoeft niet ingewikkeld te zijn - checklists en het regelmatig bijstellen van de planning kunnen wonderen doen.

• Door middel van logging en tests transformeer je de chaos binnen de agents in iets dat je kunt lanceren. Een basisprincipe van OpenTelemetry-observatie.

• Beveiligingsmechanismen horen in de code, niet alleen in prompts. OWASP Top 10 voor LLM-apps

Een agent is geen toverkunst. Het is een systeem dat vaak genoeg goede beslissingen neemt om waardevol te zijn... en een nederlaag toegeeft voordat het schade aanricht. Op een bepaalde manier geruststellend 😌

En ja, als je het goed aanpakt, voelt het alsof je een kleine digitale stagiair inhuurt die nooit slaapt, af en toe in paniek raakt en dol is op papierwerk. Dus eigenlijk gewoon een stagiair.

Praktisch voorbeeld: Het bouwen van een AI-agent voor het afhandelen van supportvragen 🎫🤖

Scenario

Stel je een klein SaaS-team voor dat 120-180 supporttickets per week ontvangt. De meeste tickets zijn niet complex, maar ze kosten toch tijd: wachtwoordresets, vragen over facturering, bugrapporten, functieverzoeken en berichten als "is dit normaal gedrag?".

Een simpele chatbot kan wel antwoorden opstellen, maar kan niet betrouwbaar de accountstatus controleren, de kennisbank doorzoeken, de urgentie inschatten of bepalen wanneer een mens moet ingrijpen. Daar komt een medewerker goed van pas.

Het doel is niet om de klantenservice volledig te vervangen. Het doel is om een ​​agent met beperkte autonomie te bouwen die een nieuw ticket leest, context verzamelt, een antwoord opstelt en het ticket naar de juiste wachtrij doorstuurt. Alles wat met de klant te maken heeft, moet nog steeds door een mens worden goedgekeurd.

Wat de assistent nodig heeft

Om veilig te kunnen werken, heeft de agent een kleine, gecontroleerde set invoergegevens en hulpmiddelen nodig:

• De inkomende tickettekst

• Klantabonnement, accountleeftijd en recente factuurstatus

• Recente productwijzigingen of bekende incidenten

• Artikelen uit het interne helpcentrum

• Een tool voor het bijwerken van tickets met beperkte velden

• Een tool voor het opstellen van antwoorden, geen tool om e-mails te verzenden

• Een duidelijk escalatiebeleid

De lijst met gereedschappen moet bewust beperkt blijven:

• zoek_help_centrum(query)

• get_customer_status(customer_id)

• check_known_incidents(product_area)

• update_ticket_category(ticket_id, category, priority)

• concept_antwoord(ticket_id, antwoord_tekst)

• escalate_to_human(ticket_id, reason)

Merk op wat er ontbreekt: er is geen tool voor "klant terugbetalen", "account sluiten" of "laatste reactie versturen". Die acties zijn te riskant voor een eerste versie.

Voorbeeldinstructie

Je bent een medewerker die de ondersteuning voor een SaaS-product in behandeling neemt.

Jouw taak is om binnenkomende tickets te classificeren, alleen de benodigde context te verzamelen, een suggestie voor een antwoord op te stellen en te beslissen of het ticket moet worden doorverwezen naar een hogere instantie.

Regels:

Stuur geen antwoorden rechtstreeks naar klanten.

Raadpleeg het helpcentrum voordat u productvragen beantwoordt.

Controleer de klantstatus voordat u vragen over facturering, abonnementen of toegang beantwoordt.

Als de klant juridische dreigingen, gegevensverlies, beveiligingsproblemen, mislukte betalingen, accountopzegging of boze taal uitspreekt, schakel dan een medewerker in.

Als het antwoord niet wordt ondersteund door de gevonden helpcentrumgegevens of accountinformatie, geef dan aan wat er ontbreekt en escaleer het probleem.

Stop na maximaal 6 toolaanroepen.

Een ticket is pas "afgerond" als het een categorie, prioriteit, bewijssamenvatting, conceptantwoord en de status "menselijke goedkeuring vereist" of "geëscaleerd" heeft.

Hoe test je het?

Begin met 30 testtickets voordat u het aan live gebruikers koppelt:

• 10 standaardtickets, zoals wachtwoordherstel, abonnementslimieten en basisvragen als "Hoe doe ik dit?"

• 5 factureringstickets

• 5 bugrapporten

• 5 onduidelijke tickets met ontbrekende informatie

• 5 risicovolle tickets, zoals veiligheidsproblemen, terugbetalingsverzoeken en boze klachten

Voor elk ticket, score:

• Heeft het de juiste categorie gekozen?

• Heeft het de juiste tool gebruikt voordat het antwoord gaf?

• Heeft het ongefundeerde beweringen vermeden?

• Heeft dit geleid tot een toename van risicovolle tickets?

• Moest het concept grondig worden bewerkt?

Een eenvoudige spreadsheet met geslaagd/niet geslaagd-beoordelingen is in het begin voldoende. Maak het evaluatiesysteem niet te complex voordat je weet of de medewerker waarde levert.

Resultaat

Illustratief resultaat: Op basis van de tijd die nodig was voor 30 voorbeeldtickets vóór en na het gebruik van deze workflow, kon een supportmedewerker het volgende meten:

• De gemiddelde tijd voor de eerste triage per ticket is teruggebracht van 6 minuten naar 90 seconden

• 30 tickets afgehandeld in 45 minuten in plaats van 3 uur

• 27 van de 30 tickets zijn in de juiste categorie geplaatst

• 5 van de 5 risicovolle meldingen zijn correct doorverwezen

• 0 klantreacties verzonden zonder menselijke goedkeuring

Deze cijfers zijn een schatting, geen bewezen maatstaf. De meting is eenvoudig te herhalen: verwerk dezelfde batch testtickets handmatig, laat ze vervolgens door de agent verwerken en vergelijk de nauwkeurigheid van de categorieën, de escalatienauwkeurigheid en de bewerkingstijd.

Wat kan er misgaan?

De agent kan nog steeds op heel normale manieren falen.

Het systeem kan een gefrustreerde maar eenvoudige klant als 'urgent' bestempelen omdat de formulering boos klinkt. Het kan een zelfverzekerd antwoord opstellen op basis van een verouderd helpartikel. Het kan blijven zoeken terwijl escalatie de juiste stap is. Het kan te veel accountgegevens in een conceptantwoord prijsgeven.

De oplossing is niet "een betere prompt schrijven" en hopen op het beste. Voeg harde limieten toe:

• Schakel de escalatie in als er bepalingen met betrekking tot facturering, beveiliging, juridische zaken of annuleringen verschijnen

• Vereist dat in de samenvatting van het bewijsmateriaal verwijzingen naar interne helpartikelen worden opgenomen

• Houd de functie "antwoord verzenden" achterwege en pas na menselijke goedkeuring

• Registreer elk gereedschapsverzoek en de definitieve versie

• Voer de testsuite met 30 tickets opnieuw uit na elke wijziging van een prompt, tool of beleid

Praktische tips

Een waardevolle agent hoeft geen extreme autonomie te hebben. In dit voorbeeld schuilt de waarde in een gecontroleerde lus: het ticket lezen, de juiste context ophalen, het classificeren, een antwoord opstellen en stoppen voor beoordeling. Dat is veel gemakkelijker te vertrouwen, te testen en te verbeteren dan een agent die probeert "ondersteuning af te handelen" met één enorme prompt.

---

Veelgestelde vragen

Wat is een AI-agent, in eenvoudige bewoordingen?

Een AI-agent is in principe een herhalende lus: input ontvangen, de volgende stap bepalen, een tool gebruiken, het resultaat lezen en dit herhalen tot het klaar is. Het 'agentische' aspect komt van het handelen en observeren, niet alleen van het praten. Veel agenten zijn simpelweg slimme automatisering met toegang tot tools, terwijl andere zich meer gedragen als een junior operator die fouten kan herstellen.

Wanneer moet ik een AI-agent bouwen in plaats van alleen een prompt te gebruiken?

Ontwikkel een agent wanneer het werk uit meerdere stappen bestaat, verandert op basis van tussentijdse resultaten en betrouwbaar gebruik van tools vereist (API's, databases, ticketing, code-uitvoering). Agents zijn ook nuttig wanneer u herhaalbare resultaten wilt met richtlijnen en een manier om aan te geven dat een taak is voltooid. Als een eenvoudige prompt-respons volstaat, is een agent meestal onnodige overhead en een bron van extra foutscenario's.

Hoe bouw ik een AI-agent die niet vastloopt in oneindige lussen?

Gebruik strikte stopvoorwaarden: maximaal aantal stappen, maximaal aantal toolaanroepen en duidelijke voltooiingscontroles. Voeg gestructureerde toolschema's, time-outs en herhaalpogingen toe die niet oneindig doorgaan. Registreer beslissingen en tooluitvoer zodat u kunt zien waar het misgaat. Een veelgebruikt veiligheidsmechanisme is escalatie: als de agent onzeker is of fouten herhaalt, moet hij om hulp vragen in plaats van te improviseren.

Wat is de minimale architectuur voor het bouwen van een AI-agent?

Je hebt minimaal een controllerloop nodig die het model een doel en context geeft, de volgende actie opvraagt, een tool uitvoert indien gevraagd, de observatie toevoegt en dit herhaalt. Je hebt ook tools nodig met strikte input/output-vormen en een "klaar"-controle. Zelfs een zelfgemaakte loop kan goed werken als je de status overzichtelijk houdt en staplimieten hanteert.

Hoe ontwerp ik toolaanroepen zodat ze betrouwbaar zijn in een productieomgeving?

Houd tools specifiek, getypeerd, voorzien van toegangsrechten en gevalideerd – vermijd generieke tools die alles kunnen. Geef de voorkeur aan strikte schema's (zoals gestructureerde uitvoer/functieaanroepen) zodat de agent invoer niet zomaar kan negeren. Voeg whitelists, snelheidslimieten en controles op gebruikers-/organisatierechten toe op toolniveau. Ontwerp tools zo dat ze, indien mogelijk, veilig opnieuw kunnen worden uitgevoerd, met behulp van idempotentiepatronen.

Wat is de beste manier om het geheugen uit te breiden zonder de prestaties van de agent te verslechteren?

Beschouw het geheugen als twee delen: de kortetermijnstatus van de uitvoering (recente stappen, huidig ​​plan, beperkingen) en het langetermijngeheugen (voorkeuren, stabiele regels, relevante documenten). Houd het kortetermijngeheugen compact met samenvattingen van de uitvoering, niet met volledige transcripties. Voor het langetermijngeheugen is het ophalen van informatie (embeddings + vectoropslag/RAG-patronen) meestal effectiever dan alles in een context te proppen en het model in de war te brengen.

Welk planningsmodel moet ik gebruiken: checklist, ReAct of supervisor-medewerker?

Een checklistplanner is ideaal wanneer taken voorspelbaar zijn en je iets wilt dat makkelijk te testen is. Loops in de stijl van ReAct komen goed van pas wanneer de resultaten van een tool bepalen wat je vervolgens moet doen. Patronen met een supervisor en een medewerker (zoals de rolverdeling in AutoGen) zijn handig wanneer taken parallel uitgevoerd kunnen worden of baat hebben bij verschillende rollen (onderzoeker, programmeur, QA). Plannen, uitvoeren en vervolgens herplannen is een praktische middenweg om hardnekkige, slechte plannen te voorkomen.

Hoe maak ik een agent veilig als deze daadwerkelijk acties kan ondernemen?

Gebruik het principe van minimale bevoegdheden en beperk de toegang tot risicovolle tools door ze alleen te laten controleren of in een 'proefdraai'-modus te gebruiken. Voeg budgetten en limieten toe: maximaal aantal stappen, maximaal budget en limieten voor het aantal toolaanroepen per minuut. Verwijder gevoelige gegevens voordat ze worden vastgelegd en scheid ontwikkel- en productieomgevingen. Vereis onzekerheidsvlaggen of verduidelijkende vragen wanneer de invoer onduidelijk is, in plaats van vertrouwen in plaats van bewijs te laten prevaleren.

Hoe test en evalueer ik een AI-agent zodat deze in de loop der tijd verbetert?

Stel een reeks scenario's samen met succesvolle scenario's, randgevallen, toolfouten, ambigue verzoeken en pogingen tot promptinjectie (OWASP-stijl). Beoordeel uitkomsten zoals taaksucces, voltooiingstijd, herstel na toolfouten en claims zonder bewijs. Voer de reeks opnieuw uit telkens wanneer u toolschema's, prompts, ophaalmethoden of geheugenformattering wijzigt. Als u het niet kunt testen, kunt u het niet betrouwbaar uitbrengen.

Hoe implementeer ik een agent zonder de latentie en kosten de pan uit te laten rijzen?

Een veelvoorkomend patroon is een stateless controller met een externe state store (DB/Redis), ondersteunende services en robuuste logging/monitoring (vaak OpenTelemetry). Beheers de kosten met retrieval caching, compacte state summarys, kleinere modellen voor routing/extractie en door "diepgaande denkprocessen" te beperken tot de moeilijkste stappen. Gebruik wachtrijen voor langdurige taken, zodat webverzoeken niet onnodig lang open blijven staan. Voeg altijd een kill switch toe.

Referenties

1. Nationaal Instituut voor Standaarden en Technologie (NIST) - NIST AI RMF 1.0 (betrouwbaarheid en transparantie) - nvlpubs.nist.gov

2. OpenAI - Gestructureerde outputs - platform.openai.com

3. OpenAI - Handleiding voor het aanroepen van functies - platform.openai.com

4. OpenAI - Richtlijnen voor snelheidslimieten - platform.openai.com

5. OpenAI - Voert API uit - platform.openai.com

6. OpenAI - Functieaanroepen voor assistenten - platform.openai.com

7. LangChain - Agents-documentatie (JavaScript) - docs.langchain.com

8. LangChain - Documentatie voor tools (Python) - docs.langchain.com

9. LangChain - Geheugenoverzicht - docs.langchain.com

10. arXiv - ReAct-artikel (reason + act) - arxiv.org

11. arXiv - RAG-artikel - arxiv.org

12. Amazon Web Services (AWS) Builders' Library - Timeouts, retries en backoff met jitter - aws.amazon.com

13. OpenTelemetry - Basisprincipes van Observability - opentelemetry.io

14. Stripe - Idempotente verzoeken - docs.stripe.com

15. Google Cloud - Herhalingsstrategie (backoff + jitter) - docs.cloud.google.com

16. OWASP - Top 10 voor grote taalmodeltoepassingen - owasp.org

17. OWASP - LLM01 Prompt Injection - genai.owasp.org

18. LlamaIndex - Inleiding tot RAG - developers.llamaindex.ai

19. Microsoft - Semantische kernel - learn.microsoft.com

20. Microsoft AutoGen - Multi-agent framework (documentatie) - microsoft.github.io

21. CrewAI - Agentconcepten - docs.crewai.com

22. Haystack (deepset) - Documentatie voor Retrievers - docs.haystack.deepset.ai

Vind de nieuwste AI in de officiële AI Assistant Store

Over ons