💻 computer science

Embodied.cpp: A Portable Inference Runtime of Embodied AI Models on Heterogeneous Robots

Dit artikel introduceert Embodied.cpp, een draagbare C++ inference-runtime die is ontworpen om de gefragmenteerde implementatie van diverse embodied AI-modellen (zoals VLAs en WAMs) op heterogene edge-robots te verenigen door een modulaire, vijflaagse architectuur te bieden die lage-latentie, multi-rate closed-loop-besturing mogelijk maakt terwijl de geheugenefficiëntie en taaksuccesratio's aanzienlijk worden verbeterd.

Oorspronkelijke auteurs: Ling Xu, Chuyu Han, Borui Li, Hao Wu, Shiqi Jiang, Ting Cao, Chuanyou Li, Sheng Zhong, Shuai Wang

Gepubliceerd 2026-07-03

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ling Xu, Chuyu Han, Borui Li, Hao Wu, Shiqi Jiang, Ting Cao, Chuanyou Li, Sheng Zhong, Shuai Wang

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 briljant, hoogintelligent robotbrein hebt gebouwd. Het kan zien, taal begrijpen en plannen hoe het zijn armen moet bewegen om een beker op te pakken. Maar op dit moment is het werkelijk laten werken van dit brein op een echte robot alsof je een Formule 1-motor probeert te passen in een fietsframe met behulp van ducttape en een Zwitsers zakmes.

Momenteel, elke keer dat een wetenschapper een nieuw robotbrein bouwt, moeten ze een compleet nieuwe set "glue code" (de software die het brein verbindt met de sensoren en motoren van de robot) schrijven. Deze code is vaak slordig, geschreven in Python en werkt alleen op specifieke computers. Als je de robot of het brein verandert, moet je de hele verbinding vanaf nul opnieuw opbouwen.

Maak kennis met "Embodied.cpp".

Beschouw Embodied.cpp als een universele, hoogwaardige adapterkit voor robotbreinen. Het is een stuk software geschreven in C++ (een taal die bekend staat als snel en efficiënt) dat fungeert als een brug tussen elk nieuw robotbrein en elke robotbehuizing, of het nu een kleine robot op een chip is of een enorme werkstationrobot.

Zo werkt het, met behulp van enkele eenvoudige analogieën:

1. Het Probleem: De "One-Size-Fits-None" Adapter

Stel je voor dat je een smart home-systeem hebt. Sommige lampen gaan elke seconde aan, de thermostaat controleert elke minuut de temperatuur en de beveiligingscamera neemt elke uur een opname op.

De Oude Manier: Je bouwt een aparte timer, een aparte sensor en een aparte schakelaar voor elk afzonderlijk apparaat. Als je een nieuw apparaat toevoegt, moet je een heel nieuw circuit bedraden.
Het Probleem van het Papier: Robotbreinen zijn hetzelfde. Sommige onderdelen (zoals de ogen) moeten langzaam worden bijgewerkt, terwijl andere (zoals de motorbesturing) super snel moeten worden bijgewerkt. Bestaande software probeert alles met dezelfde snelheid uit te voeren, wat inefficiënt is en vertragingen veroorzaakt.

2. De Oplossing: Een Modulair "Lego"-Systeem

De auteurs hebben Embodied.cpp ontworpen als een hoogwaardige Lego-set met vijf specifieke lagen:

Input Adapters: Dit zijn universele stekkers. Of de robot nu een camera ziet, een aanraaksensor voelt of een krachtmeter leest, deze laag vertaalt dit naar een taal die het brein begrijpt.
Sequence Builders: Dit organiseert de gegevens, zoals een bibliothecaris die boeken sorteert voordat ze in de kast gaan.
Backbone Execution: Dit is de "machinekamer" waar het eigenlijke denken plaatsvindt.
Head Plugins: Dit zijn de gespecialiseerde gereedschappen. De ene robot heeft misschien een "grijp"-gereedschap nodig, een andere een "loop"-gereedschap. Je klikt de juiste plugin er gewoon in zonder de motor opnieuw te bouwen.
Deployment Adapters: Dit is de uitvoerlaag die met de echte wereld communiceert door commando's naar de motoren van de robot of de simulatiesoftware te sturen.

3. De Drie Superkrachten

Het paper benadrukt drie specifieke manieren waarop dit systeem beter is dan wat er vandaag de dag bestaat:

Multi-Rate Execution (De Orkestdirigent):
In een robot hoeven de "ogen" niet even snel te knipperen als de "vingers". Embodiment.cpp fungeert als een dirigent, waardoor de ogen op een langzaam ritme kunnen draaien en de vingers op een snel ritme, allemaal binnen hetzelfde systeem. Oude software probeert iedereen volgens hetzelfde ritme te laten marcheren, wat energie verspilt en vertraging veroorzaakt.
Latency-First Control (De Formule 1-coureur):
In cloud computing (zoals chatten met een AI) wordt snelheid gemeten aan de hand van hoeveel mensen je tegelijkertijd kunt bedienen. Maar voor een robot wordt snelheid gemeten door hoe snel het reageert op één enkel commando. Als een robot een vallend object moet vangen, kan hij niet wachten op een "batch" aan berekeningen; hij heeft een directe reactie nodig. Embodied.cpp is gebouwd om die fractie van een seconde snelle reactietijd te prioriteren op verschillende soorten hardware (van kleine chips tot grote computers).
Extensible Interfaces (De Universele Afstandsbediening):
Robots geven niet alleen "woorden" of "tokens" uit; ze geven complexe dingen uit zoals "beweeg arm 30 graden", "voorspel waar de bal over 2 seconden zal zijn" of "knijp voorzichtig". Embodied.cpp is gebouwd om deze vreemde, aangepaste outputs te verwerken zonder dat het telkens opnieuw geschreven moet worden.

4. De Resultaten: Werkt het?

De auteurs hebben dit systeem getest met twee verschillende soorten robotbreinen:

De "Vision-Language" Breinen (VLA): Ze testten twee modellen (HY-VLA en pi0.5). Het systeem slaagde erin om een robot aan te sturen om taken te voltooien.
- Resultaat: Eén model slaagde 100% van de tijd, en het andere 91%. Het bewees dat de software complexe breinen op echte hardware kan draaien zonder vast te lopen.
De "World-Action" Breinen (WAM): Dit zijn nieuwere modellen die proberen de toekomst te voorspellen (zoals raden waar een bal naartoe zal rollen). Ze testten een klein deel van dit brein.
- Resultaat: Door dit nieuwe systeem te gebruiken, hebben ze het geheugen dat nodig is om dat deel van het brein te draaien verminderd van 312 MiB naar 88 MiB. Dat is alsof je een zware rugzak verkleint tot een klein buitenzakje, waardoor het veel gemakkelijker te draaien is op kleinere, goedkopere robots.

De Kernboodschap

Embodied.cpp is een draagbare, hogesnelheidsmotor voor robotintelligentie. Het voorkomt dat wetenschappers telkens het wiel opnieuw moeten uitvinden wanneer ze een nieuwe robot bouwen. In plaats van voor elk nieuw project slordige, aangepaste code te schrijven, kunnen ze hun nieuwe robotbrein in dit universele systeem pluggen, en dan werkt het gewoon — snel, efficiënt en op bijna elke hardware.

Technische Samenvatting: Embodied.cpp

Probleemstelling

De praktische inzet van Embodied AI-modellen—variërend van Vision-Language-Action (VLA) modellen tot World-Action Models (WAM's)—wordt momenteel belemmerd door fragmentatie. Bestaande oplossingen vertrouwen op modelspecifieke Python-stacks, backend-aannames en aangepaste "glue code" voor elke robothandeling, wat de implementatie op heterogene edge-apparaten (bijv. Jetson, RK-gebaseerde boards, x86 edge boxes) inefficiënt en niet-portabel maakt.

Bovendien zijn bestaande algemene inference-runtimes (bijv. llama.cpp, vLLM, ONNX Runtime) primair ontworpen voor request-response serving met uniforme token-interfaces en doorvoer-georiënteerde optimalisatie. Ze voldoen niet aan de specifieke "runtime contract" die vereist is voor embodied deployment, welke vraagt om:

Multi-rate uitvoering: Verschillende componenten (perceptie-encoders, backbones, predictieve takken, action heads) moeten op verschillende frequenties opereren binnen een enkele closed-loop control cycle.
Latency-georiënteerde closed-loop controle: Optimalisatie richt zich op stabiele, lage-latency, lage-jitter batch-1 inference op heterogene hardware, in plaats van high-throughput batchverwerking.
Uitbreidbare embodied interfaces: Systemen moeten custom operators, heterogene multimodale inputs (beelden, proprioceptie, kracht/tactiele signalen) en diverse outputs (action chunks, voorspelde toekomsten) ondersteunen die verder gaan dan vaste token I/O.

Methodologie: Embodied.cpp Architectuur

De auteurs presenteren Embodied.cpp, een draagbare C++ inference runtime die is ontworpen om de uitvoering van diverse embodied modellen te verenigen. Het systeem is gebouwd op een architecturale analyse van representatieve VLA- en WAM-modellen, waarbij een gedeeld executiepad is geïdentificeerd waar divergenties beperkt blijven tot een kleine set pluggable heads en predictieve modules.

De runtime organiseert dit gedeelde pad in een vijflaagse architectuur:

Input Adapters: Absorberen online sensorstromen en offline dataset-samples (camera's, IMU, kracht/tactiele signalen) via een getypeerde embodied interface.
Sequence Builders: Construeren inputsequenties voor het model.
Backbone Execution: Voert de kern van de transformer of backbone-logica uit.
Head Plugins: Verwerkt modelspecifieke heads (bijv. action heads, predictieve heads, world models).
Deployment Adapters: Overbrugt runtime-outputs naar simulators (bijv. ManiSkill, Isaac Sim) en real-world robot software-stacks.

Kernontwerpprincipes

Om de geïdentificeerde uitdagingen aan te pakken, houdt Embodied.cpp zich aan drie ontwerpprincipes:

Modulaire Multi-rate Uitvoering: Expliciete executie-units en gedeelde state-pools maken het mogelijk dat componenten op verschillende verversingsfrequenties draaien zonder een enkel synchroon pad af te dwingen.
Latency-georiënteerde Fused Execution: Prioriteert stabiele controleprestaties via graph replay, bufferhergebruik, operator fusie en backend-specifieke dispatch voor efficiënte small-batch inference op heterogene hardware (CPU, GPU, NPU).
Uitbreidbare Operator en I/O Ondersteuning: Biedt getypeerde interfaces en pluggable heads om nieuwe modelfamilies en custom operators te accommoderen zonder de runtime opnieuw te bouwen.

Het systeem bevat een "Embodied AI Kernel Warehouse" met herbruikbare operators en modelspecifieke kernels om evoluerende architecturen te ondersteunen.

Belangrijkste Bijdragen

Architecturale Analyse: Een taxonomie van embodied modellen (VLA en WAM) die een gedeeld executiepad onthult waarbij structurele verschillen gelokaliseerd zijn in pluggable modules, wat een verenigde runtime-aanpak mogelijk maakt.
Draagbare C++ Runtime: Het ontwerp en de implementatie van Embodied.cpp, die het gedeelde executiepad mappen naar de hierboven beschreven vijflaagse architectuur, waarbij backend-abstractie wordt geboden voor heterogene edge-apparaten.
Empirische Evaluatie: Kwantitatieve validatie van de runtime op twee VLA-modellen en een voorlopige WAM-benchmark, waarbij efficiëntiewinst wordt aangetoond terwijl de nauwkeurigheid behouden blijft.

Experimentele Resultaten

De auteurs evalueerden Embodied.cpp op twee VLA-modellen en een WAM-component:

VLA Deployment (HY-VLA en pi0.5):
- HY-VLA: Geïmplementeerd op een RoboTwin taak (place_empty_cup), met een task success rate van 100,0%. Het systeem handelde een grotere backbone (Hunyuan-VL) en complexe inputs (three-view, video-history) af met een geamortiseerde step latency van 735,9 ms.
- pi0.5: Bereikte een task success rate van 91,0% met een lichtere PaliGemma backbone. Het vertoonde een lagere geamortiseerde step latency (56,85 ms) dankzij een langere action chunk strategie.
- Beide modellen draalden succesvol door de C++ runtime, waarbij de taakgedrag behouden bleef terwijl de piek GPU-geheugengebruik werd beheerd (6,5–6,8 GiB).
WAM Benchmark (LingBot-VA):
- Vanwege stabiliteitsbeperkingen op de lokale edge-opstelling, hebben de auteurs een enkele Transformer-block van het LingBot-VA model getest in plaats van een volledige closed-loop WAM run.
- Geheugenefficiëntie: De C++ implementatie met gebruik van Q4_K kwantisatie verminderde het blokgeheugen van 312,2 MiB (Python BF16) naar 88,1 MiB.
- Nauwkeurigheid: De gekwantiseerde C++ block behield een hoge getrouwheid, met een Mean Absolute Error (MAE) < $3,3 \times 10^{-2}$ en een Cosine Similarity > $9,997 \times 10^{-1}$ vergeleken met de Python baseline.
- Latency: Het C++ pad bereikte een vergelijkbare latency (3,171 ms vs. 3,236 ms) voor de enkele block computation.

Betekenis en Claims

Het artikel claimt dat Embodied.cpp de kritieke kloof tussen modelconstructie en betrouwbare robot-zijde deployment overbrugt. Door het gemeenschappelijke executiepad als infrastructuur te behandelen en afwijkende delen als plugins, maakt de runtime het volgende mogelijk:

Draagbaarheid: Deployment over heterogene apparaten, robots en simulators via een enkele backend-abstractie.
Efficiëntie: Significante geheugenreductie (via kwantisatie) en latency-geoptimaliseerde executie geschikt voor closed-loop controle.
Schaalbaarheid: Een stabiele, herbruikbare kern die nieuwe embodied modelvarianten (VLA, WAM en toekomstige architecturen) kan absorberen zonder een volledige softwarestack-rebuild te vereisen.

De auteurs positioneren Embodied.cpp niet als een vervanging voor algemene LLM runtimes, maar als een gespecialiseerde oplossing voor het unieke "runtime contract" van embodied AI, dat prioriteit geeft aan stateful, multi-rate en low-latency controle boven throughput.