🤖 AI

LabGuard: Grounding Natural-Language Laboratory Rules into Runtime Guards for Embodied Laboratory Agents

LabGuard is een veiligheidssuite die de kloof overbrugt tussen natuurlijke taal-laboratoriumregels en machine-uitvoerbare beperkingen door een getypeerde intermediaire representatie, een benchmark-dataset en een grondingsmodel te introduceren om runtime-monitoren te implementeren die onveilige gebeurtenissen in belichaamde laboratoriumagenten aanzienlijk verminderen terwijl de taaksucces behouden blijft.

Oorspronkelijke auteurs: Jingpu Yang, Fengxian Ji, Zhengzhao Lai, Zhexuan Cui, Guangxian Ouyang, Qian Jiang, Fan Zhang, Min Peng, Qianqian Xie, Preslav Nakov, Zhuohan Xie

Gepubliceerd 2026-07-01

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Jingpu Yang, Fengxian Ji, Zhengzhao Lai, Zhexuan Cui, Guangxian Ouyang, Qian Jiang, Fan Zhang, Min Peng, Qianqian Xie, Preslav Nakov, Zhuohan Xie

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 een hooggeschoolde robotchef voor die werkt in een hightech keuken. Deze robot is ongelooflijk goed in het volgen van complexe recepten om heerlijke gerechten te maken (laboratoriumtaken uitvoeren). Echter, de robot begrijpt van nature de "veiligheidsregels" die in de handboeken van de chef staan geschreven niet, zoals: "Meng nooit bleekmiddel met ammoniak" of "Draag altijd een veiligheidsbril bij het hanteren van hete vloeistoffen." Als de robot probeert een recept te volgen dat per ongeluk deze regels overtreedt, zou dit een gevaarlijke explosie of een giftige bende kunnen veroorzaken.

LabGuard is een nieuw systeem dat dit probleem oplost. Het fungeert als een universele vertaler en een strikte veiligheidsinspecteur die tussen de hersenen van de robot en zijn handen in zit.

Hieronder wordt uitgelegd hoe LabGuard werkt, opgedeeld in eenvoudige stappen:

1. Het Probleem: "Menselijke Taal" vs. "Robotcode"

Momenteel zijn veiligheidsregels in laboratoria geschreven in natuurlijke taal (Engelse zinnen) voor mensen om te lezen. Robots hebben echter machinecode (strikte logica) nodig om te weten wat ze moeten doen.

De Kloof: Een robot kan de zin "Meng geen zuur en base" lezen, maar hij weet niet hoe hij die regel moet controleren terwijl hij zijn arm beweegt. Hij heeft een specifieke instructie nodig zoals: "Als Bak A Zuur bevat en Bak B Base bevat, STOP de mengactie."
Het Risico: Zonder deze vertaling kan een robot een recept perfect volgen, maar per ongeluk een ramp veroorzaken omdat hij een verborgen veiligheidsregel heeft gemist.

2. De Oplossing: De LabGuard "Vertaler"

De onderzoekers hebben een systeem gebouwd genaamd LabGuard dat die menselijke veiligheidszinnen automatisch vertaalt naar robotveilige instructies. Zie dit als een driestaps assemblageproces:

Stap A: De Vertaler (LabGuard-Grounder)

Stel je een superintelligente vertaler voor die een veiligheidshandboek leest en dit omzet in een gestructureerd "veiligheidscontract".

Input: "Meng tijdens het schenken geen zoutzuur met natriumhypochloriet."
Output: Een gestructureerd codeblok dat zegt:
- Wie: Zoutzuur & Natriumhypochloriet.
- Wanneer: Tijdens het schenken of mengen.
- Actie: Als deze twee elkaar ontmoeten, BLOKKEER de actie onmiddellijk.
Dit systeem werd getraind op 812 voorbeelden van veiligheidsregels (zoals een student die 812 flashcards bestudeert), zodat het leert hoe het deze patronen in elk nieuw handboek kan herkennen.

Stap B: De Compiler (De "Veiligheidsbewaker")

Zodra de vertaler het "veiligheidscontract" heeft gemaakt, zet een compiler dit om in een runtime monitor.

Denk aan het installeren van een uitsmijter bij de deur van de robot. Deze uitsmijter leest niet alleen de regels; hij houdt de bewegingen van de robot in real-time actief in de gaten.
Voordat de robot zijn arm beweegt om een vloeistof te schenken, controleert de uitsmijter: "Wacht even, zit er zuur in deze beker? Houd de andere beker bleekmiddel? Zo ja, dan stop ik je."

Stap C: De Executie (Het "Veiligheidsnet")

De robot probeert zijn werk te doen. De uitsmijter staat direct aan de rand van het controlesysteem van de robot.

Als de beweging veilig is: Zegt de uitsmijter "Ga door" en de robot schenkt de vloeistof in.
Als de beweging onveilig is: Slaat de uitsmijter de remmen in, past de beweging aan of blokkeert de beweging volledig.
Cruciaal is dat dit onmiddellijk gebeurt, zonder dat de robot hoeft te stoppen om na te denken of om hulp van een mens te vragen.

3. Hoe goed werkt het?

De onderzoekers hebben dit systeem getest in een virtuele laboratoriumsimulatie (een video game-achtige omgeving genaamd LabUtopia).

Het Resultaat: Voordat LabGuard werd gebruikt, maakten de robots ongeveer 39,5% van de tijd onveilige fouten. Na de installatie van de LabGuard "uitsmijter" daalden die fouten naar 23,8%.
Het Beste Eraan: Het veiligheidssysteem is zo slim dat het zelden in de weg zit. Het greep slechts 0,5% van de tijd in (stopte de robot) wanneer de robot eigenlijk iets veiligs aan het doen was. Het vertraagde de robot niet en verpestte zijn vermogen om de taak te voltooien niet.

Samenvattende Analogie

Beschouw LabGuard als een slimme gordel en airbag-systeem voor een robot.

De gordel (het vertaalingssysteem) neemt de complexe veiligheidswetten uit het handboek en zet ze om in een simpele "klik" die de auto (de robot) begrijpt.
De airbag (de runtime monitor) staat klaar om direct uit te klappen als er een botsing dreigt te gebeuren, waardoor de robot wordt tegengehouden om iets gevaarlijks te doen.
Het resultaat is een robot die complex werk kan doen, maar gegarandeerd binnen de "veilige rijstrook" blijft die door menselijke regels is gedefinieerd.

Belangrijke Opmerking: Het artikel vermeldt expliciet dat al deze tests zijn uitgevoerd in een computersimulatie. Het systeem is nog niet getest op echte fysieke robots met echte chemicaliën, dus hoewel het perfect werkt in de "videogame", zou implementatie in de echte wereld verdere tests vereisen.

Technische Samenvatting: LabGuard

Probleemstelling

Hoewel belichaamde agenten steeds beter in staat zijn om complexe laboratoriumprocedures uit te voeren met behulp van Vision-Language-Action (VLA) modellen en imitation learning, blijft het waarborgen van veiligheid in dynamische laboratoriumomgevingen een grote uitdaging. Huidig veiligheidsonderzoek gaat er vaak van uit dat veiligheidsinformatie al geformaliseerd is. Echter, in echte laboratoria bestaat veiligheidskennis voornamelijk als ongestructureerde natuurlijke taal (bijv. Standard Operating Procedures, handleidingen, protocollen en regels voor chemische behandeling).

Het kernprobleem dat dit artikel aanpakt, is de "missing link" tussen deze natuurlijke taal-veiligheidsregels en de door machines controleerbare runtime-beperkingen die vereist zijn voor robotcontrollers. Bestaande benaderingen negeren vaak de tussenstap van het transformeren van tekstuele veiligheidsregels naar uitvoerbare specificaties die actief kunnen worden gemonitord en afgedwongen bij de controller-grens tijdens de uitvoering. De auteurs identificeren drie belangrijke uitdagingen:

Representatie: Hoe representeer je laboratoriumveiligheidstaal zodat controllers regels kunnen activeren en controleren.
Gronding (Grounding): Hoe breng je diverse bronnen in natuurlijke taal (SOP's, handleidingen, etc.) over naar een getypeerde, uitvoerbare representatie.
Compilatie: Hoe compileer je deze gegronde representaties naar runtime-monitors die live staten kunnen controleren en kunnen ingrijpen (doorgeven, wijzigen of blokkeren) bij acties vóór de uitvoering.

Methodologie: De LabGuard Suite

De auteurs stellen LabGuard voor, een taal-naar-executie veiligheidssuite ontworpen om laboratoriumregels in natuurlijke taal te gronden in uitvoerbare runtime-guards. Het systeem werkt via een driestaps-pipeline:

1. LabGuard-IR (Intermediate Representation)

De auteurs definiëren LabGuard-IR, een getypeerde uitvoerbare representatie die dient als doel voor gronding en de input voor compilatie. In tegen tegenstelling tot eenvoudige tekstuele beschrijvingen, legt LabGuard-IR de executie-semantiek vast die nodig is voor controle aan de controller-zijde. Het bestaat uit zes velden:

$\hat{t}$ (Constraint Type): Selecteert de veiligheidslogica (bijv. chemische incompatibiliteit, temperatuurlimieten, sequentiecontrole).
$\hat{S}$ (Substance/Entity Set): Koppelt tekstuele vermeldingen aan concrete, traceerbare laboratoriumentiteiten.
$\hat{p}$ (State Predicate): Definieert de conditie die wordt geëvalueerd tegen de live staat of de voorgestelde actie.
$\hat{T}$ (Action Scope): Activeert de regel alleen voor relevante controller-acties.
$\hat{v}$ (Severity): Bepaalt de prioriteit van de overtreding.
$\hat{i}$ (Intervention Mode): Specificeert de respons (bijv. loggen, wijzigen, blokkeren).

2. LabGuard-Bench (Supervised Benchmark)

Om het grondingsproces te trainen en te evalueren, hebben de auteurs LabGuard-Bench geconstrueerd.

Data: Het bevat 812 gesuperviseerde annotaties, uitgebreid vanuit 203 zaad-laboratoriumregels.
Bronnen: De zaden zijn afkomstig van vier verschillende families: veiligheidshandboeken voor laboratoria, PubChem GHS-verklaringen, door experts geschreven controller-gerichte regels en chemische veiligheidsreferenties.
Annotatie: Vijf annotatoren met een achtergrond in chemie/robotica hebben de data beoordeeld, waarbij de semantische equivalentie tussen parafrases en canonieke regels werd gewaarborgd. De dataset beslaat 15 beperkingstypen gegroepeerd in vier families (materiaalcompatibiliteit, fysieke/kwantitatieve behandeling, proces/apparatuurcontroles, en omgeving/PBM/afval).

3. LabGuard-Grounder en Pipeline

LabGuard-Grounder: Een trainbaar component (geïmplementeerd als een LoRA fine-tuned taalmodel) dat natuurlijke taalregels naar het LabGuard-IR schema mapt. Het is getraind via supervised sequence generation om de gestructureerde velden te herstellen die vereist zijn voor downstream compilatie.
LabGuard Pipeline:
- Compile-Time: De gegronde IR-instantie wordt gevalideerd tegen het schema en gecompileerd naar een uitvoerbare runtime-monitor ( $\rho$ ). De compiler instantieert check-functies ( $f_{check}$ ), scope-predicaten ( $\phi_{scope}$ ) en parameters ( $\theta$ ) op basis van de IR-velden.
- Runtime: Bij elke controle-stap stelt de basiscontroller een ruwe actie voor. De runtime-executor activeert relevante monitors op basis van de actie-scope. De veiligheidsfilter ($SafeFilter$) evalueert de actie tegen de live laboratoriumstaat (inclusief substantie-identiteiten, volumes, temperaturen en kinematica). Vervolgens geeft het een oordeel: pass, modify, of block.

Belangrijkste Bijdragen

LabGuard-IR: Een getypeerde representatie die laboratoriumveiligheidstaal bruikbaar maakt voor de controller door expliciet beperkingstypes, entiteitsbindingen, actie-scopes en interventiemodi vast te leggen.
LabGuard-Bench & Grounder: Een gesuperviseerde benchmark met 812 annotaties en een bijbehorend grondingsmodel dat diverse regels in natuurlijke taal naar het uitvoerbare IR-schema mapt.
LabGuard Pipeline: Een volledig systeem dat gegronde IR-instanties compileert naar runtime-monitors en deze integreert met belichaamde agenten (specifiek ACT-policies in LabUtopia) om reductie van gevaren en taakbehoud te testen.

Experimentele Resultaten

De auteurs evalueerden LabGuard in drie fasen: gronding, offline replay, en live runtime-executie.

Laboratoriumtaal Gronding: Onder "source-held-out" instellingen (testen van generalisatie naar onbekende regelbronnen) bereikte LabGuard-Hybrid (combinatie van geleerde gronding met regelgebaseerde normalisatie) een 79.4 task-scope F1. In "chemistry-held-out" settings (onbekende chemische categorieën) bereikte het een 91.8 F1.
Gecompileerde-Monitor Replay: In offline stress-tests met 70 onveilige scenario's bereikten de monitors, gecompileerd uit de door LabGuard-Hybrid gegronde regels, een catch rate van 58.6% en een 69.5 F1, wat dicht bij de oracle-grens van de gold labels ligt (77.1% catch, 84.4 F1). De resultaten geven aan dat nauwkeurige task-scope routing en substantie-binding cruciaal zijn voor downstream veiligheid, zelfs als exacte predicaat-herstel uitdagend blijft.
Runtime Executie (LabUtopia): Geïntegreerd met ACT-policies in LabUtopia (Levels 1–4):
- Veiligheid: Onveilige gebeurtenissen werden verminderd van 39.5% naar 23.8% na monitor-compilatie.
- Taaksucces: De veiligheidslaag behield of verbeterde de succespercentages van taken. Bijvoorbeeld, in de "HeatLiquid" taak steeg het succespercentage van 33.3% (Base) naar 46.7% (Full LabGuard).
- Overhead: De interventie-ratio's bleven laag (≤0.5%), wat aangeeft dat het systeem geen spookmatige blokkades introduceert voor veilige acties.
- Ablatie: De "Action Filter" module droeg het meest bij aan de verbetering van het succespercentage, terwijl semantische controles en risicoscoring complementaire voordelen boden.

Betekenis en Claims

Het artikel claimt dat LabGuard een auditbaar pad biedt van menselijk leesbare laboratoriumveiligheidskennis naar uitvoerbare monitors. Door gronding, compilatie en uitvoering te scheiden, overbrugt het systeem de kloof tussen natuurlijke taal en robot-control loops zonder dat de basispolicy opnieuw getraind hoeft te worden.

De auteurs benadrukken dat hun werk de haalbaarheid aantoont van het verbinden van laboratorium-natuurlijke taal aan runtime-monitors in simulatie. Ze stellen expliciet dat de resultaten nog geen veiligheid in een echt laboratorium vaststellen, aangezien fysieke implementatie validatie vereist tegen echte robotdynamiek, sensorgebruis en institutionele procedures. Het werk wordt gepresenteerd als een fundamentele stap richting "representeerbare, leerbare en uitvoerbare" veiligheid voor belichaamde wetenschappelijke agenten.