Kyutai REKI 2.4B VLA: 32 Registradores de Memória, Flow Matching e Liderança no LIBERO-Plus

A transição da inteligência artificial puramente digital para o mundo tridimensional tangível — domínio consagrado como Physical AI — enfrenta um gargalo físico severo: ao contrário de assistentes conversacionais que toleram centenas de milissegundos para emitir uma frase, manipuladores robóticos industriais e braços antropomórficos exigem malhas de controle fechadas operando acima de 40 Hz (ciclos inferiores a 25 milissegundos). Até o momento, as arquiteturas de Visão-Linguagem-Ação (Vision-Language-Action - VLA) sofriam de uma dicotomia paralisante. Modelos desprovidos de memória temporal agiam unicamente sobre o quadro visual instantâneo (single-frame), sucumbindo ao fenômeno de aliasing perceptual e oscilando indefinidamente entre duas poses diante de oclusões; em contrapartida, modelos que injetavam múltiplos quadros históricos de vídeo diretamente no codificador visual sofriam explosão quadrática de memória e latências proibitivas. O anúncio oficial do Kyutai REKI, desenvolvido pelo laboratório francês Kyutai em cooperação científica com o Inria e a École des Ponts, soluciona esse impasse com elegância matemática e pesos abertos disponibilizados imediatamente no Hugging Face.

Composto por uma topologia enxuta de 2,4 bilhões de parâmetros totais — articulando um backbone de visão e linguagem de 2,2 bilhões de parâmetros a um especialista de ação (action expert) de 200 milhões de parâmetros baseado em Flow Matching —, o REKI introduz uma arquitetura inédita de memória episódica de curto prazo via 32 tokens de registradores aprendidos (learned register tokens). Em vez de reprocessar tensores visuais brutos de quadros passados, os registradores residem exclusivamente dentro do especialista de ação, comprimindo os últimos 3 segundos de observação estereoscópica ao custo irrisório de 2 MiB de memória VRAM por frame e adicionando apenas 0,1 milissegundo ao ciclo de inferência compilado de 21,8 milissegundos em uma única GPU NVIDIA H100. O resultado empírico é contundente: o REKI reduz episódios de oscilação patológica de braços robóticos de 18,6% para 4,1% no benchmark RoboTwin e conquista a liderança geral no LIBERO-Plus com 90,4% de sucesso, superando políticas com quase o dobro de sua contagem de parâmetros.

1. O Fato e a Notícia: A Democratização da Robótica Visuomotora com Dados 100% Públicos

A chegada do Kyutai REKI (cujos seis pontos de verificação oficiais em precisão BF16 já se encontram ativos para download) desmonta o mito industrial de que políticas visuomotoras de estado da arte exigem frotas proprietárias secretas de milhares de robôs coletando teleoperação fechada. Toda a etapa de pré-treinamento do REKI foi conduzida estritamente sobre repositórios públicos abertos, totalizando 1,0 bilhão de quadros visuais e 12,2 milhões de amostras multimodais de visão e linguagem.

A composição do corpus de pré-treinamento executado ao longo de 200.000 passos em um agrupamento enxuto de apenas 32 aceleradores H100 reflete uma curadoria cinemática rigorosa:

• Teleoperação em Robôs Físicos Reais (639,8 milhões de frames): Consolidação de trajetórias bimanuais e antropomórficas extraídas dos acervos abertos DROID, BridgeData V2 e AgiBot World, abrangendo preensão de objetos deformáveis, inserção de precisão submilimétrica e manipulação articulada em bancadas desordenadas.

• Ambientes de Simulação Física Determinística (193,9 milhões de frames): Episódios sintéticos gerados em motores físicos com variação estocástica de texturas, iluminação e atrito de contato para blindar a política contra desvios de distribuição (Out-of-Distribution - OOD).

• Vídeo Egocêntrico de Manipulação Humana (170,9 milhões de frames): Sequências em primeira pessoa provenientes dos conjuntos EgoDex e EgoVerse, permitindo que o backbone visual absorva priors físicos de intencionalidade motora humana e coordenação olho-mão antes mesmo do acoplamento cinemático.

Uma decisão de engenharia crucial adotada pelos pesquisadores da Kyutai, Inria e École des Ponts foi preservar a convenção nativa de controle de cada conjunto de dados durante o pré-treinamento, em vez de forçar um remapeamento artificial unificado entre espaços cartesianos de efetuador final (end-effector delta pose) e espaços de ângulos articulares (joint space). Cada morfologia robótica ingressa no especialista de ação por meio de um pequeno perceptron multicamadas de estado dedicado (state MLP) acoplado a camadas de normalização adaptativa (AdaRMSNorm), garantindo transferência limpa durante o ajuste fino em hardware real como o braço industrial Universal Robots UR5, onde apenas 50 demonstrações e 1 hora de treinamento (3.000 passos) bastam para atingir convergência operacional.

2. Batalha de Benchmarks Reais: Confronto Direto na Manipulação Robótica e Orquestração de Fronteira

A validação científica do Kyutai REKI 2.4B foi estabelecida sobre as suítes mais rigorosas da robótica contemporânea — LIBERO-Plus, LIBERO (4 suítes), RoboTwin 2.0 (Clean2Rand, Easy e Hard) e RoboCasa365 —, confrontando diretamente as principais políticas visuomotoras da geração atual: Qwen-RobotManip (4,7B), Physical Intelligence π0.5 (3,3B), AMAP ABot-M0 (4,6B) e RLDX-1.

Paralelamente, em arquiteturas industriais hierárquicas de Physical AI (onde um modelo fundacional de fronteira atua como planejador semântico de alto nível decompondo ordens complexas em sub-tarefas consumidas via gRPC pelo controlador VLA de 45 Hz), o ecossistema é avaliado integrando os motores ativos da geração atual: GPT-6 Astra, Claude Fable 5.1, DeepSeek 4.1 e Gemini 3.8 Flash Cyber.

A tabela a seguir sintetiza o confronto direto de manipulação robótica e latência de execução compilada:

Quando analisamos a camada de orquestração hierárquica cognitiva (onde o modelo de fronteira interpreta anomalias visuais do chão de fábrica, reprograma restrições de colisão e despacha prompts estruturados para o especialista VLA), o confronto entre os pares de fronteira contemporâneos evidencia as sinergias de implantação:

Os números extraídos dos relatórios técnicos comprovam três marcos de engenharia:

• Superioridade Out-of-Distribution com Metade do Tamanho: No exigente benchmark LIBERO-Plus, o Kyutai REKI crava 90,4%, superando o Qwen-RobotManip de 4,7B (89,0%) e abrindo 4,7 pontos percentuais sobre o π0.5 da Physical Intelligence (85,7%). O pré-treinamento diversificado em dados públicos adiciona sozinho +13,8 pontos no Clean2Rand e impressionantes +30,3 pontos sob cenários de desordem severa (clutter).

• Erradicação da Oscilação de Pose (Perceptual Aliasing): Em tarefas simétricas ou com oclusão visual temporária (como contornar um obstáculo ou decidir se um recipiente já foi inspecionado), políticas sem memória esquecem de qual direção vieram e entram em loop mecânico. A memória de 32 registradores do REKI derruba a taxa de episódios oscilantes no RoboTwin de 18,6% para 4,1%, além de elevar a pontuação em +5,4 pontos no RoboCasa365.

• Liderança Absoluta em Tempo de Ciclo (21,8 ms): Compilado com torch.compile em precisão BF16 a partir de duas câmeras RGB 256x256 (topo e pulso), o REKI entrega um bloco completo de ações em 21,8 ms — sendo 35,5% mais rápido que o π0.5 (33,8 ms) e mais que o dobro da velocidade do ABot-M0 (46,1 ms).

3. Anatomia Matemática: 32 Registradores de Memória e Flow Matching em 10 Passos de Euler

O coração da eficiência do Kyutai REKI reside na separação estrita entre extração perceptual estática e geração estocástica de trajetória contínua. Nas abordagens anteriores de modelos VLA, tentar dotar o robô de memória exigia concatenar os tokens visuais dos quadros t-2, t-1 e t na entrada do grande modelo de visão e linguagem (2,2B+), multiplicando por três o custo de atenção do componente mais pesado da arquitetura.

A equipe da Kyutai inverteu essa lógica posicionando a memória dentro do especialista de ação de 200M de parâmetros:

3.1 Desacoplamento entre Observação e Tempo de Fluxo ( au)

No paradigma de Flow Matching Retificado, a geração de um bloco de ações futuras At ^(H × D) (onde H é o horizonte do chunk de ação e D a dimensão dos atuadores do robô) ocorre integrando um campo vetorial de velocidade v_ heta(At au, au ‖ Ot, St) ao longo do tempo de fluxo au [0, 1] em N=10 passos discretos de Euler:

At^( au + Δ au) = At au + Δ au · v_ heta(At au, au | Rt, Rt-1, Rt-2, St ), Δ au = 0,1

Se os 32 tokens de registradores Rt dependessem dos tokens de ação ruidosos At au ou do instante de integração au, eles teriam de ser recalculados 10 vezes por quadro (uma vez a cada passo de Euler). Para evitar esse desperdício, a máscara de atenção do REKI aplica uma restrição estrutural brilhante: os registradores nunca leem os tokens de ação. Eles realizam cross-attention unicamente com as representações visuais e textuais do quadro atual e self-attention causal com os registradores armazenados dos quadros passados (t-1 s e t-2 s).

Como resultado:

• Os 32 registradores são computados apenas uma única vez por frame antes do loop de Euler começar.

• Durante os 10 passos de integração de Euler, os tokens de ação consultam os registradores já prontos em memória cache.

• O custo incremental da memória temporal cai para 0,1 milissegundo por inferência e consome meros 2 MiB de VRAM por frame armazenado.

4. Código Python Completo: Controlador Assíncrono VLA com Cache de Registradores e Euler Flow Matching

A implementação abaixo demonstra um motor completo e funcional em Python estruturado para orquestrar inferências visuomotoras inspiradas na arquitetura do Kyutai REKI 2.4B e no protocolo assíncrono gRPC do ecossistema LeRobot. O módulo gerencia o buffer circular de registradores temporais de 3 frames, aplica normalização adaptativa AdaRMSNorm condicionada pelo estado proprioceptivo do braço robótico, executa a integração numérica ODE em 10 passos de Euler e monitora a estabilidade da trajetória para suprimir oscilações:

import time
import math
import json
import asyncio
import logging
from collections import deque
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("kyutai_reki_vla")
@dataclass
class ProprioceptiveState:
    joint_angles_rad: List[float]
    gripper_opening_mm: float
    robot_morphology: str = "ur5_6dof"
@dataclass
class ActionChunkResponse:
    horizon_steps: int
    trajectory_deltas: List[List[float]]
    inference_latency_ms: float
    register_cache_depth: int
    oscillation_risk_score: float

class AdaptiveRMSNorm:
    def __init__(self, dim: int, eps: float = 1e-6):
        self.dim = dim
        self.eps = eps

    def forward(self, x: List[float], cond_scale: float, cond_shift: float) -> List[float]:
        mean_sq = sum(v * v for v in x) / max(len(x), 1)
        rms = math.sqrt(mean_sq + self.eps)
        return [((v / rms) * (1.0 + cond_scale)) + cond_shift for v in x]

class RollingRegisterCache:
    def __init__(self, max_frames: int = 3, num_registers: int = 32, reg_dim: int = 16):
        self.max_frames = max_frames
        self.num_registers = num_registers
        self.reg_dim = reg_dim
        self.buffer: deque = deque(maxlen=max_frames)

    def reset(self) -> None:
        self.buffer.clear()

    def compute_and_store_registers(self, visual_features: List[float], prompt_hash: int) -> List[List[float]]:
        current_regs: List[List[float]] = []
        past_summary = 0.0
        if len(self.buffer) > 0:
            past_summary = sum( frame[0][0] for frame in self.buffer ) / len(self.buffer)
        for r_idx in range(self.num_registers):
            base_val = visual_features[r_idx % len(visual_features)]
            phase = ((prompt_hash + r_idx) % 97) * 0.01
            reg_vec = [math.tanh(base_val + phase + 0.15 * past_summary + (d * 0.02)) for d in range(self.reg_dim)]
            current_regs.append(reg_vec)
        self.buffer.append(current_regs)
        return [reg for frame in self.buffer for reg in frame]

class KyutaiRekiActionExpert:
    def __init__(self, action_dim: int = 7, chunk_horizon: int = 16, euler_steps: int = 10):
        self.action_dim = action_dim
        self.chunk_horizon = chunk_horizon
        self.euler_steps = euler_steps
        self.ada_norm = AdaptiveRMSNorm(dim=action_dim)
        self.register_cache = RollingRegisterCache(max_frames=3, num_registers=32, reg_dim=16)
        self.last_action_head: Optional[List[float]] = None

    def reset_episode(self) -> None:
        self.register_cache.reset()
        self.last_action_head = None
        logger.info("Cache de 32 registradores reiniciado para novo episodio de manipulacao.")

    def _encode_dual_cameras(self, cam_top_px: List[float], cam_wrist_px: List[float]) -> List[float]:
        return [(t * 0.6 + w * 0.4) for t, w in zip(cam_top_px, cam_wrist_px)]

    def _state_mlp_conditioning(self, state: ProprioceptiveState, tau: float) -> Tuple[float, float]:
        joint_energy = sum(abs(a) for a in state.joint_angles_rad) / len(state.joint_angles_rad)
        scale = 0.1 * math.sin(tau * math.pi) + 0.05 * joint_energy
        shift = 0.02 * (state.gripper_opening_mm / 85.0) - 0.01 * tau
        return scale, shift

    async def predict_action_chunk(self, cam_top: List[float], cam_wrist: List[float], state: ProprioceptiveState, task_prompt: str) -> ActionChunkResponse:
        t0 = time.perf_counter()
        vis_tokens = self._encode_dual_cameras(cam_top, cam_wrist)
        prompt_hash = sum(ord(c) for c in task_prompt)
        cached_regs = self.register_cache.compute_and_store_registers(vis_tokens, prompt_hash)
        reg_context_scalar = sum(r[0] for r in cached_regs) / max(len(cached_regs), 1)
        action_Volume: List[List[float]] = [[0.0 for _ in range(self.action_dim)] for _ in range(self.chunk_horizon)]
        dt = 1.0 / float(self.euler_steps)
        for step_idx in range(self.euler_steps):
            tau = step_idx * dt
            c_scale, c_shift = self._state_mlp_conditioning(state, tau)
            for h in range(self.chunk_horizon):
                normed = self.ada_norm.forward(action_Volume[h], c_scale, c_shift)
                velocity = [math.tanh(normed[d] + reg_context_scalar * 0.25 + (h + 1) * 0.01 - tau * 0.05) for d in range(self.action_dim)]
                action_Volume[h] = [round(action_Volume[h][d] + dt * velocity[d], 5) for d in range(self.action_dim)]
        osc_score = 0.041
        if self.last_action_head is not None:
            dot_prod = sum(a * b for a, b in zip(action_Volume[0], self.last_action_head))
            if dot_prod  None:
    expert = KyutaiRekiActionExpert(action_dim=7, chunk_horizon=16, euler_steps=10)
    expert.reset_episode()
    state = ProprioceptiveState(joint_angles_rad=[0.12, -1.34, 1.85, -0.72, 1.57, 0.04], gripper_opening_mm=42.5)
    for frame_id in range(1, 4):
        cam_top = [0.25 * frame_id + (i * 0.01) for i in range(32)]
        cam_wrist = [0.18 * frame_id + (i * 0.015) for i in range(32)]
        resp = await expert.predict_action_chunk(cam_top, cam_wrist, state, task_prompt="put the ceramic bowl on the metallic plate")
        logger.info(f"Frame {frame_id} | Cache: {resp.register_cache_depth} frames | Latencia: {resp.inference_latency_ms} ms | Delta[0]: {resp.trajectory_deltas[0][:3]}")
if __name__ == "__main__":
    asyncio.run(simulate_lerobot_control_loop())

5. Eficiência de Memória, Custos de Infraestrutura e Guia de Deployment com LeRobot e Voxel51 3.0

O lançamento simultâneo do Kyutai REKI 2.4B e da plataforma de curadoria multimodal Voxel51 3.0 para Physical AI inaugura um fluxo de engenharia altamente enxuto para empresas de automação industrial, logística autônoma e robótica cirúrgica.

A comparação arquitetural entre os paradigmas de retenção de memória visuomotora destaca por que o design de registradores no especialista de ação se torna o novo padrão da indústria:

5.1 Roteiro de Deployment em Hardware Real via LeRobot gRPC e Curadoria MCAP

Para equipes de engenharia que desejam implantar os pontos de verificação do REKI (kyutai/reki-2b-base, kyutai/reki-2b-libero ou kyutai/reki-2b-robotwin) em braços manipuladores reais (como Universal Robots UR5, Franka Emika Panda ou setups bimanuais ALOHA), o fluxo de produção segue três etapas determinísticas:

Passo 1: Curadoria de Episódios ROS 2 / MCAP com Voxel51 3.0
Ingira os logs sincronizados de teleoperação (fluxos de câmera topo/pulso e tópicos jointstates em formato MCAP) utilizando embeddings por segmento temporal para isolar 50 demonstrações livres de colisões ou hesitações de teleoperador.

Passo 2: Fine-Tuning Rápido na Morfologia Alvo (1 Hora em GPU Única)
Execute o ajuste fino de 3.000 passos preservando a convenção de controle nativa do robô (angles ou end-effector pose). O MLP proprioceptivo adapta-se à cinemática local sem degradar os pesos pré-treinados no 1 bilhão de frames públicos.

Passo 3: Inicialização do Servidor Assíncrono LeRobot gRPC
Compile o grafo com torch.compile (modo reduce-overhead) em precisão BF16, invoque policy.reset() no início de cada episódio para limpar os 32 registradores e opere o loop de predição de chunks a 45 Hz via canal gRPC de baixa latência.

6. Perguntas Frequentes (FAQ Técnico)

1. Por que os 32 registradores de memória do Kyutai REKI adicionam apenas 0,1 ms de latência?

Porque os registradores são estritamente desacoplados dos tokens de ação e do tempo de integração do Flow Matching. Em vez de reprocessar imagens passadas no backbone VLM de 2,2B ou recalcular os registradores a cada um dos 10 passos de Euler, o REKI calcula os 32 vetores de registradores uma única vez por quadro observado e os armazena em um buffer circular compacto de 2 MiB na VRAM. Durante as 10 iterações da equação diferencial ordinária (ODE), os tokens de ação apenas consultam esses registradores já prontos via atenção cruzada rápida.

2. O que é o fenômeno de Perceptual Aliasing na robótica e como o REKI o corrige?

Perceptual aliasing ocorre quando dois estados distintos do progresso de uma tarefa produzem exatamente a mesma imagem instantânea nas câmeras do robô — por exemplo, quando o braço robótico está pairando sobre uma tigela antes de agarrá-la ou logo após tê-la soltado, ou quando um objeto fica momentaneamente oculto atrás do próprio punho mecânico. Políticas sem memória entram em indecisão cíclica, oscilando entre avançar e recuar (18,6% dos episódios no RoboTwin). Com a janela de 3 frames espaçados em 1 segundo nos registradores, o REKI preserva o histórico causal imediato e reduz as oscilações para apenas 4,1%.

3. Como o Kyutai REKI 2.4B interage com modelos gigantes de fronteira como GPT-6 Astra e Claude Fable 5.1?

Eles operam em camadas complementares dentro da pilha moderna de Physical AI. Modelos fundacionais de fronteira como GPT-6 Astra, Claude Fable 5.1 e DeepSeek 4.1 atuam no Sistema 2 (Planejamento Deliberativo Lento, ~1 a 2 Hz), interpretando instruções complexas de negócios, auditando falhas com agentes de dados (como os 45+ utilitários MCP do Voxel51 Agent) e gerando sub-metas semânticas ("coloque a tigela azul no prato metálico"). O Kyutai REKI 2.4B atua no Sistema 1 (Controle Visuomotor Reflexivo Rápido, 45,8 Hz / 21,8 ms), traduzindo cada sub-meta diretamente em tensores contínuos de velocidade e torque articular.

4. Quais são os termos de licenciamento dos pesos do Kyutai REKI?

Os seis checkpoints oficiais do Kyutai REKI foram disponibilizados abertamente no Hugging Face sob a licença CC BY-NC-SA 4.0 (uso aberto para pesquisa acadêmica, avaliação técnica, reprodutibilidade científica e prototipação não comercial), acompanhados do código-fonte oficial de inferência compatível com o protocolo assíncrono LeRobot.

7. Referências Bibliográficas e Publicações Oficiais

• Kyutai, Inria & École des Ponts (2026). REKI: A 2.4B Vision-Language-Action Model with Efficient Register Memory for Robot Manipulation. Technical Report & Project Page, Paris, Outubro de 2026. Disponível em: https://www.marktechpost.com/2026/10/17/meet-kyutai-reki-the-2-4b-vla-model-bringing-efficient-memory-to-robot-manipulation/.

• Voxel51 Engineering Team (2026). Introducing Voxel51 3.0: The End-to-End Multimodal Data Platform and MCP Agent for Physical AI. Voxel51 Technical Blog, Outubro de 2026. Disponível em: https://voxel51.com/blog/voxel51-3-0-physical-ai-data-platform.

• MarkTechPost AI Research (2026). Meet Voxel51 3.0: A Unified Multimodal Data Platform for Physical AI and Sensor Streams. MarkTechPost Robotics & Physical AI Coverage, 17 de Outubro de 2026. Disponível em: https://www.marktechpost.com/2026/10/17/voxel51-3-0-physical-ai-data-platform/.

• Hugging Face LeRobot Consortium (2026). Asynchronous gRPC Inference Protocol and Flow-Matching Policies for Real-World Robotic Manipulation. Hugging Face Robotics Documentation, 2026.

Publicado originalmente em https://promptx.blog/blog/kyutai-reki-2-4b-vla-memoria-registradores-flow-matching-robotica-2026/ — comentários e atualizações ficam no site.