Na de agent, de workflow en het geheugen: de harness
Harness, agent runtime, agent loop. De term staat op elke AI-conferentie en in elke tool-release. En net als bij de vorige buzzwords verbergt de hype iets concreets.
In onze serie schreven we wat een AI agent is, een LLM dat tools aanroept, hoe je losse stappen tot een agentic workflow knoopt en hoe een knowledge graph als geheugen werkt. In die stukken viel telkens het woord harness, zonder dat we het uitlegden. Dit is dat stuk.
Een taalmodel op zichzelf doet één ding: tekst voorspellen. Het stuurt geen mail, opent geen bestand en onthoudt niets van de vorige beurt. De harness is de software die daar een handelende agent van maakt. Je bedient zelden het kale model. Wat je gebruikt is de harness eromheen. Claude Code, Cursor, de agent in je supporttool: allemaal harnessen rond hetzelfde soort model.
Wat een harness eigenlijk is
Het model is de motor. De harness is de rest van de auto: het stuur, de remmen, het dashboard en het chassis. Een motor op een testbank loeit hard en komt nergens. Pas in een auto wordt het vervoer. Zo wordt een model pas een agent zodra er een harness omheen zit die hem tools geeft, zijn antwoorden uitvoert en de boel op koers houdt.
Een los model
Voorspelt tekst en verder niets. Geen acties, geen geheugen tussen aanroepen. Je vraagt iets, je krijgt woorden terug.
Een model met tools
Function calling erbij: het model kan een tool aanroepen. Een stap wordt een actie, maar het blijft bij die ene stap.
Een harness
Draait de loop: model, tool, resultaat, weer het model. Met contextbeheer en guardrails eromheen. Hier wordt capaciteit een werkende agent.
Een model voorspelt tekst. Een harness laat die tekst iets doen, stap na stap, binnen grenzen die jij zet. Wie een agent bouwt, bouwt vooral aan de harness.
De loop is het hart van de harness
Het kloppende deel van elke harness is de agent loop. Het model praat niet zelf met je systemen; de harness zit ertussen en herhaalt steeds dezelfde cyclus tot de taak af is.
De harness stuurt de context
Het model krijgt de opdracht, de beschikbare tools en alles wat er tot nu toe gebeurd is in één pakket aangeleverd.
Het model kiest een tool
Het antwoordt met een tool-call in plaats van met tekst voor jou: roep deze functie aan met deze parameters.
De harness voert de tool uit
Een API, een database-query, een bestand dat aangepast wordt. De harness draait het en leest het resultaat terug.
Het resultaat gaat terug naar het model
Met die nieuwe informatie bepaalt het model de volgende stap. Nog een tool, of een afrondend antwoord.
De loop herhaalt tot het klaar is
Stap voor stap werkt het systeem zo een hele taak af, met de harness als regisseur van elke ronde.
Dit is precies wat Claude Code, Cursor en elke coding-agent onder de motorkap draaien. Wat eronder zit is een nette loop die het model keer op keer de juiste context en de juiste tools voorschotelt. Meer is het niet.
Wat er nog meer in een harness zit
De loop is het skelet. Wat een harness laat standhouden op echte data, zijn de lagen eromheen.
Contextbeheer
Het contextvenster van een model is eindig. De harness bepaalt wat er elke beurt in de prompt gaat, vat samen wat te lang wordt en haalt het juiste geheugen erbij. Hier plugt een knowledge graph als bron in.
De tool-laag
De brug tussen model en je echte systemen. Tools definiëren, de tool-calls van het model uitlezen, ze veilig uitvoeren en het antwoord teruggeven in een vorm die het model snapt. MCP standaardiseert dat.
Foutafhandeling
Een tool faalt, een API ligt eruit, het model vraagt iets onmogelijks. De harness vangt dat op, probeert opnieuw of stopt netjes, zodat één mislukte stap niet de hele run meesleurt.
Guardrails
Wat de agent zelf mag en waarvoor een mens moet tekenen. Permissies, harde limieten en een mens in de lus voor onomkeerbare acties.
Het contextvenster is de werkbank van het model. De harness bepaalt wat erop ligt: te veel en het model verdwaalt, te weinig en het mist het feit dat het nodig had.
Harness, workflow of agent?
Deze drie termen lopen in elke discussie door elkaar. Ze beschrijven verschillende lagen, en wie ze uit elkaar houdt kijkt door elke pitch heen.
De agent: wat het kan
Het model met tools. De capaciteit om iets te doen in plaats van alleen tekst terug te geven.
De harness: wat het draait
De software die de agent laat lopen. De loop, de tools en de controle eronder. De motor van het geheel.
De workflow: hoe je het ordent
Hoe je meerdere stappen aan elkaar knoopt tot een systeem dat een taak afmaakt. De structuur erboven.
Een agentic workflow draait dus altijd ergens in een harness. De workflow zegt welke stappen er zijn en in welke volgorde; de harness voert elke stap daadwerkelijk uit en houdt hem binnen de lijntjes.
De agent is wat het kan. De harness is wat het draait. De workflow is hoe je het ordent. Drie woorden voor drie lagen die elkaar nodig hebben.
Waarom de harness de helft van het werk is
Als een agent ineens veel beter presteert, krijgt het model de credits. Vaak terecht, en net zo vaak komt een groot deel van die sprong uit de harness eromheen. Hetzelfde model gedraagt zich totaal anders, afhankelijk van wat je eromheen bouwt.
Een zwakke harness raakt halverwege een lange taak de draad kwijt, kan niet herstellen van een mislukte tool en heeft geen rem op onomkeerbare acties. Een sterke harness houdt het model op koers over tientallen stappen, vangt fouten op en weet wanneer hij een mens moet vragen. Het model neem je af bij een leverancier en wissel je zodra er een beter model komt. De harness is het deel dat van jou is.
Een sterker model krijgt de credits. Een groot deel van wat een agent kan, komt uit de harness eromheen. Daar zitten je betrouwbaarheid, je veiligheid en het meeste engineeringwerk.
Kant-en-klaar of zelf bouwen
De meeste mensen gebruiken al een harness zonder het zo te noemen. Claude Code, Cursor of de agent-runtime van een platform zijn kant-en-klare harnessen. Dat is precies goed zolang je taak in een standaardvorm past. Je bouwt of past er pas zelf een aan zodra je eigen tools, eigen grenzen en schrijftoegang tot je eigen systemen nodig hebt.
Gebruik een bestaande harness
Je taak past in een standaardvorm: code schrijven, vragen beantwoorden over je documenten, een assistent in je tool. Claude Code, Cursor of de agent-runtime van een platform doen het werk. Zelf bouwen is dan onnodige complexiteit.
Bouw of pas een harness aan
Je hebt eigen tools, eigen guardrails en gecontroleerde schrijftoegang tot je systemen nodig, afgestemd op jouw risico. Dan wordt de harness het deel dat je echt zelf in handen wilt hebben.
Begin ook hier zo simpel mogelijk. Een eigen harness bouw je pas als een bestaande je echt in de weg zit. Elke laag die je toevoegt, is er ook één die je moet onderhouden terwijl de modellen eronder veranderen.
Het moeilijke zit in de loop draaiende houden
Een agent loop schrijf je in een middag: een lus die het model aanroept, de tool draait en het resultaat terugstuurt. Dat is het makkelijke deel. Het echte werk begint zodra die loop elke dag op echte data draait, met schrijftoegang tot je systemen, terwijl de modellen eronder blijven veranderen.
Dan moet het contextbeheer meegroeien met langere taken, moet elke fout worden opgevangen, moeten de guardrails kloppen voor onomkeerbare acties en moet je in productie kunnen zien wat er gebeurt. Dit is precies de laag die wij voor klanten bouwen: AI agents en automatisering die ook na de demo blijft werken. Het groeisysteem onder de site die je nu leest, draait er zelf op: elke wijziging gaat door zo’n loop, met guardrails en een mens die tekent voor wat eruit gaat.
Een agent loop schrijf je in een middag. Een harness die maandenlang op echte data standhoudt zonder te ontsporen, dat is engineering.
Conclusie: het model levert tekst, de harness levert een agent
Een harness wordt begrijpelijk zodra je hem ziet als de motor rond het model. Het model voorspelt tekst; de harness draait de loop die daar acties van maakt, en zet de grenzen waarbinnen dat veilig gebeurt.
De loop is het hart
Model, tool, resultaat, weer het model, tot de taak af is. Dat is wat elke agent onder de motorkap draait.
De controle zit in de harness
Contextbeheer, foutafhandeling en guardrails maken het verschil tussen een demo en iets dat op echte data standhoudt.
Het model wissel je, de harness is van jou
Modellen veranderen. De harness eromheen is waar jouw tools, je grenzen en je betrouwbaarheid in zitten.
Begin met een bestaande harness, leer waar hij je in de weg zit en bouw pas je eigen versie als je die echt nodig hebt. Werkend in een demo en betrouwbaar in productie zijn twee verschillende dingen, en het verschil zit in de harness.
Wat is een AI-harness?
Wat is het verschil tussen een harness en een AI agent?
Wat is een agent loop?
Heb ik een eigen harness nodig of kan ik een bestaande gebruiken?
Waarom bepaalt de harness of een agent betrouwbaar is?
Een AI agent die betrouwbaar op je eigen systemen draait?
Wij bouwen de harness rond het model: de loop, de tools, het contextbeheer en de guardrails die je agent op koers houden terwijl je systemen en de modellen veranderen. Van eerste opzet tot beheer.
