💻 computer science

ARCHER: Agentic Rule and Compliance Harness for Executable Regulations

Het artikel introduceert ARCHER, een deterministische multi-agent programmasynthese-harness die controleerbare verificatiecode genereert vanuit regelgevende documenten om schaalbare, transparante en zeer nauwkeurige controle van bouwvoorschriften te bereiken, waarbij wordt aangetoond dat zelfgehoste open-weights modellen de prestaties van frontier API's kunnen evenaren tegen een fractie van de kosten.

Oorspronkelijke auteurs: Chiraag Singh Anand, Xue Wen Tan, Lionel Teo, Eric Tan

Gepubliceerd 2026-07-29

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Chiraag Singh Anand, Xue Wen Tan, Lionel Teo, Eric Tan

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

Stel je voor dat je een robot probeert te leren om een zeer strikte set regels te volgen voor het bouwen van een huis. Het probleem is niet dat de robot lui is; het is dat het regelboek geschreven is in menselijke taal, vol vage zinnen als "zorg ervoor dat de gang breed genoeg is", terwijl de robot alleen maar wiskunde en geometrie begrijpt. In de wereld van de architectuur worden deze regels "bouwvoorschriften" genoemd, en de blauwdrukken zijn digitale 3D-modellen die bekend staan als BIM (Building Information Modeling). Decennialang was het controleren of een ontwerp aan de regels voldoet een enorme, dure hoofdpijn, waarbij meestal legers aan menselijke experts nodig waren om handmatig duizenden regels code en geometrie te scannen. Het is alsof je probeert een enkele typefout te vinden in een bibliotheek van een miljoen boeken door elke pagina met een vergrootglas te lezen.

Onlangs zijn wetenschappers begonnen met het gebruik van "AI-agenten" — slimme computerprogramma's die kunnen denken, plannen en code schrijven — om hiermee te helpen. Maar hier komt de crux: als je een slimme AI simpelweg vraagt om "een regelcontroleur te schrijven", raakt het vaak in de war, verzint het regels die niet bestaan, of schrijft het code die vastloopt. Het is alsof je een briljante maar chaotische chef vraagt om een taart te bakken zonder recept; ze kunnen iets lekkers maken, of ze kunnen de keuken in brand steken. De grote vraag die onderzoekers stellen is: hoe organiseren we deze AI-agenten zodat ze niet gewoon gokken, maar daadwerkelijk betrouwbare, werkende tools bouwen die we kunnen vertrouwen? Dit is de puzzel die een team van de Infocomm Media Development Authority uit Singapore besloot op te lossen.

De ARCHER: Een Team van AI-Architecten

Het artikel introduceert een nieuw systeem genaamd ARCHER (Agentic Rule and Compliance Harness for Executable Regulations). Denk aan ARCHER niet als één enkel superbrein, maar als een zeer georganiseerde bouwploeg waarbij elk lid een specifieke taak heeft en een strikt, onbreekbaar schema volgt.

In het verleden probeerden onderzoekers dit te doen door een enkele AI-model een grote prompt te geven en het beste ervan te hopen. De auteurs noemen dit de "Blind" benadering. Het is alsof je een complexe wiskundige opdracht aan een student geeft en zegt: "Los het maar uit," zonder hem de kans te geven zijn werk te controleren. Het paper vond dat deze methode onbetrouwbaar is. Zelfs de slimste AI-modellen falen vaak in het geven van het juiste antwoord omdat ze hun eigen fouten pas zien als het te laat is.

ARCHER verandert het spel door een multi-agent systeem te gebruiken met een deterministische orchestratie. Laten we dat ontleden met een analogie:

Stel je voor dat je een perfect LEGO-kasteel probeert te bouwen op basis van een vage instructiehandleiding.

De Planner: Eerst leest een "Planner"-agent de handleiding en maakt een stapsgewijze schets van hoe het kasteel gebouwd moet worden. Hij raakt de blokjes nog niet aan; hij maakt alleen een plan.
De Generator: Vervolgens volgt een "Generator"-agent die schets en begint de LEGO-blokjes aan elkaar te klikken, waarbij de werkelijke computercode wordt geschreven.
De Evaluator: Daarna controleert een strikte "Evaluator"-agent het kasteel. Hij meet elke muur en telt elk blokje tegenover de oorspronkelijke regels. Als de muur te kort is, zegt de Evaluator niet alleen "Fout". Hij wijst precies naar de korte muur en zegt: "Repareer dit specifieke blokje."
De Loop: De Generator herstelt dan de fout en probeert het opnieuw. Deze cyclus herhaalt zich tot wel 30 keer. Als de Evaluator beseft dat het plan zelf fout was (en niet alleen de blokjes), stuurt hij het werk terug naar de Planner om de schets opnieuw te tekenen.

Deze "Plan-Genereer-Evalueer"-loop is het geheime ingrediënt. Het paper laat zien dat door de AI te dwingen om zijn eigen werk herhaaldelijk te controleren en specifieke fouten te herstellen, het een vage regel zoals "parkeervakken moeten 2,4 meter breed zijn" kan omzetten in een perfect, werkend computerprogramum dat duizenden 3D-modellen direct controleert.

Wat Ze Vonden: De Kracht van Structuur

De onderzoekers testten dit systeem met behulp van een nieuwe dataset van tien real-world bouwregels en 3D-modellen. Ze vergeleken hun "ARCHER"-ploeg met zes andere manieren om AI te gebruiken, variërend van een enkele verwarde robot tot een team van robots die met elkaar in discussie gaan.

Dit zijn de belangrijkste conclusies, verteld in gewone cijfers:

Structuur wint van pure intelligentie: De meest verrassende bevinding is dat een goed georganiseerd team van "zwakkere" AI-modellen beter presteerde dan een enkel "superintelligent" AI-model dat alleen werkt. Wanneer de AI werd toegestaan om slechts één keer te gokken (de "Blind"-methode), kreeg het gemiddeld slechts ongeveer 47% van de tijd het juiste antwoord. Maar wanneer het team de ARCHER-loop gebruikte, sprong de nauwkeurigheid naar gemiddeld 85%. Dat is een verbetering van 82% ten opzichte van de basismethode.
De "Orchestrator" doet ertoe: Het team testte twee manieren om de ploeg aan te sturen. De ene manier liet een AI beslissen wie met wie praat (zoals een chaotische vergadering). De andere manier gebruikte een vast, onveranderlijk schema (zoals een militaire oefening). Ze ontdekten dat het vaste schema (ARCHER) veel betrouwbaarder was. Het verbeterde de nauwkeurigheid met wel 24,5 procentpunt voor sommige modellen vergeleken met de chaotische versie.
Goedkoop is niet altijd goedkoper: Het team testte vier verschillende AI-modellen, van dure, top-tier "frontier" modellen (die veel geld kosten om te draaien) tot goedkopere, zelf gehoste modellen (die je op je eigen computer kunt draaien).
- De dure modellen waren geweldig, maar het paper vond dat een goedkoper, zelf gehost model dat draait op het ARCHER-systeem 97,8% van de nauwkeurigheid van het dure model kon bereiken.
- Nog beter: deze goedkopere opstelling kostte slechts één vierde van de prijs.
- Dit suggereert dat organisaties geen fortuin hoeven uit te geven aan de duurste AI voor geweldige resultaten; ze hebben alleen het juiste systeem (ARCHER) nodig om de goedkopere AI te begeleiden.

Waarom Dit Belangrijk Is

Het paper betoogt dat de controle op naleving van bouwvoorschriften te lang in een "handmatig" tijdperk is blijven steken. Bestaande tools zijn vaak vergrendeld achter dure, propriëtaire software die niemand kan inzien of aanpassen. Als een regel ambigu is, faalt de software simpelweg, en moet je een mens bellen.

ARCHER suggereert een nieuwe weg voorwaarts: Transparant, aanpasbaar en schaalbaar. Omdat het systeem standaard Python-code schrijft (een veelgebruikte programmeertaal), kunnen mensen de door de AI geschreven code daadwerkelijk lezen om te zien hoe de AI besloot of een gebouw veilig was of niet. Als de AI iets fout doet, kan een mens de code bekijken, de logica begrijpen en het corrigeren.

De auteurs merken er voorzichtig bij op dat dit geen toverstaf is die elk probleem oplost. Sommige bouwregels zijn simpelweg te complex voor een computer om perfect te meten (zoals het beoordelen of een vreemd gevormde trap "veilig" is op een manier die menselijke intuïtie vereist). Voor die gevallen is het systeem ontworpen om ze te markeren voor een menselijke controle (gelabeld als "MANUAL_CHECK"). Maar voor de duizenden standaardregels — zoals "is de deur breed genoeg?" of "is het parkeervak de juiste grootte?" — suggereert ARCHER dat we nu het zware werk met hoge nauwkeurigheid en lage kosten kunnen automatiseren.

Kortom, het paper bewijst dat als je AI een strikte functiebeschrijving geeft, een team van specialisten en een loop om zijn huiswerk te controleren, het de rommelige, verwarrende bouwregels kan omzetten in heldere, werkende code. Het verandert de "black box" van AI in een transparante, controleerbare tool die er ooit voor kan zorgen dat bouwen veiliger, sneller en goedkoper is voor iedereen.

Technische Samenvatting: ARCHER (Agentic Rule and Compliance Harness for Executable Regulations)

1. Probleemdefinitie

Building Information Modeling (BIM) heeft het architectonisch ontwerp getransformeerd naar semantisch rijke, interoperabele datamodellen via het Industry Foundation Classes (IFC) schema. Het verifiëren van naleving (compliance) tegenover deze modellen blijft echter een handmatige, kostbare en niet-schaalbare flessenhals, vooral in jurisdicties zoals Singapore waar projecten aan duizenden regelgevende regels moeten voldoen.

Bestaande Automated Compliance Checkers (ACC's) kampen met drie primaire beperkingen:

Gebrek aan Generaliseerbaarheid: Ze zijn doorgaans hard-coded voor specifieke regelsets en use cases, waardoor ze moeilijk aan te passen zijn aan nieuwe regelgeving.
Propriëtaire Opaciteit: Veel commerciële ACC's geven de onderliggende verificatiecode niet vrij, wat gebruikers verhindert te verifiëren of hun regelgevende intentie accuraat is vastgelegd.
Ambiguïteit in Operationalisering: Natuurlijke taalregels zijn vaak ambigu met betrekking tot geometrische meting (bijv. hoe de breedte van een parkeerplaats te meten die wordt gerepresenteerd als een solide versus 2D-lijnen). Domeinexperts bezitten de regelgevende intentie maar missen de programmeerkennis om dit te formaliseren, terwijl ontwikkelaars de domeinkennis missen om de regels getrouw te interpreteren.

Huidige Large Language Model (LLM) benaderingen hebben enkele barrières verlaagd, maar vertrouwen vaak op vooraf gedefinieerde API's of geëxtraheerde metadata, waarbij ze er niet in slagen de ruimtelijke en contextuele redenering te vatten die vereist is voor handmatige deskundige beoordeling. Bovendien missen ze de betrouwbaarheid van test-gedreven feedbackloops die te vinden zijn in breder onderzoek naar agentic code-generatie.

2. Methodologie: Het ARCHER-framework

De auteurs introduceren ARCHER, een test-gedreven, deterministisch georkestreerde multi-agent programma-synthese harness. Het doel is om controleerbare, uitvoerbare Python compliance checkers te genereren vanuit "Codes of Practice" en door experts gelabelde BIM-modellen.

Kernarchitectuur

ARCHER werkt op twee door experts geautoriseerde artefacten:

Rule Interpretation (RI): Een tekstueel document dat de regelgevende logica vertaalt naar een ondubbelzinnige flow (bijv. het definiëren van wat een "pass", "fail" of "manual check" inhoudt zonder de geometrische berekeningsmethode te specificeren).
Gelabelde BIM-modellen: Trainingsparen ( $D_{train}$ ) en testparen ( $D_{test}$ ) waarbij domeinexperts oordelen ( $L = \{PASS, FAIL, ALERT, MANUAL\_CHECK, NA\}$ ) hebben toegewezen aan specifieke elementen.

De Synthese-loop

ARCHER maakt gebruik van een deterministische multi-agent orchestratie (Harness 5) bestaande uit drie gespecialiseerde agents:

Planner: Stelt een coderingsplan op op basis van de RI.
Generator: Schrijft of bewerkt Python-code (main.py) om het plan te implementeren.
Evaluator: Voert de gegenereerde code uit tegen $D_{train}$ , berekent de Union Accuracy ( $A_\cup$ ), en geeft feedback.

Het systeem iterereert tot maximaal 30 keer. Als de Evaluator een fout identificeert die geworteld is in het logische plan in plaats van een programmeerfout, triggert het een Replan (tot 2 keer), waarbij de controle teruggaat naar de Planner. De loop eindigt wanneer de gegenereerde checker een perfecte overeenstemming ( $A_\cup = 1.0$ ) bereikt op de trainingsset of de iteratielimiet bereikt. De uiteindelijke checker wordt één keer geëvalueerd op de uitgesloten testset ( $D_{test}$ ).

Evaluatie Taxonomie

Om de effectiviteit van agentic synthese te karakteriseren, evalueerden de auteurs een taxonomie van zes harnesses variërend van eenvoudig tot geavanceerd:

H0 (Blind): Enkele agent, geen toegang tot trainingsdata.
H1 (BIM Model Aware): Enkele agent, uitvoering tegen model alleen.
H2 (Full TDD): Enkele agent met volledige scoring feedback.
H3 (Planning Step): Enkele agent met expliciete planning.
H4 (Multi-Agent, Non-Deterministic): LLM-georkestreerde pipeline.
H5 (Multi-Agent, Deterministic - ARCHER): Vaste controle-loop die Planner, Generator en Evaluator orkestreert.

3. Belangrijkste Bijdragen

Eerste Toepassing van Agentic Synthesis: De auteurs beweren de eersten te zijn die agentic program synthesis specifiek toepassen op geautomatiseerde bouw-compliance checking.
ARCHER Harness: Een nieuwe multi-agent architectuur die planning, generatie en evaluatie orkestreert om inspecteerbare, uitvoerbare compliance checkers te produceren.
Uitgebreide Kosten–Nauwkeurigheid Analyse: Een studie die vier backbone modellen beslaat (van frontier API's tot on-premise open-weights modellen) over verschillende deployment tiers (third-party, private cloud, on-premise).
Nieuwe Benchmark Dataset: Een dataset van tien reële regelgevende vereisten gekoppeld aan expert-gelabelde BIM-modellen, ontworpen om robuustheid te testen tegen out-of-distribution (OOD) variaties in geometrie en metadata.

4. Experimentele Resultaten

De studie evalueerde de zes harnesses over vier backbone modellen: GPT-5.5 (Frontier API), GPT-5.4 Mini (Budget API), DeepSeek-v4-flash (Self-hosted), en GPT-OSS-120B-Q4KM (On-premise).

Bevindingen over Nauwkeurigheid

ARCHER (Harness 5) is Uniform de Beste: Het behaalde de hoogste union accuracy voor elk backbone model.
Significante Verbetering: ARCHER verbeterde de gemiddelde union accuracy met 82% ten opzichte van de naïeve single-pass prompting baseline (H0), waarmee het gemiddelde steeg van 0.468 naar 0.850.
Deterministisch vs. LLM Orchestratie: De deterministische controle-loop (H5) presteerde beter dan de LLM-georkestreerde pipeline (H4) over alle modellen, vooral voor zwakkere backbones die moeite hadden met het sequensen van hun eigen sub-agents.
Feedback Structuur: Het blootstellen van volledige test-gedreven feedback aan een enkele agent (H2) degradeerde de prestaties voor open-weights modellen. Gestructureerde multi-agent harnesses waren nodig om dichte scoring feedback om te zetten in gerichte code-revisies.

Kosten en Efficiëntie

Token Consumptie: Tokengebruik schaalde invers met de modelcapaciteit. Zwakkere modellen (bijv. GPT-OSS-120B) consumeerden aanzienlijk meer tokens (tot 223,7× meer input tokens dan GPT-5.5 in Harness 5) vanwege herhaalde verfijningsloops.
Kosten–Nauwkeurigheid Afruil:
- Harness Sophisticatie > Model Prijs: Het verhogen van het harness-niveau binnen een modelfamilie leverde betere resultaten op dan het overstappen naar een duurder backbone model.
- Data Soevereiniteit: Een zelf-gehost open-weights model (DeepSeek-v4-flash) onder ARCHER bereikte 97,8% van de nauwkeurigheid van de frontier API tegen ongeveer één vierde van de kosten.
- Pareto Frontier: De meest kosteneffectieve configuraties werden gevonden onder zelf-hostbare modellen die de ARCHER harness gebruiken, wat data-soevereine compliance checking praktisch maakt.

Scenario Moeilijkheidsgraad

Vereisten die relationele of topologische redenering vereisen (bijv. vluchtwegen, rioolverbindingen) waren aanzienlijk moeilijker en duurder om te synthetiseren dan eenvoudige dimensionale controles.
Hoewel het frontier model (GPT-5.5) de moeilijkste scenario's oploste (bijv. R5, R10) waar anderen faalden, kwam het zelf-gehoste DeepSeek model op 7 van de 10 vereisten gelijk aan of presteerde het beter dan het frontier model.

5. Betekenis en Claims

Het artikel positioneert ARCHER als een stap naar transparante, aanpasbare en schaalbare compliance checking. De primaire betekenis ligt in:

Democratisering van Compliance: Door open, inspecteerbare Python-code te genereren, verwijdert het de "black box"-natuur van propriëtaire ACC's, waardoor domeinexperts de logica kunnen auditeren.
Haalbaarheid van On-Premise Oplossingen: Het demonstreert dat organisaties met strikte eisen aan data-soevereiniteit (bijv. overheid of defensie) een bijna-frontier nauwkeurigheid kunnen bereiken met zelf-gehoste open-weights modellen, mits ze een geavanceerde agentic harness gebruiken.
Mens-Agent Samenwerking: Het systeem wordt geframed als een collaboratieve tool waarbij experts de intentie definiëren (via RI) en de agent de computationele implementatie afhandelt, waardoor de kloof tussen regelgevende intentie en uitvoerbare logica wordt overbrugd.

Beperkingen

De auteurs erkennen dat ARCHER niet volledig autonoom is. Het vereist voorafgaande inspanning van experts om Rule Interpretation documenten te schrijven en trainingsdata te labelen. Daarnaast behandelt het systeem regels in isolatie, modelleert het geen onderlinge afhankelijkheden tussen regels, en blijft het gebonden aan de geometrische beperkingen van BIM-schema's (vandaar de inclusie van MANUAL_CHECK voor ambigue gevallen). Toekomstig werk wordt gesuggereerd om regelafhankelijkheden aan te pakken via semantische kennisgrafen en om vision-language modellen te integreren voor niet-deterministische geometrische controles.