Wat is een Agent Harness? Hoe AI-agents tools, geheugen en controle krijgen

Het idee is niet gloednieuw. Ontwikkelaars bouwen al jaren wrappers, steigers en uitvoeringsomgevingen rondom modellen. Het label verspreidde zich nadat Mitchell Hashimoto, medeoprichter van HashiCorp, in februari 2026 de term "harness engineering" gebruikte in een blogpost over zijn AI-werkstroom. Zijn punt was simpel: wanneer een agent een fout maakt, verander de omgeving zodat die fout niet opnieuw kan gebeuren. OpenAI nam de term dezelfde week over voor zijn Codex-werk, en LangChain volgde met hetzelfde kader.

In dit artikel leg ik uit wat een agent harness is, waarom AI-agents er een nodig hebben, hoe het verschilt van frameworks en runtimes, en welke tools ontwikkelaars gebruiken om systemen in deze stijl te bouwen.

Wat is een Agent Harness?

Eén definitie komt van LangChain: "Als je niet het model bent, ben je de harness." In de praktijk is een agent harness de software rond een taalmodel: tools, geheugen, staat, uitvoering, guardrails en observeerbaarheid.

Agent = Model + Harness

Het model redeneert. De harness geeft dat redeneren een plek om te handelen, te onthouden, resultaten te controleren en regels te volgen.

Model binnen zijn werkende agent harness. Afbeelding door de auteur.

De formule is nuttig, maar het is een mentaal model, geen industriestandaard. Sommige leveranciers gebruiken "harness", "framework" en "scaffold" nog steeds min of meer als synoniemen.

Waarom AI-agents een harness nodig hebben

Een ruw taalmodel heeft beperkingen wanneer je het vraagt om over veel stappen te werken. Het houdt niet zelfstandig een duurzame staat bij, voert niet uit zichzelf tools uit, beheert niet zelfstandig een groeiend contextvenster, en herstelt niet zonder hulp van mislukte tool-calls. 

Stel je een agent voor die een falende test in een Python-project moet fixen. Zonder harness kan het model een oplossing opschrijven die erop lijkt, maar het kan het daadwerkelijke testbestand niet lezen, pytest niet draaien, de echte fout niet zien, de falende functie niet bewerken of bevestigen dat de fix slaagt. Met een harness wordt die hele lus een klusje van een paar minuten dat de agent zelf uitvoert, met elke stap ergens vastgelegd zodat een mens het kan nakijken.

De richtlijnen van Anthropic blijven wel gelden: begin zo simpel mogelijk en voeg alleen bewegende delen toe als de taak daar om vraagt.

Waaruit een agent harness bestaat

De onderdelen verschillen, maar de meesten delen een paar bouwstenen. Zie ze als een checklist, niet als een strikte productspecificatie. Een kleine agent heeft misschien maar een paar van deze stukken nodig, terwijl een productieagent er meer nodig heeft.

Systeemprompts en gedragsregels

De harness beheert meestal de basisinstructies van het model. Dit omvat de systeemprompt, maar kan ook projectregels, codeerstandaarden, rolinperkingen en veiligheidsbeleid omvatten. In LangChains Deep Agents kan bijvoorbeeld een AGENTS.md-bestand de spelregels vastleggen voordat een taak begint.

Sommige harnesses in 2026 gebruiken ook progressieve onthulling van instructies. In plaats van bij het opstarten elke toolbeschrijving in de context te laden, voegt de harness alleen een samenvatting toe van wat er beschikbaar is. Volledige instructies voor een tool worden pas geladen wanneer het model die tool nodig heeft.

Tools: hoe agents met de wereld omgaan

Tools laten de agent dingen doen buiten tekstgeneratie. Veelvoorkomende voorbeelden zijn webzoekopdrachten, bestanden lezen en schrijven, databasequeries, API-calls, browseracties, code-uitvoering en terminalcommando's. De harness bepaalt welke tools beschikbaar zijn, wanneer het model ze mag aanroepen, en hoe resultaten worden opgemaakt en teruggegeven aan de context van de agent.

Model Context Protocol (MCP) is in 2026 de standaardinterface hiervoor geworden. Veel harnesses, waaronder de Anthropic Agent SDK, LangChain Deep Agents en de OpenAI Agents SDK, gebruiken MCP om externe toolservers te koppelen zonder voor elk daarvan aangepaste integratiecode te schrijven.

Geheugen en staat

Agents moeten weten wat er eerder in een taak is gebeurd. Een harness kan kortetermijnstaat bewaren in het actieve gesprek en langetermijnstaat in bestanden, logs, samenvattingen of opgeslagen voorkeuren. Sommige harnesses comprimeren ook lange geschiedenissen tot kortere samenvattingen zodat het model niet elk detail in context hoeft mee te dragen.

Uitvoeringsomgeving: waar de agent draait en handelt

Veel nuttige agents hebben ergens een plek nodig om daadwerkelijk te werken. Dat kan een bestandssysteem zijn, een container, een gesandboxte terminal, een browserinstantie of een cloudruntime. Zonder een door de harness beheerde uitvoeringsomgeving hebben tool-calls geen landingsplek.

Veel harnesses gebruiken nu geïsoleerde sandboxcontainers: kortlevende omgevingen die zijn afgebakend tot één sessie en worden opgeschoond wanneer de taak eindigt, zodat bestandsschrijfsels, geïnstalleerde pakketten en netwerkcalls van de ene agenttaak niet in een andere overlopen.

Orchestratie en planning

Sommige taken passen niet in één rechte lijn van stappen. De harness kan een planningstool bieden die een doel opsplitst in subtaken en hun status bijhoudt. Het kan ook subagents starten die één deel van het werk afhandelen en alleen een samenvatting aan de hoofdagent teruggeven.

LangChain Deep Agents houdt bijvoorbeeld planstappen bij in een bestand op het bestandssysteem en werkt elke stap bij van in behandeling naar voltooid terwijl de taak loopt.

Guardrails en permissies

De harness is waar je de regels neerzet: menselijke goedkeuring, geblokkeerde tool-calls, op rollen gebaseerde permissies en outputcontroles. OpenAI Agents SDK, LangChain Deep Agents en Microsoft Agent Framework ondersteunen dit soort controle. Het veiligere patroon is om input, output en toolpermissies afzonderlijk te controleren.

Observeerbaarheid en tracing

Wanneer een agenttaak van vijftig stappen faalt bij stap zevenendertig, laat een trace zien wat er is gebeurd. Tracing registreert model-calls, tool-calls, overdrachten, fouten, latency en kosten gedurende een volledige run. De OpenAI Agents SDK zet tracing standaard aan. LangSmith voegt daar debugging- en evaluatiedashboards bovenop. OpenTelemetry is de standaard geworden voor het exporteren van traces in een leverancier-neutraal formaat, zodat je niet vastzit aan één observatietool.

Agent Harness vs. Framework vs. Runtime: wat is het verschil?

Deze vraag komt vaak terug, en het antwoord is rommeliger dan de meeste uitlegartikelen suggereren. De taxonomie is nuttig, maar niet vaststaand.

Drie lagen, oplopende abstractie van onder naar boven. Afbeelding door de auteur.

Ik begin met het framework, omdat veel ontwikkelaars daar al mee hebben gewerkt.

Wat is een agentframework?

Een agentframework geeft ontwikkelaars bouwstenen om agents te creëren. Het dekt model-calls, tooldefinities, geheugenpatronen en de structuur van de agentlus. Voorbeelden zijn vroegere LangChain, CrewAI en Google ADK. Een framework vertelt je hoe je een agent structureert, maar niet altijd hoe je hem betrouwbaar in productie draait.

Wat is een agentruntime?

Een agentruntime is de laag die helpt een agent betrouwbaar over tijd te laten draaien. Het verzorgt duurzame uitvoering, staatpersistentie, retries, human-in-the-loop-stappen en streaming. LangGraph, Temporal en Inngest zijn voorbeelden. Harrison Chase gaf deze analogie: als Node.js de runtime is en Express het framework, dan is een harness zoals Next.js.

Wat maakt een harness anders?

Een harness staat op een hoger niveau dan een framework. Waar een framework je componenten geeft, komt een harness meestal met meer beslissingen vooraf: tools, planning, toegang tot het bestandssysteem en contextbeheer.

Use-cases voor agent harnesses: coderen, research, data en enterprise

Dezelfde bouwstenen duiken op bij heel verschillende taken, maar de mix verschilt. Een codeagent en een enterprise-workflowagent hebben allebei een harness nodig, maar belasten andere onderdelen. Deze categorieën zijn geen formele standaarden. Het zijn praktische manieren om te zien hoe hetzelfde idee meebuigt met het werk ervoor.

Harnesses voor codeagents

Codeagents zijn nu een goed voorbeeld omdat de harness zichtbaar is. Om nuttig codewerk te doen, heeft een agent bestands­toegang, gitcontext, terminaluitvoering, testruns, installatie van afhankelijkheden en projectregels nodig. Claude Code en Codex zijn voorbeelden van dit patroon: beide draaien op veel harness-code, niet op een kale model-API.

Het verschil tussen een goede en een middelmatige code-harness zie je vaak in kleine details: hoe die herstelt van een mislukte test, of die een slechte edit kan terugdraaien, hoe netjes gitgeschiedenis aan het model wordt blootgesteld. In die details gaat het grootste deel van de engineering-inspanning zitten.

Harnesses voor researchagents

Researchagents hebben een andere toolset nodig: webzoekopdrachten, brontracking, aantekeningen, bronvermelding en samenvatten. De harness beheert hoe zoekresultaten worden opgeslagen, hoe bronnen worden toegewezen en hoe lange documenten worden opgeknipt en ausgeladen om te voorkomen dat het volledige contextvenster in één keer wordt opgesoupeerd.

Harnesses voor data-analyseagents

Data-agents hebben toegang nodig tot datasets, SQL-databases, Python-uitvoeringsomgevingen en schemacontext zodat ze weten welke tabellen en kolommen beschikbaar zijn voordat ze queries gaan schrijven. De harness handhaaft ook permissiegrenzen, wat belangrijk is wanneer de agent productiegegevens kan aanraken.

Enterprise-workflowharnesses

Enterprise-implementaties voegen nog een laag eisen toe: authenticatie, auditlogs, goedkeuringsworkflows, op rollen gebaseerde toegangscontrole en koppelingen naar interne systemen. AWS AgentCore is één beheerd voorbeeld in deze categorie, met identity, VPC-netwerking en observeerbaarheid inbegrepen. Microsoft Agent Framework dekt vergelijkbaar terrein voor teams in Azure- of .NET-omgevingen.

Tools om agent harness-systemen te bouwen in 2026

Een handvol producten komt medio 2026 het vaakst voorbij. Ze zitten op verschillende punten op het spectrum framework-runtime-harness, en de grenzen verschuiven nog steeds.

LangChain Deep Agents

LangChain Deep Agents is LangChains open-source harness, gebouwd op LangGraph als runtime. Het wordt geleverd met een planningstool, virtueel bestandssysteem, het starten van subagents, automatische contextcompactie en middleware voor human-in-the-loop-goedkeuring en PII-detectie. Het is model-agnostisch, ondersteunt OpenAI-compatibele endpoints en koppelt aan sandboxproviders zoals Modal, Runloop en Daytona voor code-uitvoering.

Anthropic Agent SDK

De Anthropic Agent SDK (pakketnaam: claude-agent-sdk) is uit Claude Code gehaald en als losstaande optie uitgebracht. Het bevat een ingebouwde agentlus, tools voor bash-uitvoering, bestanden lezen en schrijven, webzoekopdrachten, MCP-integratie en contextcompactie. Het werkt alleen met Claude-modellen, via de API van Anthropic, Amazon Bedrock, Vertex AI en Azure.

OpenAI Agents SDK

Zoals ik eerder noemde, OpenAI Agents SDK verschoof van framework naar harnessgebied naarmate de featureset groeide. De release van april 2026 voegde native sandboxuitvoering, geheugencompactie en bestandssysteemtools toe. Beschikbaar in Python en TypeScript ondersteunt de SDK toolgebruik, agent-overdrachten en guardrails.

Google Agent Development Kit

Google ADK ondersteunt multi-agentorchestratie met ingebouwde klassen voor sequentiële, parallelle en lusgebaseerde agentstructuren. Het bevat evaluatietools, werkt met Vertex AI voor beheerde deploys en ondersteunt MCP voor toolconnectiviteit. Beschikbaar in Python, Java, TypeScript en Go, is het afgestemd op Gemini-modellen maar beschreven als model-agnostisch.

Microsoft Agent Framework

Microsoft Agent Framework is Microsofts huidige migratiepad voor AutoGen-projecten. Het ondersteunt Python en .NET, werkt met Azure AI-diensten en bevat MCP-ondersteuning voor toolconnectiviteit.

CrewAI

CrewAI hanteert een rolnadering voor multi-agentsystemen. Je definieert agents met specifieke rollen, wijst taken toe, stelt crews samen en configureert geheugen en guardrails declaratief. Het past bij problemen die zich natuurlijk laten vertalen naar een team van specialisten.

Temporal en Inngest

Dit zijn op zichzelf geen agent harnesses. Het zijn platforms voor duurzame uitvoering die afhandelen wat er gebeurt wanneer een agenttaak uren of dagen moet draaien zonder staat te verliezen. Bij falen speelt de engine vanaf het laatste succesvolle checkpoint opnieuw af in plaats van helemaal opnieuw te beginnen.

Uitdagingen en trade-offs van een agent harness

Een harness toevoegen laat het systeem meer doen, maar elke extra tool, permissie en agent voegt ook een extra manier toe waarop dingen kunnen stukgaan. Naarmate taken langer worden, stoppen guardrails, tracing en duurzame staat met optioneel te zijn en worden ze juist wat het herstel van een lange run mogelijk maakt.

Er is ook een koppelinrisico dat teams overvalt. LangChain rapporteerde een sprong van 10 tot 20 punten op een tau2-bench-subset na het toevoegen van modelspecifieke harnessprofielen. Artificial Analysis maakte een vergelijkbaar punt in zijn Coding Agent Index: resultaten van codeagents hangen samen van model en harness, waarbij kosten, tokengebruik en tijd per taak sterk verschillen per combinatie. Het model veranderde niet. De omringende prompts, tools en middleware wel. Dat profiel is op zichzelf harnesswerk.

Heb je eigenlijk een agent harness nodig?

Hier is een directe manier om te bepalen of je er één nodig hebt.

Je hebt waarschijnlijk een harness nodig als je systeem aan één of meer van deze voorwaarden voldoet:

• Het moet externe tools gebruiken
• Het moet voortgang over sessies heen onthouden
• Het moet code draaien in een echte omgeving
• Het coördineert meer dan één agent
• Het moet herstellen van gedeeltelijke fouten zonder werk te verliezen
• Er is menselijke goedkeuring vereist

Je hebt waarschijnlijk geen harness nodig als de taak een voorspelbare workflow is waarbij elke stap vooraf vastligt.

Een nuttige test: als de taak kan worden afgehandeld met één model-call, of met een klein deterministisch script met een handvol conditionele statements, is een harness waarschijnlijk overkill. Op het moment dat de taak vereist dat de agent beslissingen neemt, tools gebruikt en in de tijd op resultaten reageert, begint de harness echt werk te doen.

Een patroon dat ik blijf zien, is teams die te vroeg naar een harness grijpen en tracing en sandboxing bouwen voor wat eigenlijk een one-shot tekstgeneratietaak is. De omgekeerde fout is de pijnlijke: het model direct uitrollen en dan bij de tweede mislukte test, de derde tool-call of de vijfde herstart beseffen dat er geen infrastructuur is om op terug te vallen.

Slotgedachten

Zoals ik eerder noemde, gebruiken leveranciers niet allemaal dezelfde woorden voor dezelfde dingen, en de grens tussen framework, runtime en agent harness verschuift nog steeds.

Voor one-shotgeneratie is de wrapper overkill. Voor agents die over lange sessies moeten handelen, onthouden en herstellen, wordt de agent harness een groot deel van het systeem. De juiste kiezen is in toenemende mate een aparte beslissing van het kiezen van het juiste model. Ik ben benieuwd hoeveel van deze laag de volgende generatie modellen zelf absorbeert, aangezien sommige zetten van OpenAI en Anthropic suggereren dat de grens zal blijven verschuiven. Het basisidee blijft gelden: een agent is een model plus een agent harness.

Wil je meer leren over het bouwen van agentsystemen, dan behandelt onze cursus Building Scalable Agentic Systems de patronen achter toolgebruik, orchestratie en langlopende agentworkflows.