Wat is nou écht AI? En wanneer is het gewoon een workflow?

Iedereen noemt tegenwoordig van alles een "AI-agent". Maar vaak is het gewoon een nette automatisering met een paar vaste stappen. Soms zit daar een LLM in, soms niet. En soms is het pas écht agentisch.

Dat maakt het gesprek verwarrend. Termen als AI, LLM, workflow, automatisering en agent worden voortdurend door elkaar gebruikt. Dit artikel helpt je het verschil scherp te zien, zodat je beter kunt kiezen wat je nodig hebt.

De kernvraag is namelijk niet: zit er AI in? De betere vraag is: hoeveel vrijheid krijgt het systeem om zelf te beslissen wat de volgende stap is?

De kernvraag is niet of er AI in zit. De betere vraag is: hoeveel vrijheid krijgt het systeem om zelf te bepalen wat de volgende stap is?

De korte factcheck

Een paar stellingen die vaak langskomen, met de nuance erbij:

• "Als er een LLM aan te pas komt, is het AI." Grotendeels waar — maar dat betekent nog niet dat het ook een agent is.
• "Een agent is gewoon een markdown-bestand met instructies." Deels. De instructies staan inderdaad vaak in tekst of markdown, maar een agent bestaat óók uit modelkeuze, tools, geheugen, runtime en besturingslogica.
• "De LLM leest dat bestand en voert het daarna uit." Niet helemaal. De LLM leest instructies en genereert tekst of tool-calls; de software eromheen voert de acties uit.
• "Je moet niet altijd het duurste model pakken." Klopt. Voor simpele taken is routing naar goedkopere modellen vaak veel slimmer qua kosten.

Wat is gewoon een workflow of automatisering?

Een automatisering is in de basis: als X gebeurt, doe dan Y. Denk aan:

• Als er een formulier binnenkomt, maak een taak aan.
• Als een factuur wordt betaald, stuur een bevestiging.
• Als een lead "warm" wordt, stuur een melding naar sales.

Dat kan volledig zonder AI.

Een workflow gaat een stap verder: meerdere vaste stappen achter elkaar. Bijvoorbeeld: er komt een e-mail binnen, de tekst wordt uitgelezen, een LLM vat de mail samen, de uitkomst wordt in het CRM gezet en er wordt automatisch een vervolgtaak aangemaakt.

Dat is slim, nuttig en modern — maar nog steeds meestal een voorgeprogrammeerde route.

Wanneer wordt het dan AI?

Zodra je een LLM inzet, voeg je een laag toe die niet alleen regels volgt, maar ook taal begrijpt, samenvat, herschrijft, classificeert, vergelijkt of redeneert binnen bepaalde grenzen. Grof gezegd:

• Een klassieke automation: vaste regels.
• Een AI-workflow: vaste stappen plus één of meer LLM-calls.
• Een agent: een systeem dat binnen kaders zelf bepaalt welke stap nodig is.

Dat verschil is belangrijk. Niet elke AI-workflow is een agent. En niet elke agent hoeft extreem complex te zijn.

Het echte verschil: workflow versus agent

Workflow = vaste route

Bij een workflow ligt het pad grotendeels vooraf vast. Bijvoorbeeld: lees de nieuwe lead, classificeer de branche, schrijf een follow-up, zet het resultaat in Notion, stop. De software bepaalt hier de volgorde.

Agent = dynamische route

Bij een agent ligt het doel vast, maar niet altijd het pad. Zo'n systeem begrijpt de vraag van de gebruiker, bepaalt welke informatie ontbreekt, kiest of er eerst gezocht moet worden, beslist welk hulpmiddel nodig is, controleert het resultaat, vraagt eventueel door en levert daarna pas een antwoord of actie op. Onderweg bepaalt het systeem deels zelf wat logisch is.

Wil je dit verschil concreet zien tegenover een simpele chatbot? We werkten het eerder uit in AI-agent versus chatbot.

Bij een workflow bepaalt de software de volgorde. Bij een agent ligt het doel vast, maar bepaalt het systeem onderweg deels zelf de route.

Is "AI" vooral het feit dat er een LLM aan te pas komt?

Voor een groot deel: ja. In de praktijk bedoelen veel mensen met "we doen iets met AI" simpelweg dat er ergens in de keten een taalmodel meedraait.

Maar inhoudelijk is dat nog te grof. Want je hebt minstens drie lagen:

1. Model — het LLM zelf.
2. Instructies — wat het model moet doen.
3. Orchestratie — de softwarelaag die bepaalt wanneer het model draait, welke tools beschikbaar zijn en wat er met de uitkomst gebeurt.

Pas samen vormen die lagen een bruikbaar systeem.

Zit er dan echt "gewoon een markdown-bestand" achter?

Ja en nee.

Wat hier wél aan klopt

Heel veel AI-systemen werken inderdaad met verrassend simpele instructies in platte tekst. Dat kan een markdown-bestand zijn, een prompt-template, een system prompt in code, een tekstveld in Notion, een record in een database of een combinatie daarvan.

Die instructies zijn vaak gewoon menselijk leesbare tekst: wat is je rol, wat is je doel, welke stijl gebruik je, welke tools mag je gebruiken, wanneer moet je stoppen en hoe moet de output eruitzien? Dat voelt bijna ouderwets simpel. En dat is juist ook de kracht.

Wat hier níet aan klopt

Het is meestal niet zo dat "de LLM een bestand leest en daarna zelfstandig alles uitvoert". Wat er in werkelijkheid gebeurt:

1. De applicatie geeft het model instructies en context.
2. De applicatie geeft eventueel tools mee, zoals zoekfuncties, database-acties of API-calls.
3. Het model beslist op basis van die context wat een goed volgend antwoord of welke tool-call is.
4. De softwarelaag voert die tool-call uit.
5. Het resultaat gaat terug naar het model.
6. Dat herhaalt zich totdat het doel is gehaald of een stopvoorwaarde is bereikt.

De LLM denkt en kiest, maar de software eromheen voert uit en bewaakt.

Waarom een AI gateway of model routing interessant is

Als je voor élke taak standaard het zwaarste en duurste model gebruikt, lopen je kosten snel op. Zeker bij veel kleine taken, grote volumes, agent-loops met meerdere stappen of gebruikers die veel context meesturen.

Daarom is een AI gateway of model router vaak slim. Die laag kan bijvoorbeeld beslissen:

• simpele classificatie → goedkoop model;
• samenvatting van korte tekst → goedkoop of middensegment;
• complexe analyse of belangrijk klantvoorstel → sterker model;
• kwaliteitscontrole of fallback → alleen opschalen als het nodig is.

Dat heet vaak routing, cascades of escalation. Wat zo'n opzet in de praktijk kost en oplevert, werkten we uit in wat kost een AI-agent.

Belangrijke nuance: begin niet te ingewikkeld

Veel teams bouwen te snel iets "agentisch" terwijl een goede prompt of simpele workflow al genoeg is. Een verstandige volgorde is meestal:

1. Start met één goede prompt.
2. Voeg retrieval of context toe.
3. Maak er een vaste workflow van.
4. Voeg pas daarna agentische vrijheid toe als het echt nodig is.
5. Voeg model routing toe zodra volumes of kosten daarom vragen.

Dus ja: model routing is interessant. Maar nee: het hoeft niet je eerste stap te zijn.

Hoe maak je zelf een agent?

Hier is de simpelste bruikbare aanpak, in zeven stappen.

Stap 1 — Kies één scherp doel

Niet: "ik wil iets met AI." Wel iets concreets: beantwoord inkomende supportvragen, maak van meeting notes concrete taken, kwalificeer leads en schrijf opvolgvoorstellen, of analyseer een klantvraag en stel de juiste vervolgstappen voor. Een agent met één duidelijke taak werkt bijna altijd beter dan een "alleskunner".

Stap 2 — Schrijf de instructies

Beschrijf in gewone taal wie of wat de agent is, wat het doel is, welke input binnenkomt, welke output gewenst is, welke regels gelden, wat de agent juist níet mag doen en wanneer de agent moet stoppen of terugvragen. Bijvoorbeeld:

Je bent een leadkwalificatie-agent voor een softwarebureau.

Doel:
- bepaal of een lead interessant is
- vat de vraag samen
- stel maximaal 3 verhelderende vragen
- doe een eerste inschatting van urgentie en potentiële fit

Regels:
- verzin geen feiten
- wees zakelijk en kort
- als informatie ontbreekt, zeg dat expliciet
- geef output in vaste secties

Dit kan prima in markdown staan. Maar het kan net zo goed uit code, een CMS, een prompt library of Notion komen.

Stap 3 — Geef de agent tools

Een agent zonder tools is vaak vooral een slimme schrijver. Handige tools zijn bijvoorbeeld een zoekfunctie in interne documentatie, een CRM-opvraag, e-mail lezen of een concept maken, de agenda checken, een database bijwerken, web search, een bestand uitlezen of API-calls naar je eigen systemen. De kwaliteit van een agent hangt vaak minder af van "magische AI" en meer van hoe goed die tools en hun beschrijvingen zijn ingericht.

Stap 4 — Bepaal hoeveel autonomie nodig is

Niet elk systeem hoeft volledig autonoom te zijn. Grofweg zijn er drie niveaus:

1. Assist mode — de AI doet een voorstel, maar de mens beslist.
2. Workflow mode — de AI draait in een vaste flow met beperkte vrijheid.
3. Agent mode — de AI kiest binnen kaders zelf welke acties of tools nodig zijn.

Voor veel bedrijven is niveau 1 of 2 al direct waardevol.

Stap 5 — Kies je modelstrategie

Denk in lagen: een goedkoop model voor simpele, veelvoorkomende taken, een sterker model voor belangrijke of complexe taken, een fallback-model als iets mislukt en eventueel een review-model voor kwaliteitscontrole. Je hoeft dus niet alles op het duurste model te laten draaien.

Stap 6 — Bouw guardrails in

Goede agents hebben grenzen nodig: een maximaal aantal stappen, alleen bepaalde tools toestaan, een verplichte menselijke check bij kritieke acties, output valideren vóór verzending, logging en evaluatie, en duidelijke foutafhandeling. Zonder guardrails wordt een agent snel duur, onvoorspelbaar of onveilig.

Stap 7 — Test op echte cases

Niet alleen: "werkt de demo?" Maar vooral: waar gaat het fout, wanneer hallucineren antwoorden, wanneer kiest het model de verkeerde tool, wanneer is een goedkoper model al goed genoeg en welke instructies blijken te vaag? Een agent bouw je niet alleen met prompts, maar vooral met iteratie.

Wil je dit niet zelf uitvogelen? Zo pakken wij het aan als we een AI-agent laten bouwen — of breder AI-agents in je processen zetten.

Een simpele referentie-architectuur

Een minimale setup ziet er vaak zo uit:

1. Een gebruiker of trigger start een taak.
2. De app verzamelt context.
3. De app kiest een model of route.
4. Instructies, context en tools gaan naar het LLM.
5. Het LLM antwoordt of vraagt om een tool.
6. De tool wordt uitgevoerd.
7. Het resultaat gaat terug naar het LLM.
8. De app valideert de output.
9. Een mens of systeem verwerkt de uitkomst.

Van "slimme prompt" naar echte agent

Je hoeft niet direct groot te beginnen. Een logische groeilijn is: een prompt, dan een prompt met context, dan een workflow met meerdere stappen, dan een workflow met tools, dan een agent met beslisruimte en uiteindelijk een agent met routing, evaluatie en monitoring. Dat is vaak ook de goedkoopste én verstandigste route.

En zodra meerdere van die workflows en agents moeten samenwerken rond dezelfde bedrijfsinformatie, kom je bij de orchestratielaag: de plek waar processen, data en AI logisch bij elkaar komen in een bedrijfs-OS.

Conclusie

De kern is simpel:

• Automatisering volgt regels.
• Workflow volgt vaste stappen.
• AI-workflow gebruikt een LLM binnen een vaste flow.
• Agent krijgt een doel en bepaalt deels zelf de route.

En ja: de instructielaag van zo'n systeem kan verrassend eenvoudig zijn — vaak gewoon tekst of markdown. Maar een agent is méér dan alleen een markdown-bestand. Het is de combinatie van instructies, model, tools, context, runtime, guardrails en evaluatie.

Wie dat goed begrijpt, kan veel beter kiezen: wanneer is een simpele automation genoeg, wanneer heb je een workflow nodig, en wanneer is een echte agent de moeite waard?

De beste eerste stap is niet "bouw meteen een superagent". Het is: kies één concreet proces, schrijf heldere instructies, geef beperkte tools, meet de kwaliteit — en schaal daarna pas op.

Zelf de juiste keuze maken?

Twijfel je of jouw volgende stap een simpele automatisering, een workflow of een echte agent is? Doe de Quickscan — dan zie je in een paar minuten waar de grootste winst zit. Wil je zien hoe losse workflows en agents samenkomen in één laag, kijk dan naar het bedrijfs-OS. Liever direct sparren over wat voor jouw processen verstandig is? Plan een vrijblijvend gesprek in.

De voorbeelden in dit artikel zijn illustratief, bedoeld om het idee te laten zien. Wat voor jouw bedrijf verstandig is, hangt af van je processen, je systemen en je situatie.