💻 computer science

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

El artículo presenta NAUTILUS, un entorno de código abierto que transforma prompts individuales en flujos de trabajo de aprendizaje robótico automatizados y validados, mediante la provisión de habilidades de agente plug-and-play, interfaces unificadas y ejecución escalable en cámaras para eliminar la fragmentación de ingeniería que actualmente obstaculiza la reproducción y evaluación de políticas entre diferentes familias.

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

Publicado 2026-05-13

📖 5 min de lectura🧠 Análisis profundo

CC BY 4.0

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

Artículo original bajo licencia CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta es una explicación generada por IA del artículo a continuación. No ha sido escrita ni avalada por los autores. Para mayor precisión técnica, consulte el artículo original. Leer descargo de responsabilidad completo

Imagina el mundo del aprendizaje robótico como un inmenso y caótico sitio de construcción. En un lado, tienes a arquitectos diseñando nuevos cerebros para robots (llamados "políticas"). En otro lado, tienes pistas de prueba (benchmarks) donde los robots aprenden a caminar o a agarrar objetos. En un tercer lado, tienes a los robots reales mismos, que van desde brazos simples hasta caminantes con forma humana.

El problema, según este artículo, es que conectar a cualquier arquitecto con cualquier pista de prueba y con cualquier robot es una pesadilla. Cada vez que un investigador quiere probar un nuevo cerebro en una nueva pista con un nuevo robot, tiene que construir un puente personalizado desde cero. Tienen que escribir "código de unión" para hacer que los lenguajes coincidan, arreglar versiones de software conflictivas y asegurar que el robot no se estrelle. Es como intentar conectar una tostadora a un motor de coche, una tostadora a una nave espacial y una tostadora a un barco; cada vez, tienes que inventar un nuevo adaptador.

Presentamos Nautilus.

Los autores proponen Nautilus como un arnés universal de "conectar y usar". Imagínalo como una estación adaptadora inteligente y mágica para toda la industria del aprendizaje robótico.

Así es como funciona, usando analogías simples:

1. La "Regleta Universal" (Contratos Tipados)

Actualmente, cada robot y cada cerebro habla un idioma diferente. Nautilus introduce una regleta estandarizada.

La Analogía: Imagina que cada electrodoméstico de tu casa (tostadora, lámpara, televisor) tuviera que ser re cableado para encajar en el enchufe de la pared. Nautilus dice: "Basta de recableado". Obliga a cada cerebro de robot y a cada pista de prueba a acordar una única forma estricta para sus enchufes (llamados "contratos tipados").
El Resultado: Una vez que un cerebro de robot se conecta a este estándar, puede conectarse instantáneamente a cualquier pista de prueba o robot sin necesidad de un adaptador personalizado.

2. Las "Cabinas Aisladas Acústicamente" (Ejecución en Cámaras)

El software de los robots es desordenado. Un robot podría necesitar una versión específica de un motor de videojuegos, mientras que otro necesita una versión diferente de un simulador de física. Si los ejecutas en la misma computadora, pelean y se estrellan.

La Analogía: Nautilus construye cabinas aisladas acústicamente (contenedores) para cada parte del experimento. El cerebro del robot vive en una cabina, la pista de prueba en otra y el robot mismo en una tercera. Pueden hablar entre sí a través de una ventana segura, pero sus herramientas internas desordenadas nunca chocan.
El Resultado: Puedes mezclar y combinar cualquier combinación sin preocuparte por conflictos de software.

3. El "Gerente de Proyecto Inteligente" (El Agente)

El artículo utiliza un Modelo de Lenguaje Grande (un programador de IA) para hacer el trabajo pesado. Pero usualmente, los programadores de IA fallan en robótica porque no conocen las "reglas no escritas" del campo.

La Analogía: Nautilus le da al programador de IA un reglamento y una lista de verificación (llamados Guías y Sensores).
- Guías: Antes de que la IA escriba código, el reglamento le dice: "Oye, los robots necesitan reiniciarse antes de empezar y debes verificar si la batería es segura".
- Sensores: Después de que la IA escribe el código, un inspector de seguridad lo revisa. "¿Realmente probaste si el robot se mueve? ¿Verificaste el formato de los datos?". Si la respuesta es no, la IA debe arreglarlo antes de continuar.
El Resultado: La IA no solo adivina; sigue un flujo de trabajo probado y seguro que los investigadores utilizan todos los días.

4. La "Concha de Nautilus" (Escalabilidad)

El nombre proviene de la concha de un nautilo, que crece añadiendo nuevas cámaras.

La Analogía: En lugar de construir un marco gigante y rígido que se rompe cuando añades un nuevo robot, Nautilus crece añadiendo nuevas cámaras. Si un investigador añade un nuevo robot (como un nuevo tipo de mano), solo añade una nueva "cámara" al sistema. El resto del sistema no necesita ser reconstruido.
El Resultado: El sistema se vuelve más grande y útil sin volverse más complicado.

¿Qué demostraron realmente?

El artículo no afirma que Nautilus haya inventado un nuevo cerebro de robot o que haya hecho a los robots más inteligentes de lo que eran antes. En cambio, demostraron:

Funciona como traductor: Tomaron cerebros de robots existentes y los probaron en benchmarks existentes usando Nautilus, y los resultados coincidieron con lo que los autores originales afirmaron.
Ahorra tiempo: Mostraron que usar Nautilus para conectar un nuevo cerebro de robot a una nueva pista de prueba es mucho más rápido y barato que hacerlo manualmente. Reduce el trabajo de construir un puente para cada par individual a solo construir un puente para todo el sistema.
Funciona en robots reales: Tomaron con éxito un cerebro de robot entrenado en una simulación, lo envolvieron en Nautilus y lo desplegaron en dos robots reales muy diferentes (un brazo robótico Franka y un robot humanoide Unitree H1) sin cambiar el código del cerebro.

En resumen: Nautilus no es un nuevo cerebro de robot; es el traductor universal e inspector de seguridad que permite que diferentes cerebros de robots, pistas de prueba y robots finalmente hablen entre sí sin necesidad de un equipo de ingenieros para construir un puente personalizado cada vez.

Resumen Técnico: Nautilus: De un Prompt al Aprendizaje de Robots Plug-and-Play

1. Declaración del Problema

La investigación en aprendizaje de robots está actualmente fragmentada en tres ejes mayormente independientes: familias de políticas ( $P$ , ej. IL, RL, VLA, WAM), suites de benchmarks ( $B$ , ej. LIBERO, ManiSkill) y encarnaciones de robots ( $R$ , ej. Franka, Unitree H1). Integrar cualquier triplete específico $(P, B, R)$ típicamente requiere una capa de integración distinta y escrita a mano que involucre configuración de Docker, adaptadores de observación y procedimientos de validación de confianza.

Esta fragmentación crea una "brecha de arnés" (harness gap). Si bien los Modelos de Lenguaje Grandes (LLM) han avanzado en la generación de código, a menudo fallan en producir resultados reproducibles de extremo a extremo en robótica porque carecen de los priors procedimentales y las prácticas de validación específicos de los flujos de trabajo de investigación en robótica. La carga de ingeniería escala como $\Theta(N \cdot M \cdot K)$ , donde $N, M, K$ son las cardinalidades de políticas, benchmarks y robots. Los marcos existentes (ej. LeRobot, Isaac Lab) suelen estar acoplados a componentes fijos, mientras que los agentes de codificación de propósito general carecen del andamiaje específico del dominio necesario para navegar conflictos complejos de dependencias y desajustes de interfaces.

2. Metodología: El Arnés NAUTILUS

Los autores proponen NAUTILUS, un arnés de código abierto orientado a agentes diseñado para convertir un único prompt de lenguaje natural (ej. "Evaluar la política A con el benchmark B") en flujos de trabajo listos para usar de reproducción, evaluación, ajuste fino y despliegue. NAUTILUS se estructura en dos capas: un sustrato y una capa de contenido.

2.1 El Sustrato (Invariantes de Ingeniería)

El sustrato proporciona una superficie estable sobre la cual el agente puede razonar, reduciendo la complejidad de integración de $\Theta(N \cdot M \cdot K)$ a $\Theta(N + M + K)$ . Se basa en tres invariantes:

Contratos de Interfaz Tipada: Las políticas, benchmarks y robots se exponen a través de esquemas fijos y legibles por máquina (ej. infer(obs) -> acciones, reset(seed), apply_action). Estos contratos ocultan la maquinaria específica de implementación (ej. pilas CUDA, controladores ROS 2) y definen la unidad de integración.
Ejecución en Cámaras: Los artefactos generados se ejecutan en contenedores desechables e aislados. Esto evita que los fallos de dependencias (ej. versiones conflictivas de CUDA) se filtren entre módulos. Un contenedor de política, un contenedor de benchmark y un contenedor de hardware ocupan la misma ranura arquitectónica desde la perspectiva del agente.
Comunicación Uniforme Inter-módulo:
- Nivel 1 (Local al robot): La percepción y el control de alto ancho de banda permanecen en la pila nativa del robot (ej. ROS 2, memoria compartida).
- Nivel 2 (Fuera del robot): El agente solo ve un protocolo WebSocket ligero que conecta el contenedor de política con el endpoint del benchmark o del robot real. Esto asegura que los endpoints simulados y de robots reales compartan un único esquema de observación/acción.

2.2 La Capa de Contenido (Guías, Sensores, Estado)

Construida sobre el sustrato, esta capa destila los flujos de trabajo de investigación en robótica en componentes explícitos y reutilizables:

Guías: Instrucciones pre-generación que orientan el comportamiento del agente, proporcionando reglas de enrutamiento, roles de subagentes y protocolos de validación antes de escribir el código.
Sensores: Validadores post-generación que verifican los artefactos contra seis criterios (ej. filtrado pre-acción, verificación de interfaz, comparación de especificaciones, pruebas de humo). Los sensores pueden desencadenar correcciones locales o bloquear ejecuciones si se violan los contratos.
Estado: Un registro persistente, validado por esquema JSON, que almacena contratos tipados y artefactos fijados (commits de origen, imágenes Docker). Esto permite al agente reutilizar conocimiento de módulos verificados en lugar de redescubrir la disposición de los repositorios desde cero.
Artefactos del Espacio de Trabajo: Registros de solo adición y recibos de reproducción que registran el commit de origen, las elecciones de entorno y las decisiones para cada ejecución.

2.3 Flujo de Ejecución

Cuando un usuario emite un prompt (ej. "Ejecutar $\pi_0$ en LIBERO"), el orquestador enruta la solicitud a un flujo de trabajo específico de subagente. El sistema verifica el registro de Estado en busca de entradas verificadas. Si faltan, genera módulos de política y benchmark en paralelo, compara sus especificaciones tipadas (ej. claves de observación, formas de acción), ejecuta una prueba de humo WebSocket y escribe recibos de reproducibilidad.

3. Contribuciones Clave

Sustrato Modular: Un sistema basado en contratos tipados, ejecución en cámaras y transporte uniforme que colapsa el costo de integración del aprendizaje de robots entre familias.
Priors Procedimentales Destilados: La conversión del conocimiento tácito de los flujos de trabajo en robótica en Guías y Sensores explícitos, transformando la generación "caja negra" del agente en un proceso validado y paso a paso.
Plataforma de Código Abierto: El lanzamiento de NAUTILUS con flujos de trabajo estructurados que soportan cuatro familias de políticas (IL, VLA, RL, WAM), seis suites de benchmarks y cuatro clases de encarnación. Incluye nautilus-collect, una plataforma de recolección de datos que valida el mismo contrato de Robot en hardware heterogéneo (Franka y Unitree H1).
Registro Extensible: Una plataforma comunitaria donde nuevas políticas, benchmarks o robots pueden incorporarse mediante 3–5 contratos de métodos tipados sin modificar el código del marco, siempre que pasen los protocolos de validación de confianza.

4. Resultados Experimentales

El artículo evalúa NAUTILUS a través de tres estudios:

Validación de Confianza de Benchmark: El sistema reprodujo resultados de referencia para políticas públicas (Diffusion Policy, $\pi_0$ , OpenVLA, etc.) en LIBERO, ManiSkill, RoboTwin, ALOHA y RoboCasa. Los envoltorios generados reprodujeron fielmente las puntuaciones de referencia con pequeñas desviaciones (ej. $\Delta \approx \pm 2\%$ ), confirmando que los adaptadores preservan los protocolos de evaluación previstos.
Ablación sobre Extensibilidad: En un banco de pruebas de "dejar un benchmark fuera", NAUTILUS se comparó con un agente de codificación estándar.
- Éxito: NAUTILUS logró un 100% de éxito en el envoltorio y un alto éxito en la tarea (98.7% en Claude Opus 4.7).
- Eficiencia de Costos: Eliminar la plantilla tipada (el sustrato) hizo que el éxito del envoltorio cayera al 55.3% y que el uso de tokens se triplicara (41.7M tokens), demostrando que el sustrato evita que el agente vuelva a aprender el código de unión.
- Escalado de Modelos: El arnés proporcionó beneficios relativos mayores en modelos más débiles (Claude Sonnet 4.6), reduciendo los giros de interacción en ~27% y los costos en ~8% en comparación con el agente estándar.
Despliegue en Robot Real: El sistema desplegó con éxito un punto de control de manipulación VLA ( $\pi_0.5$ ) en un brazo Franka y una política de locomoción RL en un Unitree H1. En ambos casos, el mismo artefacto de política envuelto para simulación se transfirió al hardware intercambiando únicamente el contenedor de hardware, sin cambios en el código de la política ni en el contenedor del lado de la plataforma.

5. Significado y Afirmaciones

El artículo argumenta que la restricción principal en la automatización agéntica en el aprendizaje de robots no es la capacidad del modelo LLM, sino la ingeniería del arnés que lo rodea. NAUTILUS demuestra que, al proporcionar un sustrato estable basado en contratos con validación explícita, la carga de ingeniería de la reproducción y evaluación entre familias puede reducirse drásticamente.

Los autores afirman que NAUTILUS transforma flujos de trabajo de investigación fragmentados en procedimientos estructurados y agénticos. Al hacer que la experiencia del dominio (contratos, protocolos de validación, gestión de estado) sea ejecutable, reutilizable e inspeccionable, el sistema permite a los investigadores escalar sus flujos de trabajo sin curar manualmente código de unión para cada nueva combinación $(P, B, R)$ . El trabajo posiciona a NAUTILUS no solo como una herramienta de automatización, sino como un paso hacia un futuro donde los arneses construidos por expertos permitan a los modelos escalar la experiencia del dominio en todo el ecosistema de aprendizaje de robots.