AI-agenter får händer och fötter: Strands + LeRobot knyter ihop robotiken – naturligt språk styr riktig hårdvara direkt

Vad är den största bristen hos AI-agenter de senaste två åren?

Det är inte att de inte kan chatta eller skriva kod, utan att de för det mesta fortfarande är instängda i skärmen. Be dem planera, söka, skriva skript och anropa API:er – det är de starka på; men be dem faktiskt föra en robotarm framåt, spela in en robotdemonstration, köra en simuleringsrunda och sedan driftsätta policyn på riktig hårdvara – så krockar de genast med en hög teknisk limkod.

Nu håller det luckan på att täppas till.

Inom AWS-ekosystemet har Strands Robots SDK släppts som öppen källkod, och paketerar Hugging Face LeRobot, MuJoCo-simulering, policyinferens, Zenoh-flerrobotmesh med mera som Strands AgentTools. Den officiella formuleringen är träffande rak: strands-robots gives a Strands Agent hands.

Översatt till vardagsspråk: AI-agenter har börjat få händer och fötter.

Vad släpptes egentligen den här gången?

Projektet heter strands-robots, koden ligger i strands-labs/robots och PyPI-paketet heter också strands-robots. Kärnfunktionen är en Robot()-fabrik som gör simulerade eller verkliga robotar till verktyg som en Strands Agent kan anropa.

Det minimala exemplet är mycket talande:

from strands import Agent
from strands_robots import Robot

robot = Robot(“so100”)
agent = Agent(tools=[robot])
agent(“Pick up the red cube”)

Som standard startar Robot(“so100”) MuJoCo-simulering – varken GPU eller riktig hårdvara krävs. För att växla till den fysiska roboten måste du uttryckligen ange mode=”real”:

robot = Robot(“so100″, mode=”real”, port=”/dev/ttyACM0″)

Standardvalet är helt centralt: först simulering, sedan riktig maskin. En enda naturligt språklig instruktion ska inte kunna driva på riktiga servon av misstag.

Vad är LeRobot: robotvärldens Hugging Face-verktygskedja

För att förstå Strands Robots måste man först förstå LeRobot.

LeRobot är Hugging Faces bibliotek för robotinlärning i verkliga världen, med målet att samla robotområdets modeller, datamängder och verktyg i PyTorch-ekosystemet och sänka tröskeln för robotik.

Den officiella inriktningen är tydlig:

• Tillhandahåller modeller, datamängder och verktyg för robotik i verkliga världen
• Låter fler människor dela robotdatamängder och förtränade modeller
• Täcker imitationsinlärning, förstärkningsinlärning och VLA-modeller
• Stödjer både riktig hårdvara och simuleringsmiljöer

En av de allra viktigaste bitarna i LeRobot är formatet LeRobotDataset. Det organiserar robotens video, tillstånds- och åtgärdsdata i en standardiserad struktur, vanligen MP4 eller bilder plus Parquet. Då kan datan laddas upp till Hugging Face Hub och återanvändas i hela kedjan av träning, utvärdering och driftsättning.

Med andra ord: LeRobot ger robotinlärningen dess ”bas av data och modeller”.

Men en bas är inte ett komplett arbetsflöde. I praktiken måste man också hantera simulering, hårdvaruportar, kameror, kalibrering, policyinferens, samordning av flera robotar och säkra avbrott. Det är precis detta lager som Strands Robots fyller.

Strands Robots ersätter inte – det paketerar

Många som ser Strands + LeRobot reagerar nog först: är det ännu ett nytt robotramverk?

Nej.

Det är snarare ett verktygslager som paketerar robotkedjan till något en agent kan anropa. LeRobot fortsätter att ansvara för en stor del av robotdata, policys och hårdvarugränssnitt; MuJoCo fortsätter att sköta simuleringen; GR00T, ACT, Pi0, SmolVLA, Diffusion med flera förblir policyleverantörer; och Zenoh sköter peer-to-peer-meshen.

Värdet hos Strands Robots är att pressa dessa tidigare utspridda komponenter in i ett agentarbetsflöde:

• Spela in demonstrationsdata
• Skriva till LeRobotDataset
• Ladda upp eller återanvända data från Hugging Face Hub
• Köra simulering i MuJoCo
• Anropa lokala eller fjärrpolicys
• Driftsätta på riktiga robotar
• Låta flera robotar samordnas via mesh
• Vid behov sända E-STOP-nödstopp i broadcast

Förr krävdes en massa limkod för dessa steg. Nu kan de bli AgentTools som samma Strands Agent disponerar.

Kedjan i en mening: från naturligt språk till mekanisk rörelse

Den officiella kedjan är mycket intuitiv:

Naturligt språk → Strands Agent → Robot-verktyg → Policy Provider → Action Chunk → MuJoCo-simulering eller riktig hårdvara → observationer strömmar tillbaka

Poängen med kedjan är att agenten inte direkt styr motorerna: den låter policy providern generera action chunks som sedan överlämnas till simulering eller hårdvara för utförande.

Bland de stödda policyleverantörerna finns:

• NVIDIA GR00T
• LeRobot ACT
• Pi0 / Pi0.5
• SmolVLA
• Diffusion Policy
• Klassisk motion planner
• MPC
• scripted controller
• mock policy

Det betyder att Strands Robots inte satsar på en enda modell, utan placerar olika policys bakom samma abstrakta gränssnitt. Idag kan du validera flödet med en mock policy, imorgon byta till en lokal LeRobot-modell och i övermorgon koppla upp GR00T-inferens.

50+ robotar i 8 kategorier

Strands Robots listar officiellt 50+ robotar i 8 kategorier:

• Robotarmar: SO100, SO101, Koch, OMX, Panda, UR5e, xArm7 med flera
• Humanoider: Unitree G1, Unitree H1, Reachy2, Talos, Cassie med flera
• Mobila robotar: Spot, Unitree Go2, Stretch, LeKiwi, EarthRover med flera
• Dexterahänder: Shadow Hand, Allegro Hand, Leap Hand, Robotiq 2F85 med flera
• Dubbelarmssystem: ALOHA, bi_openarm, Trossen WXAI
• Flygande: Crazyflie, Skydio X2
• Uttrycks-/interaktionsrobotar: Reachy Mini
• Mobila manipulatorer: Google Robot

En del av robotarna kan driva riktig hårdvara via LeRobot, exempelvis SO100, SO101, Koch, OMX, HopeJR, ALOHA, bi_openarm, Reachy2, Unitree G1, LeKiwi och EarthRover.

Viktigare är att alla robotar kan simuleras. För utvecklare betyder det att flödet kan köras igenom i billig simulering först, och att beslutet om hårdvaruköp kan vänta.

Mesh-samordning av flera robotar + nödstopp

Flerrobotik och säkerhetsstyrning är oundvikliga frågor när man kopplar en agent till den fysiska världen.

Strands Robots har inbyggt Zenoh-mesh-nätverk. Varje robot blir automatiskt en peer och kan prata med en annan robot via tell(), sända kommandon via broadcast() och stoppa allt med E-STOP.

Meshen kan bryggas till AWS IoT Core, och med device-connect-pluginen går det att bygga mer avancerade enhetsmedvetna nätverk.

Säkerhetsdesignen är också tydlig:

• Simulering som standard, och lägesbyte måste deklareras explicit med mode=”real”
• Tre separata verktygsåtgärder: läsa status, utföra, stoppa
• E-STOP ligger utanför den normala styrkedjan
• Mänskligt godkännande avbryter före riktiga åtgärder

I industrimiljö är detta inte valfria inställningar. Saknas en enda kan olyckor hända.

Terminologi: vem ligger bakom det här?

Denna integrationslösning har släppts som öppen källkod av AWS (Apache 2.0) och presenterats på hugggingface.co:s blogg. Strands i sig är AWS:s öppna Agent SDK (Apache 2.0) med stöd för Python och TypeScript och ett komplett agentramverk. LeRobot är ett Hugging Face-projekt. Deras gemensamma punkt är strands-robots.

Hur kommer man igång?

För att bara testa simuleringen rekommenderas MuJoCo-extra:

uv pip install “strands-robots[sim-mujoco]”

Ska riktig hårdvara och lokala LeRobot-policys användas:

uv pip install “strands-robots[sim-mujoco,lerobot]”

Vill man installera allt:

uv pip install “strands-robots[all]”

Basinstallationen är lätt och innehåller bara numpy, opencv-headless, Pillow med flera. Övriga funktioner installeras via separata extras: sim-mujoco för simulering, lerobot för riktig hårdvara och lokala policys, groot-service för NVIDIA GR00T-inferens, mesh för Zenoh-flerrobotnätverk och mesh-iot för AWS IoT Core-flottor.

Uppdelningen är pragmatisk – du drunknar inte i alla beroenden direkt.

Missförstå mig rätt: det här är inte ”embodied intelligence i ett klick”

Här måste en skopa kallt vatten hällas på.

Strands Robots är häftigt, men det gör inte AI:n till robotexpert med ett klick.

Riktig hårdvara ställer fortfarande krav på:

• Portidentifiering
• Servokommunikation
• Kamerakonfiguration
• Kalibrering av robotarmen
• Anpassning av datascheman
• Tillgängliga checkpoints
• GPU / Docker / inferenstjänst
• Klyftan mellan simulering och verklighet (sim2real)
• Säkerhetsgränser vid flerrobotik

GR00T-lokal inferens kan exempelvis kräva NVIDIA GPU, Docker, checkpoints och rätt datakonfiguration. En fysisk SO-101 börjar inte plocka röda kuber bara för att du skrivit mode=”real” – kameror, kalibrering, policy och en säker miljö behövs fortfarande.

Det verkliga värdet: mindre limkod

Det mest uppmärksammansvärda den här gången är inte att modellkapaciteten plötsligt skjutit i höjden, utan att den tekniska kedjan knutits ihop.

Det verkligt smärta i robotutveckling är sällan forskningsartiklarna utan att olika system inte pratar med varandra:

• Ett format för datamängder
• En uppsättning simuleringsskript
• En lösning för styrning av riktig hårdvara
• En pipeline för policyinferens
• En kanal för flerrobotkommunikation
• Och ytterligare en lösning för säker stopp

Strands Robots samlar ihop dem till AgentTools.

Det är mycket konkret för både forskargrupper och startups. Du kan börja med att köra SO100-simulering på din laptop – utan att köpa hårdvara, utan GPU och utan Hub-behörighet – och när flödet bekräftats successivt introducera riktig SO101, GR00T, Hugging Face-checkpoints och flerrobotmesh.

Budget och risk kan frigöras i etapper i stället för att hårdvara, data, träning och driftsättning alltihop tryckas på dag ett.

Varför det spelar roll för agenter

Tidigare har agenternas verktyg mest varit digitala: filer, webbläsare, databaser, API:er, terminaler, kodtolkare.

Strands Robots pressar verktygsgränsen ut i den fysiska världen: robotar, kameror, servon, simuleringsmiljöer, åtgärdspolicys, flerrobotkommunikation.

Det betyder att agentens räckvidd börjar expandera från ”informationshantering” till ”fysiskt utförande”.

Naturligtvis krävs större försiktighet med fysiskt utförande. Den verkliga världen har ingen ångraknapp – en robotarm som slår i bordet, krossar ett föremål eller träffar en människa löses inte genom att köra skriptet igen. Just därför är standardsimulering, explicit verkligt läge, E-STOP och godkännandeavbrott tecken på projektets mognad.

Relationen till ROS

Vissa frågar: ersätter det här ROS?

Kort sikt: nej. ROS är robotikens klassiska systembyggsbas – dess ekosystem av noder, topics, services, launch och drivrutiner är djupt. Strands Robots är snarare ett agentorkestreringslager med fokus på att ”låta stora modeller organisera robotuppgifter via verktygsgränssnitt”.

Framtida scenariot är förmodligen: underliggande hårdvara och komplexa robotsystem fortsatt med ROS, tillverkar-SDK:er och styrningar, medan agentlagret via verktyg som Strands Robots knyter ihop uppgiftsplanering, policyanrop, datainsamling, simuleringsverifiering och flerrobotsamordning.

Med andra ord: den försöker inte ta chassiset, utan ta ingången till det övre arbetsflödet.

Sammanfattning

Den verkliga betydelsen av att Strands + LeRobot knyter ihop robotkedjan är inte att en mening gör robotarmen genast smartare, utan att AI-agenter börjar få ett standardiserat verktygsgränssnitt mot den fysiska världen.

LeRobot levererar robotikens data, modeller och hårdvarugränssnitt; MuJoCo ger säker simulering; GR00T, ACT, Pi0, SmolVLA, Diffusion med flera levererar policys; Zenoh-mesh sköter flerrobotkommunikationen; och Strands Robots paketerar alltihop som AgentTools.

Det är dess värde: ingen revolution i ett klick, men en hel hög limkod mindre att skriva.

Tidigare växte AI-agenter bara hjärna och mun. Nu börjar de få händer och fötter.

Men innan de verkligen kliver in i den fysiska världen behövs fortfarande bromsar, räcken, godkännanden, simulering och massor av tekniska detaljer.

Det är det mest genuina steget hittills för embodied intelligence från presentationsbild till experimentbänk.