🔢 mathematics

Harness Engineering as Categorical Architecture

Dit artikel vestigt categorische architectuur als de formele theoretische basis voor het engineering van LLM-agentharnassen door de vier pijlers van agentexternalisatie te koppelen aan de (G, Know, Phi)-tripel van het ArchAgents-framework, waardoor structurele garanties en cross-framework-compilatie mogelijk worden die worden geverifieerd via identiteit en replay in plaats van correctheid van de outputlaag.

Oorspronkelijke auteurs: Bogdan Banu

Gepubliceerd 2026-05-13

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Bogdan Banu

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Grote Idee: De "Tuig" versus het "Brein"

Stel je voor dat je een briljante, superslimme assistent hebt (het AI-model). Deze assistent weet alles in de wereld, maar is een beetje chaotisch. Het kan vergeten wat je vijf minuten geleden vroeg, het kan proberen hulpmiddelen te gebruiken die het niet heeft, of het kan in de war raken over de volgorde van bewerkingen.

In de wereld van AI is het Model het brein. Maar de Tuig (Harness) is alles wat daarbuiten ligt: het notitieboek waarin het dingen opschrijft (Geheugen), de gereedschapskist die het gebruikt (Vaardigheden), de regels die het volgt om met je te praten (Protocollen), en de manager die vertelt wat het als volgende moet doen (Orkestratie).

Het artikel stelt dat ingenieurs al lang deze "managers" (tuig) hebben gebouwd door te gissen en dingen uit te proberen (proef en fout). Ze hadden geen formeel regelboek om te bewijzen dat hun manager betrouwbaar zou werken.

Dit artikel zegt: "We hebben een op wiskunde gebaseerd regelboek voor het bouwen van deze managers, en we kunnen bewijzen dat het werkt."

Het Driedelige Blauwdruk: De "Architectuurtripel"

De auteurs introduceren een wiskundig raamwerk dat de Architectuurtripel wordt genoemd. Denk hierbij aan een blauwdruk voor het bouwen van een betrouwbare AI-manager. Het heeft drie onderdelen:

Het Bedradingsschema (G): Dit is het stroomschema. Het toont hoe informatie van de ene stap naar de volgende stroomt. Analogie: De leidingen in een huis. Het toont waar het water (data) stroomt, maar niet wat het water is.
Het Regelboek (Know): Dit is het belangrijkste onderdeel. Het somt de "structurele garanties" of beloften op die het systeem doet. Analogie: De bouwvoorschriften. Het belooft dingen zoals "Het dak zal nooit lekken" of "De vluchtweg zal altijd open zijn", ongeacht wie in het huis woont.
De Implementatiekaart (Φ): Dit is de instructie over welk specifiek brein (AI-model) voor welk werk moet worden gebruikt. Analogie: Het personeelsrooster. Het zegt: "Gebruik de junior-kok voor het snijden van groenten, maar de chef-kok voor het hoofdgerecht."

De Vier Pilaren van de Manager

Het artikel verbindt dit wiskundige blauwdruk met vier dingen uit de echte wereld die ingenieurs al bouwen:

Geheugen: Het vermogen van het systeem om zich te herinneren. In de wiskundige wereld wordt dit behandeld als een "toestandsmachine" die in de loop van de tijd wordt bijgewerkt.
Vaardigheden: De hulpmiddelen die de agent kan gebruiken. In de wiskundige wereld zijn dit als Lego-blokjes die op specifieke manieren aan elkaar kunnen worden geklikt (in een rij, naast elkaar, of in een lus).
Protocollen: Hoe de agent met zichzelf of anderen praat. In de wiskundige wereld is dit de "bedrading" die ervoor zorgt dat het juiste type bericht in de juiste sleuf terechtkomt.
De Tuig: Het hele systeem zelf.

De Magische Truc: "Behoud van Certificaten"

De grootste claim van het artikel gaat over portabiliteit.

Stel je voor dat je een complexe machine (een tuig) bouwt in een fabriek in Duitsland. Je wilt de blauwdrukken naar een fabriek in Japan sturen om exact dezelfde machine te bouwen. Meestal, wanneer je blauwdrukken vertaalt, kun je per ongeluk een veiligheidsfunctie verliezen of een tandwielverhouding veranderen.

Dit artikel beweert dat, omdat ze deze "Architectuurtripel"-wiskunde gebruiken, ze de tuig van het ene softwareframework naar het andere kunnen vertalen (bijvoorbeeld van LangGraph naar Swarms) zonder de veiligheidsgaranties te verliezen.

Ze noemen deze garanties "Certificaten".

Voorbeeld-certificaat: "Als de kwaliteit van het antwoord te laag is, schakelt het systeem automatisch over naar een slimmer, duurder AI-model."
De Test: Toen ze de tuig naar een nieuw framework vertaalden, keken ze niet alleen of de code werkte. Ze controleerden of het Certificaat nog steeds waar was. Ze bewezen dat de "veiligheidsschakelaar" nog steeds werkte, zelfs al zag de onderliggende code er anders uit.

De Experimenten: Werkte het echt?

De auteurs hebben niet alleen over wiskunde gepraat; ze bouwden een prototype en voerden tests uit.

1. De "Escalatie"-test
Ze stelden een taak in waarbij een "snel maar dom" AI-model probeerde een probleem op te lossen.

De Opzet: Het snelle model probeerde een code-review te schrijven.
De Regel: Als de kwaliteitscore te laag was, moest het systeem "escaleren" naar een "traag maar slim" model.
Het Resultaat: Het snelle model faalde. Het systeem controleerde de score, zag dat deze te laag was, en schakelde automatisch over naar het slimme model.
Waarom dit belangrijk is: Dit bewees dat de regel (de tuig) perfect werkte, zelfs al veranderde het brein (het model). De tuig heeft de controle, niet het model.

2. De "Code-reparatie"-test (SWE-bench)
Ze probeerden hun systeem te gebruiken om bugs in echte software (Python-code) te repareren.

Het Resultaat: Ze liepen tegen een muur aan. De AI-modellen die ze gebruikten (die kleine, lokale versies waren) waren simpelweg niet slim genoeg om de code correct te schrijven, hoe goed de tuig ook was.
De Les: Een geweldige tuig kan een gebroken brein niet repareren. Als het AI-model te klein of te zwak is, zal het de code niet correct kunnen formatteren, en kan de tuig het niet redden. Dit is een "plafond" voor wat de huidige kleine modellen kunnen doen.

De Conclusie

Dit artikel is een brug tussen wiskundige theorie en technische praktijk.

Voorheen: Ingenieurs bouwden AI-managers door te gissen. "Laten we hier een veiligheidscontrole toevoegen."
Nu: Ingenieurs kunnen een formeel wiskundige taal gebruiken om de manager te ontwerpen, te bewijzen dat de veiligheidscontroles zullen blijven bestaan wanneer ze softwaretools veranderen, en ervoor zorgen dat het systeem betrouwbaar gedraagt, ongeacht welk AI-model er wordt aangesloten.

Kortom: Het artikel biedt de "handleiding" en de "kwaliteitscontroletest" voor het bouwen van AI-systemen die betrouwbaar, verplaatsbaar en veilig zijn, en bewijst dat de structuur van het systeem net zo belangrijk is als de intelligentie van het model erin.

Technische Samenvatting: Harness-engineering als Categorieale Architectuur

1. Probleemstelling

De engineering van "agent-harnesses"—de systeemlaag die prompts, tools, geheugen en orkestratielogica om Large Language Models (LLMs) heen omvat—is de primaire bepalende factor geworden voor de betrouwbaarheid van agenten. Echter, het huidige harness-ontwerp blijft ad hoc, zonder een formele theorie voor compositie, eigendomsbehoud onder compilatie, of systematische vergelijking tussen frameworks. Beoefenaars vertrouwen op trial-and-error in plaats van structurele garanties, wat leidt tot een kloof waar engineers bouwen zonder formele verificatie en theoretici formaliseren zonder praktische onderbouwing.

2. Methodologie

Het artikel stelt een formele unificatie voor van twee bestaande frameworks:

De Externalisatiezuilen (Zhou et al.): Geheugen, Vaardigheden, Protocollen en Harness-engineering.
De ArchAgents-categorie (De los Riscos et al.): Een Architectuur-triplet $(G, Know, \Phi)$ dat syntactische bedrading, structurele kennis en implementatiekaarten voorstelt.

De kernmethodologie omvat het direct afbeelden van de vier externalisatiezuilen op de componenten van het Architectuur-triplet:

Geheugen $\rightarrow$ Coalgebraïsche Toestand: Gemodelleerd als een dynamisch systeem met update-regels (bijv. bi-temporeel geheugen dat geldige tijd versus opnametijd bijhoudt).
Vaardigheden $\rightarrow$ Operad-gecomposeerde Objecten: Procedurele capaciteiten samengesteld via een operad (serieel, parallel, trace-operaties) om te waarborgen dat getypeerde compositie eigenschappen behoudt.
Protocollen $\rightarrow$ Syntactische Bedrading ( $G$ ): Een grafiek van modules met getypeerde poorten en integriteitslabels (lenzen, prisma's, traversals).
Harness $\rightarrow$ Volledige Architectuur $(G, Know, \Phi)$ : Het complete systeem waar structurele garanties worden gecodeerd als Know-niveau certificaten.

Kernmechanisme: Certificaatbehoud
Het artikel definieert een structurele garantie als een certificaat $(\tau, \sigma, evds)$ —een stelling, parametermapping en herhaalbaar bewijs. Een compiler (morfisme) tussen frameworks is alleen geldig als het deze certificaten behoudt. Behoud wordt niet geverifieerd door de correctheid van modeloutput te controleren, maar door structurele replay: waarborgen dat de stelling, parameters en bewijs de compilatie overleven en mechanisch opnieuw kunnen worden geverifieerd in het doelframework.

3. Belangrijkste Bijdragen

Formele Correspondentie: Stelt vast dat de vier zuilen van agent-externalisatie precies corresponderen met de categorische Architectuur-triplet, waardoor een wiskundige basis wordt geboden voor harness-engineering.
Certificaatbehoud-Invariant: Introduceert een mechanisme waarbij structurele garanties (bijv. integriteitspoortjes, kwaliteitsgebaseerde escalatie) worden behandeld als herhaalbare artefacten die onafhankelijk zijn van het onderliggende model of framework.
Referentie-implementatie (Operon): Een concrete implementatie met:
- Vijf compiler-functors gericht op Swarms, DeerFlow, Ralph, Scion en LangGraph.
- Een LangGraph-compiler die één node per fase creëert, de native run_single_stage()-methode aanroept om herimplementatie van harness-logica te voorkomen, en toch observabiliteit behoudt.
- Een atomaire vaardigheiden-catalogus gebaseerd op Ma et al.'s vijf coderingsvaardigheden, afgebeeld op operad-composities.
Empirische Validatie:
- Compiler-verificatie: Aangetoond dat drie genoemde certificaattypen (prioriteitspoortjes, geen valse activering, geen oscillatie) met 100% identiteit en verificatie worden behouden over alle vijf compiler-doelen.
- Modelparametriciteit: Een escalatie-experiment toonde aan dat een kwaliteitsgebaseerd controlepad (escalatie van een snel model naar een diep model op basis van een verifierscore) correct functioneert ongeacht het specifieke gebruikte model, wat bevestigt dat de harness model-parametrisch is.

4. Resultaten

Structureel Behoud: Over vijf verschillende orkestratieframeworks behielden de compiler-functors succesvol de grafstructuur en certificaatinvarianten. De structurele garanties overleefden de compilatie omdat ze vertrouwen op behouden hooks en parameters, niet op specifieke graf-topologieën.
Escalatiecontrole: In een experiment met twee modellen en één taak, triggere een kwaliteitsgebaseerd escalatiemechanisme succesvol een schakeling van een Phi-3 Mini (snel) naar een Gemma 4 (diep) model toen de kwaliteit onder een drempel viel. Dit bevestigde dat de controlelogica in de harness-structuur ($Know$) zit, niet in het model.
SWE-bench-lite-beperkingen (Negatieve Resultaten):
- Experimenten op SWE-bench-lite met 8B-parametermodellen (Gemma 4 en DeepSeek-R1 gedistilleerd) onthulden een format-disciplineplafond.
- Ondanks grounding (leveren van repository-context) en een retry-lus voor formatcorrectie, werden 0/30 inzendingen opgelost.
- De dominante faalmodus was het onvermogen om geldige git apply-compatibele diffs te produceren (bijv. lege extracties, misvormde hunk-headers), niet fouten bij bestandsselectie.
- Het artikel concludeert dat op de 8B-schaal het vermogen van het model om correcte diff-formaten uit te zenden de bindende beperking is, en dat drie-fasen decompositie deze beperking niet verlicht. De waarde van de harness in deze context is beperkt tot behoud en primitief hergebruik, niet tot verbetering van taakoplossing op deze specifieke benchmark met deze modelgroottes.

5. Betekenis en Claims

Het artikel stelt dat categorale architectuur de formele theorie achter harness-engineering is. De betekenis hiervan ligt in:

Verschuiving van de Abstractie: De focus verplaatsen van "modelcentrisch" naar "harnesscentrisch" ontwerp met formele garanties.
Portabiliteit: Bewijzen dat structurele garanties kunnen worden behouden over verschillende softwareframeworks (bijv. van een aangepast "Organisme" naar LangGraph) via structuurbehoudende morfismen.
Modelonafhankelijkheid: Aantonen dat structurele certificaten ($Know$) verschillend zijn van implementatiekaarten ( $\Phi$ ), waardoor dezelfde harness-logica op verschillende modellen kan draaien zonder zijn integriteitseigenschappen te verliezen.

De auteurs geven expliciet bescheidenheid aan met betrekking tot de resultaten: de aangetoonde waarde ligt in behoud (certificaatidentiteit over compilers) en primitief hergebruik (escalatielogica), niet in het bereiken van superieure taakoplossing op SWE-bench-lite met huidige lokale 8B-modellen. Het werk overbrugt de kloof tussen theoretische categorale theorie en praktische agent-engineering door een vocabulaire en een gereedschapsset te bieden voor het definiëren en verifiëren van harness-eigenschappen.