💻 computer science

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

O artigo apresenta o NAUTILUS, um framework de código aberto que transforma prompts únicos em fluxos de trabalho de aprendizado robótico automatizados e validados, fornecendo habilidades de agentes plug-and-play, interfaces unificadas e execução escalável em câmaras para eliminar a fragmentação de engenharia que atualmente impede a reprodução e avaliação de políticas entre diferentes famílias.

Autores originais: 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 leitura🧠 Leitura aprofundada

CC BY 4.0

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

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine o mundo da aprendizagem robótica como um enorme e caótico canteiro de obras. De um lado, você tem arquitetos projetando novos cérebros robóticos (chamados de "políticas"). De outro, você tem pistas de teste (benchmarks) onde robôs aprendem a andar ou pegar objetos. De um terceiro lado, você tem os próprios robôs, variando de braços simples a andadores humanoides.

O problema, segundo este artigo, é que conectar qualquer arquiteto a qualquer pista de teste e a qualquer robô é um pesadelo. Toda vez que um pesquisador deseja testar um novo cérebro em uma nova pista com um novo robô, eles precisam construir uma ponte personalizada do zero. Eles têm que escrever "código de cola" para fazer as linguagens coincidirem, corrigir versões de software conflitantes e garantir que o robô não travará. É como tentar conectar uma torradeira em um motor de carro, uma torradeira em uma espaçonave e uma torradeira em um barco — cada vez, você tem que inventar um novo adaptador.

Aí entra o Nautilus.

Os autores propõem o Nautilus como um sistema universal de "plug-and-play". Pense nele como uma estação adaptadora inteligente e mágica para toda a indústria da aprendizagem robótica.

Veja como funciona, usando analogias simples:

1. A "Fita de Energia Universal" (Contratos Tipados)

Atualmente, cada robô e cada cérebro fala uma linguagem diferente. O Nautilus introduz uma fita de energia padronizada.

A Analogia: Imagine se cada eletrodoméstico da sua casa (torradeira, lâmpada, TV) tivesse que ser rebaixado para cabir na tomada da parede. O Nautilus diz: "Chega de rebaixamento". Ele força cada cérebro robótico e cada pista de teste a concordar com uma única forma rígida para seus plugues (chamados de "contratos tipados").
O Resultado: Uma vez que um cérebro robótico é conectado a esse padrão, ele pode se conectar instantaneamente a qualquer pista de teste ou robô sem precisar de um adaptador personalizado.

2. As "Cabines Insonorizadas" (Execução em Câmaras)

O software robótico é bagunçado. Um robô pode precisar de uma versão específica de um motor de videogame, enquanto outro precisa de uma versão diferente de um simulador de física. Se você os executar no mesmo computador, eles brigam e travam.

A Analogia: O Nautilus constrói cabines insonorizadas (containers) para cada parte do experimento. O cérebro robótico vive em uma cabine, a pista de teste em outra e o próprio robô em uma terceira. Eles podem conversar entre si através de uma janela segura, mas suas ferramentas internas bagunçadas nunca colidem.
O Resultado: Você pode misturar e combinar qualquer combinação sem se preocupar com conflitos de software.

3. O "Gerente de Projeto Inteligente" (O Agente)

O artigo usa um Modelo de Linguagem Grande (um codificador de IA) para fazer o trabalho pesado. Mas, geralmente, os codificadores de IA falham na robótica porque não conhecem as "regras não escritas" do campo.

A Analogia: O Nautilus dá ao codificador de IA um livro de regras e uma lista de verificação (chamados de Guias e Sensores).
- Guias: Antes da IA escrever código, o livro de regras diz a ela: "Ei, os robôs precisam ser reiniciados antes de começar, e você deve verificar se a bateria está segura."
- Sensores: Depois que a IA escreve o código, um inspetor de segurança o verifica. "Você realmente testou se o robô se move? Você verificou o formato dos dados?" Se a resposta for não, a IA tem que corrigir antes de prosseguir.
O Resultado: A IA não apenas adivinha; ela segue um fluxo de trabalho comprovado e seguro que os pesquisadores usam todos os dias.

4. A "Concha do Nautilus" (Escalabilidade)

O nome vem da concha do nautilus, que cresce adicionando novas câmaras.

A Analogia: Em vez de construir uma estrutura gigante e rígida que quebra quando você adiciona um novo robô, o Nautilus cresce adicionando novas câmaras. Se um pesquisador adicionar um novo robô (como um novo tipo de mão), eles apenas adicionam uma nova "câmara" ao sistema. O resto do sistema não precisa ser reconstruído.
O Resultado: O sistema fica maior e mais útil sem ficar mais complicado.

O Que Eles Realmente Provaram?

O artigo não afirma que o Nautilus inventou um novo cérebro robótico ou que tornou os robôs mais inteligentes do que eram antes. Em vez disso, eles provaram:

Funciona como um tradutor: Eles pegaram cérebros robóticos existentes e os testaram em benchmarks existentes usando o Nautilus, e os resultados corresponderam ao que os autores originais afirmaram.
Economiza tempo: Eles mostraram que usar o Nautilus para conectar um novo cérebro robótico a uma nova pista de teste é muito mais rápido e barato do que fazer isso manualmente. Reduz o trabalho de construir uma ponte para cada par individual para apenas construir uma ponte para todo o sistema.
Funciona em robôs reais: Eles pegaram com sucesso um cérebro robótico treinado em uma simulação, envolveram-no no Nautilus e o implantaram em dois robôs reais muito diferentes (um braço robótico Franka e um robô humanoide Unitree H1) sem alterar o código do cérebro.

Em resumo: O Nautilus não é um novo cérebro robótico; é o tradutor universal e inspetor de segurança que permite que diferentes cérebros robóticos, pistas de teste e robôs finalmente conversem entre si sem precisar de uma equipe de engenheiros para construir uma ponte personalizada toda vez.

Resumo Técnico: Nautilus: De Um Prompt a Aprendizado de Robô Plug-and-Play

1. Declaração do Problema

A pesquisa em aprendizado de robôs está atualmente fragmentada em três eixos largely independentes: famílias de políticas ( $P$ , ex: IL, RL, VLA, WAM), conjuntos de benchmarks ( $B$ , ex: LIBERO, ManiSkill) e embodiments de robôs ( $R$ , ex: Franka, Unitree H1). Integrar qualquer triplet específico $(P, B, R)$ tipicamente requer uma camada de integração distinta e escrita manualmente, envolvendo configuração Docker, adaptadores de observação e procedimentos de validação de confiança.

Essa fragmentação cria uma "lacuna de harness" (harness gap). Embora os Modelos de Linguagem de Grande Escala (LLMs) tenham avançado na geração de código, eles frequentemente falham em produzir resultados reproduzíveis de ponta a ponta em robótica porque carecem dos priors procedimentais e práticas de validação específicos dos fluxos de trabalho de pesquisa em robótica. O ônus de engenharia escala como $\Theta(N \cdot M \cdot K)$ , onde $N, M, K$ são as cardinalidades de políticas, benchmarks e robôs. Frameworks existentes (ex: LeRobot, Isaac Lab) são frequentemente acoplados a componentes fixos, enquanto agentes de codificação de propósito geral carecem do andaime específico do domínio necessário para navegar conflitos complexos de dependência e incompatibilidades de interface.

2. Metodologia: O Harness NAUTILUS

Os autores propõem o NAUTILUS, um harness de código aberto voltado para agentes, projetado para transformar um único prompt em linguagem natural (ex: "Avalie a política A com o benchmark B") em fluxos de trabalho prontos para uso de reprodução, avaliação, ajuste fino e implantação. O NAUTILUS é estruturado em duas camadas: um substrato e uma camada de conteúdo.

2.1 O Substrato (Invariantes de Engenharia)

O substrato fornece uma superfície estável para o agente raciocinar, reduzindo a complexidade de integração de $\Theta(N \cdot M \cdot K)$ para $\Theta(N + M + K)$ . Ele depende de três invariantes:

Contratos de Interface Tipada: Políticas, benchmarks e robôs são expostos através de esquemas fixos e legíveis por máquina (ex: infer(obs) -> ações, reset(seed), apply_action). Esses contratos ocultam a maquinaria específica da implementação (ex: stacks CUDA, drivers ROS 2) e definem a unidade de integração.
Execução em Câmaras: Artefatos gerados são executados em contêineres descartáveis e isolados. Isso impede que falhas de dependência (ex: versões conflitantes de CUDA) vazem entre módulos. Um contêiner de política, um contêiner de benchmark e um contêiner de hardware ocupam o mesmo slot arquitetural da perspectiva do agente.
Comunicação Uniforme Inter-módulo:
- Nível 1 (Local ao robô): Sensoriamento e controle de alta largura de banda permanecem na stack nativa do robô (ex: ROS 2, memória compartilhada).
- Nível 2 (Fora do robô): O agente vê apenas um protocolo WebSocket leve conectando o contêiner de política ao endpoint do benchmark ou do robô real. Isso garante que os endpoints simulados e de robô real compartilhem um único esquema de observação/ação.

2.2 A Camada de Conteúdo (Guias, Sensores, Estado)

Construída sobre o substrato, esta camada destila fluxos de trabalho de pesquisa em robótica em componentes explícitos e reutilizáveis:

Guias: Instruções pré-geração que orientam o comportamento do agente, fornecendo regras de roteamento, papéis de subagentes e protocolos de validação antes que o código seja escrito.
Sensores: Validadores pós-geração que verificam artefatos contra seis critérios (ex: filtragem pré-ação, verificação de interface, comparação de especificação, testes de fumaça). Sensores podem acionar correções locais ou bloquear execuções se contratos forem violados.
Estado: Um registro persistente, validado por esquema JSON, que armazena contratos tipados e artefatos fixados (commits de origem, imagens Docker). Isso permite que o agente reutilize conhecimento de módulos verificados em vez de redescobrir layouts de repositório do zero.
Artefatos de Workspace: Logs apenas de adição e recibos de reprodução que registram o commit de origem, escolhas de ambiente e decisões para cada execução.

2.3 Fluxo de Execução

Quando um usuário emite um prompt (ex: "Execute $\pi_0$ no LIBERO"), o orquestrador roteia a solicitação para um fluxo de trabalho específico de subagente. O sistema verifica o registro Estado por entradas verificadas. Se ausentes, gera módulos de política e benchmark em paralelo, compara suas especificações tipadas (ex: chaves de observação, formas de ação), executa um teste de fumaça WebSocket e escreve recibos de reprodutibilidade.

3. Contribuições Principais

Substrato Modular: Um sistema baseado em contratos tipados, execução em câmaras e transporte uniforme que colapsa o custo de integração do aprendizado de robôs entre famílias.
Priors Procedimentais Destilados: A conversão de conhecimento tácito de fluxos de trabalho de robótica em Guias e Sensores explícitos, transformando a geração "caixa preta" do agente em um processo validado e passo a passo.
Plataforma de Código Aberto: O lançamento do NAUTILUS com fluxos de trabalho estruturados que suportam quatro famílias de políticas (IL, VLA, RL, WAM), seis conjuntos de benchmarks e quatro classes de embodiment. Inclui o nautilus-collect, uma plataforma de coleta de dados que valida o mesmo Contrato de Robô em hardware heterogêneo (Franka e Unitree H1).
Registro Extensível: Uma plataforma comunitária onde novas políticas, benchmarks ou robôs podem ser integrados via 3–5 contratos de métodos tipados sem modificar o código do framework, desde que passem pelos protocolos de validação de confiança.

4. Resultados Experimentais

O artigo avalia o NAUTILUS através de três estudos:

Validação de Confiança de Benchmark: O sistema reproduziu resultados de referência para políticas públicas (Diffusion Policy, $\pi_0$ , OpenVLA, etc.) em LIBERO, ManiSkill, RoboTwin, ALOHA e RoboCasa. Os wrappers gerados reproduziram fielmente as pontuações de referência com pequenas desvios (ex: $\Delta \approx \pm 2\%$ ), confirmando que os adaptadores preservam os protocolos de avaliação pretendidos.
Ablação sobre Extensibilidade: Em um ambiente de teste "leave-one-benchmark-out", o NAUTILUS foi comparado a um agente de codificação vanilla.
- Sucesso: O NAUTILUS alcançou 100% de sucesso de wrap e alto sucesso de tarefa (98,7% no Claude Opus 4.7).
- Eficiência de Custo: Remover o modelo tipado (o substrato) causou uma queda no sucesso de wrap para 55,3% e triplicou o uso de tokens (41,7M tokens), demonstrando que o substrato impede que o agente reaprenda código de cola.
- Escalonamento de Modelo: O harness forneceu benefícios relativos maiores em modelos mais fracos (Claude Sonnet 4.6), reduzindo os turnos de interação em ~27% e os custos em ~8% em comparação com o agente vanilla.
Implantação em Robô Real: O sistema implantou com sucesso um checkpoint de manipulação VLA ( $\pi_0.5$ ) em um braço Franka e uma política de locomoção RL em um Unitree H1. Em ambos os casos, o mesmo artefato de política encapsulado para simulação foi transferido para o hardware trocando apenas o contêiner de hardware, sem alterações no código da política ou no contêiner do lado da plataforma.

5. Significado e Alegações

O artigo argumenta que a principal restrição à automação agênica no aprendizado de robôs não é a capacidade do modelo LLM, mas a engenharia de harness que o cerca. O NAUTILUS demonstra que, ao fornecer um substrato estável e baseado em contratos com validação explícita, o ônus de engenharia da reprodução e avaliação entre famílias pode ser drasticamente reduzido.

Os autores afirmam que o NAUTILUS transforma fluxos de trabalho de pesquisa fragmentados em procedimentos estruturados e agênicos. Ao tornar o conhecimento de domínio (contratos, protocolos de validação, gerenciamento de estado) executável, reutilizável e inspecionável, o sistema permite que pesquisadores escalem seus fluxos de trabalho sem curar manualmente código de cola para cada nova combinação $(P, B, R)$ . O trabalho posiciona o NAUTILUS não apenas como uma ferramenta para automação, mas como um passo em direção a um futuro onde harnesses construídos por especialistas permitem que modelos escalem o conhecimento de domínio em todo o ecossistema de aprendizado de robôs.