💻 computer science

Nautilus: From One Prompt to Plug-and-Play Robot Learning

Het artikel introduceert NAUTILUS, een open-source harness dat enkele prompts omzet in geautomatiseerde, gevalideerde robotleerwerkstromen door plug-and-play agentvaardigheden, uniforme interfaces en schaalbare kameruitvoering te bieden om de engineeringfragmentatie te elimineren die momenteel de reproductie en evaluatie van beleidsplannen over verschillende families hindert.

Oorspronkelijke auteurs: Yufeng Jin, Jianfei Guo, Xiaogang Jia, Yu Deng, Zechu Li, Han Liu, Weiran Liao, Vignesh Prasad, Mathias Franzius, Gerhard Neumann, Georgia Chalvatzaki

Gepubliceerd 2026-05-13

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yufeng Jin, Jianfei Guo, Xiaogang Jia, Yu Deng, Zechu Li, Han Liu, Weiran Liao, Vignesh Prasad, Mathias Franzius, Gerhard Neumann, Georgia Chalvatzaki

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 de wereld van robotleren voor als een enorme, chaotische bouwplaats. Aan de ene kant heb je architecten die nieuwe robothersenen (zogenaamde "policies") ontwerpen. Aan de andere kant heb je testbanen (benchmarks) waar robots leren lopen of voorwerpen oppakken. Aan een derde kant heb je de roboten zelf, variërend van eenvoudige armen tot mensachtige wandelaars.

Het probleem, volgens dit paper, is dat het verbinden van één architect met één testbaan en één robot een nachtmerrie is. Telkens als een onderzoeker een nieuw hersenmodel wil testen op een nieuwe baan met een nieuwe robot, moeten ze een op maat gemaakte brug van scratch bouwen. Ze moeten "lijmcode" schrijven om de talen op elkaar af te stemmen, conflicterende softwareversies oplossen en ervoor zorgen dat de robot niet crasht. Het is alsof je probeert een broodrooster in een motoren van een auto te steken, een broodrooster in een ruimteschip en een broodrooster in een boot – elke keer moet je een nieuwe adapter uitvinden.

Nautilus komt in beeld.

De auteurs stellen Nautilus voor als een universele "plug-and-play"-harnas. Denk er als een slimme, magische adapterstation voor de hele robotleerindustrie.

Zo werkt het, met eenvoudige analogieën:

1. De "Universele Stroomstrip" (Getypeerde Contracten)

Momenteel spreekt elke robot en elk hersenmodel een andere taal. Nautilus introduceert een gestandaardiseerde stroomstrip.

De Analogie: Stel je voor dat elk apparaat in je huis (broodrooster, lamp, tv) opnieuw bedraad moest worden om in het stopcontact te passen. Nautilus zegt: "Geen opnieuw bedraden meer." Het dwingt elke robothersen en elke testbaan om overeen te komen over één enkele, strikte vorm voor hun stekkers (zogenaamde "getypeerde contracten").
Het Resultaat: Zodra een robothersen in deze standaard is gestoken, kan het direct verbinding maken met elke testbaan of robot zonder een aangepaste adapter nodig te hebben.

2. De "Geluidsdichte Cabines" (Gekamerde Executie)

Robotsoftware is rommelig. De ene robot heeft een specifieke versie van een videospel-engine nodig, terwijl de andere een andere versie van een fysische simulator nodig heeft. Als je ze op dezelfde computer draait, vechten ze en crasht het.

De Analogie: Nautilus bouwt geluidsdichte cabines (containers) voor elk onderdeel van het experiment. De robothersen leeft in één cabine, de testbaan in een andere en de robot zelf in een derde. Ze kunnen via een veilig raam met elkaar praten, maar hun rommelige interne tools botsen nooit.
Het Resultaat: Je kunt elke combinatie door elkaar gebruiken zonder je zorgen te maken over softwareconflicten.

3. De "Slimme Projectmanager" (De Agent)

Het paper gebruikt een Large Language Model (een AI-coder) voor het zware werk. Maar meestal falen AI-coders in de robotica omdat ze de "ongeschreven regels" van het vakgebied niet kennen.

De Analogie: Nautilus geeft de AI-coder een reglement en een checklist (zogenaamde Guides en Sensors).
- Guides: Voordat de AI code schrijft, vertelt het reglement haar: "Hé, robots moeten worden gereset voordat ze starten, en je moet controleren of de batterij veilig is."
- Sensors: Nadat de AI code heeft geschreven, controleert een veiligheidsinspecteur het. "Heb je echt getest of de robot beweegt? Heb je het dataformaat gecontroleerd?" Als het antwoord nee is, moet de AI het oplossen voordat ze doorgaat.
Het Resultaat: De AI raadt niet zomaar; ze volgt een bewezen, veilig workflow die onderzoekers elke dag gebruiken.

4. De "Nautilus-schelp" (Schaalbaarheid)

De naam komt van de nautilus-schelp, die groeit door nieuwe kamers toe te voegen.

De Analogie: In plaats van een gigantisch, stijf raamwerk te bouwen dat breekt wanneer je een nieuwe robot toevoegt, groeit Nautilus door nieuwe kamers toe te voegen. Als een onderzoeker een nieuwe robot toevoegt (zoals een nieuw type hand), voegt hij gewoon één nieuwe "kamer" toe aan het systeem. De rest van het systeem hoeft niet opnieuw te worden gebouwd.
Het Resultaat: Het systeem wordt groter en nuttiger zonder dat het ingewikkelder wordt.

Wat hebben ze eigenlijk bewezen?

Het paper beweert niet dat Nautilus een nieuw robothersen heeft uitgevonden of dat het robots slimmer heeft gemaakt dan ze daarvoor waren. In plaats daarvan hebben ze bewezen:

Het werkt als vertaler: Ze hebben bestaande robothersenen genomen en getest op bestaande benchmarks met behulp van Nautilus, en de resultaten kwamen overeen met wat de oorspronkelijke auteurs beweerden.
Het bespaart tijd: Ze hebben aangetoond dat het gebruik van Nautilus om een nieuw robothersen te verbinden met een nieuwe testbaan veel sneller en goedkoper is dan het handmatig doen. Het reduceert het werk van het bouwen van een brug voor elk paar tot het bouwen van slechts één brug voor het hele systeem.
Het werkt op echte robots: Ze hebben succesvol een robothersen dat in een simulatie was getraind, ingepakt in Nautilus, en ingezet op twee zeer verschillende echte robots (een Franka-robotarm en een Unitree H1-humanoid robot) zonder de code van het hersenmodel te wijzigen.

Kortom: Nautilus is geen nieuw robothersen; het is de universele vertaler en veiligheidsinspecteur die verschillende robothersenen, testbanen en robots eindelijk met elkaar laat praten zonder dat er elke keer een team van ingenieurs nodig is om een op maat gemaakte brug te bouwen.

Technische Samenvatting: Nautilus: Van één prompt naar plug-and-play robotleren

1. Probleemstelling

Onderzoek naar robotleren is momenteel gefragmenteerd over drie grotendeels onafhankelijke assen: policy-families ( $P$ , bijv. IL, RL, VLA, WAM), benchmark suites ( $B$ , bijv. LIBERO, ManiSkill) en robot-embodiments ( $R$ , bijv. Franka, Unitree H1). Het integreren van een specifieke triplet $(P, B, R)$ vereist doorgaans een aparte, handgeschreven integratielaag die Docker-configuratie, observatie-adapters en procedures voor vertrouwensvalidatie omvat.

Deze fragmentatie creëert een "harness-gat". Hoewel Large Language Models (LLM's) vooruitgang hebben geboekt in codegeneratie, slagen ze er vaak niet in om eind-tot-eind gereproduceerde resultaten te produceren in de robotica, omdat ze de procedurale priors en validatiepraktijken missen die specifiek zijn voor onderzoekswerkstromen in de robotica. De technische last schaalt als $\Theta(N \cdot M \cdot K)$ , waarbij $N, M, K$ de kardinaliteiten zijn van policies, benchmarks en robots. Bestaande frameworks (bijv. LeRobot, Isaac Lab) zijn vaak gekoppeld aan vaste componenten, terwijl algemene codeeragenten de domeinspecifieke steigers missen die nodig zijn om complexe afhankelijkheidsconflicten en interface-mismatches te navigeren.

2. Methodologie: De NAUTILUS Harness

De auteurs stellen NAUTILUS voor, een open-source, agentgerichte harness ontworpen om een enkele natuurlijke taal-prompt (bijv. "Evalueer policy A met benchmark B") om te zetten in werkstromen voor direct bruikbare reproductie, evaluatie, fijne afstelling en implementatie. NAUTILUS is gestructureerd in twee lagen: een substraat en een contentlaag.

2.1 Het Substraat (Technische Invarianten)

Het substraat biedt een stabiel oppervlak waarover de agent kan redeneren, waardoor de integratiecomplexiteit wordt gereduceerd van $\Theta(N \cdot M \cdot K)$ naar $\Theta(N + M + K)$ . Het rust op drie invarianten:

Getypeerde Interfacecontracten: Policies, benchmarks en robots worden blootgelegd via vaste, machineleesbare schema's (bijv. infer(obs) -> acties, reset(seed), apply_action). Deze contracten verbergen implementatiespecifieke mechanismen (bijv. CUDA-stacks, ROS 2-drivers) en definiëren de eenheid van integratie.
Gekamerde Executie: Gegenereerde artefacten draaien in wegwerpbare, geïsoleerde containers. Dit voorkomt dat afhankelijkheidsfouten (bijv. conflicterende CUDA-versies) lekken naar andere modules. Een policy-container, een benchmark-container en een hardware-container nemen vanuit het perspectief van de agent dezelfde architecturale sleutel in.
Uniforme Inter-module Communicatie:
- Niveau 1 (Lokaal voor de robot): Hoge-bandbreedte sensoren en besturing blijven in de native robotstack (bijv. ROS 2, gedeeld geheugen).
- Niveau 2 (Buiten de robot): De agent ziet alleen een lichtgewicht WebSocket-protocol dat de policy-container verbindt met de benchmark of het real-robot-eindpunt. Dit zorgt ervoor dat gesimuleerde en real-robot-eindpunten een enkel observatie/actie-schema delen.

2.2 De Contentlaag (Gidsen, Sensoren, Status)

Gebouwd bovenop het substraat, distilleert deze laag onderzoekswerkstromen in de robotica naar expliciete, herbruikbare componenten:

Gidsen: Voor-generatie instructies die het gedrag van de agent sturen, door routingregels, rollen voor subagenten en validatieprotocollen te bieden voordat code wordt geschreven.
Sensoren: Na-generatie validators die artefacten controleren aan de hand van zes criteria (bijv. filtering voor actie, interfaceverificatie, specificatievergelijking, rooktesten). Sensoren kunnen lokale correcties triggeren of runs blokkeren als contracten worden geschonden.
Status: Een persistente, JSON-schema-gevalideerde register die getypeerde contracten en vastgezette artefacten (broncommits, Docker-afbeeldingen) opslaat. Dit stelt de agent in staat om kennis van geverifieerde modules te hergebruiken in plaats van repository-indelingen vanaf nul opnieuw te ontdekken.
Workspace-artefacten: Alleen-voor-toevoeging logs en reproductiebewijzen die de broncommit, omgevingskeuzes en beslissingen voor elke run vastleggen.

2.3 Uitvoeringsflow

Wanneer een gebruiker een prompt indient (bijv. "Voer $\pi_0$ uit op LIBERO"), routeert de orkestrator het verzoek naar een specifieke subagent-werkstroom. Het systeem controleert de Status-register op geverifieerde invoer. Als deze ontbreekt, genereert het parallel policy- en benchmarkmodules, vergelijkt het hun getypeerde specificaties (bijv. observatiesleutels, actievormen), voert het een WebSocket-rooktest uit en schrijft het reproductiebewijzen.

3. Belangrijkste Bijdragen

Modulair Substraat: Een systeem gebaseerd op getypeerde contracten, gekamerde uitvoering en uniform transport dat de integratiekosten van robotleren over families heen reduceert.
Gedistilleerde Procedurale Priors: De omzetting van impliciete kennis over robotica-werkstromen in expliciete Gidsen en Sensoren, waardoor de "black box"-generatie van de agent wordt omgezet in een gevalideerd, stap-voor-stap proces.
Open-source Platform: De release van NAUTILUS met gestructureerde werkstromen die vier policy-families (IL, VLA, RL, WAM), zes benchmark suites en vier classes van embodiments ondersteunen. Het bevat nautilus-collect, een dataverzamelplatform dat hetzelfde Robot-contract valideert over heterogene hardware (Franka en Unitree H1).
Uitbreidbaar Register: Een communityplatform waar nieuwe policies, benchmarks of robots kunnen worden on-boarded via 3–5 getypeerde methodcontracten zonder frameworkcode te wijzigen, mits ze de vertrouwensvalidatieprotocollen doorstaan.

4. Experimentele Resultaten

Het artikel evalueert NAUTILUS via drie studies:

Validatie van Benchmarkvertrouwen: Het systeem reproduceerde referentieresultaten voor publieke policies (Diffusion Policy, $\pi_0$ , OpenVLA, etc.) over LIBERO, ManiSkill, RoboTwin, ALOHA en RoboCasa. De gegenereerde wrappers reproduceerden de referentiescores trouw met kleine afwijkingen (bijv. $\Delta \approx \pm 2\%$ ), wat bevestigt dat de adapters de beoogde evaluatieprotocollen behouden.
Ablatie op Uitbreidbaarheid: In een "leave-one-benchmark-out"-testomgeving werd NAUTILUS vergeleken met een standaard codeeragent.
- Succes: NAUTILUS bereikte 100% wrap-succes en een hoog taaksucces (98,7% op Claude Opus 4.7).
- Kostenefficiëntie: Het verwijderen van de getypeerde template (het substraat) veroorzaakte dat het wrap-succes daalde naar 55,3% en het tokengebruik verdrievoudigde (41,7 miljoen tokens), wat aantoont dat het substraat voorkomt dat de agent glue-code opnieuw moet leren.
- Modelschaling: De harness bood grotere relatieve voordelen bij zwakkere modellen (Claude Sonnet 4.6), waarbij het aantal interactierondes met ongeveer 27% en de kosten met ongeveer 8% werden gereduceerd ten opzichte van de standaard agent.
Implementatie op Real-robots: Het systeem slaagde erin een VLA-manipulatiecheckpoint ( $\pi_0.5$ ) te implementeren op een Franka-arm en een RL-locomotiepolicy op een Unitree H1. In beide gevallen werd hetzelfde policy-artefact dat voor simulatie was gewikkeld, overgebracht naar hardware door alleen de hardware-container te wisselen, zonder wijzigingen in de policy-code of de container aan de platformkant.

5. Betekenis en Claims

Het artikel betoogt dat de primaire beperking op agentieke automatisering in robotleren niet de capaciteit van het LLM-model is, maar de harness-engineering die eromheen staat. NAUTILUS demonstreert dat door een stabiel, contractgebaseerd substraat met expliciete validatie te bieden, de technische last van reproductie en evaluatie over families heen drastisch kan worden gereduceerd.

De auteurs claimen dat NAUTILUS gefragmenteerde onderzoekswerkstromen transformeert in gestructureerde, agentieke procedures. Door domeinexpertise (contracten, validatieprotocollen, statusbeheer) uitvoerbaar, herbruikbaar en inspecteerbaar te maken, stelt het systeem onderzoekers in staat hun werkstromen te schalen zonder handmatig glue-code te cureren voor elke nieuwe $(P, B, R)$ -combinatie. Het werk positioneert NAUTILUS niet alleen als een hulpmiddel voor automatisering, maar als een stap naar een toekomst waar door experts gebouwde harnessen modellen in staat stellen domeinexpertise te schalen over het hele ecosysteem van robotleren.