Kyutai releases REKI, a 2.4B robot model with a built-in short-term memory

What Kyutai released

Kyutai, the Paris AI lab best known for its speech models, released REKI on 16 October 2026. It is a vision-language-action model, or VLA: a single network that looks at camera images, reads a typed instruction such as "put the bowl on the plate" and outputs the motor commands a robot arm should follow next. Kyutai built it with Inria and École des Ponts, and the paper lists Juliette Marrie, Paul Pacaud, Adrien Ramanana Rahary, Shizhe Chen and Moritz Böhle as authors.

REKI has 2.4 billion parameters, small for a modern robot model. Kyutai's announcement on X says it was "pretrained on public data only" and that "it rivals larger models trained on in-house data with complex multi-stage pipelines." The project page makes the claim more precise: on the three out-of-distribution benchmarks Kyutai reports, REKI is beaten only by models about twice its size.

The release is not just a paper. The weights are on Hugging Face, starting with the pretrained reki-2b checkpoint, and the training, evaluation and deployment code is on GitHub. The code is MIT-licensed. The weights use CC BY-NC-SA 4.0, which allows research and personal use but not commercial use, and any derivative has to carry the same licence.

The headline feature is memory. Most robot models of this kind decide each move from the current camera frame alone. REKI keeps a compact summary of its last few frames, and Kyutai says that memory costs almost nothing to run.

How the memory works

REKI has two parts. A Qwen3.5-2B vision-language model, about 2.2 billion parameters, encodes the camera views and the instruction. A separate 200-million-parameter action expert then generates a one-second chunk of robot actions. It uses flow matching, a generative technique that turns random noise into a trajectory over ten small refinement steps. Robot state, such as joint angles, enters the expert through adaptive normalisation layers, and each robot body type gets its own small input network.

The memory lives in the action expert, not in the language model. Before the action tokens of each frame, the expert holds 32 learned "register" tokens. Those registers read the encoded image and instruction for that frame and also read the registers of earlier frames. They never read the action tokens. As a result, they depend only on what the robot saw, so they can be computed once per frame and stored in a cache.

At inference, REKI keeps registers for a rolling window. The released models are trained on windows of three frames taken one second apart, so the policy sees the current moment plus summaries of the previous two seconds. When a new frame arrives, the oldest frame's registers are dropped.

Kyutai contrasts this with three common ways of giving a robot model memory: feeding past frames back into the vision-language model, keeping a recurrent state that has to be unrolled during training, or bolting on a separate memory module. Each adds compute. REKI reuses the self-attention the expert already has. Other labs have been adding memory by other routes, such as NEURA Robotics with Neuron AI, which shows how much attention this problem is getting.

The memory addresses a specific failure Kyutai documents. Without it, the policy often gets stuck moving an arm back and forth between two poses, changing direction at each new chunk. Kyutai attributes this to perceptual aliasing: if two positions each look like the start of a demonstration heading towards the other, a policy with no history keeps flipping between them. On RoboTwin, the share of oscillating episodes fell from 18.6% without memory to 4.1% with it. Kyutai says the gap is largest on two-arm tasks.

Benchmark results and how to read them

Kyutai pretrains REKI once and then finetunes a separate copy for each benchmark. All of the scores below are Kyutai's reported success rates on simulated benchmarks. AI Lookout did not run them.

On LIBERO-Plus, which perturbs the 40 LIBERO tasks along seven axes such as camera angle, lighting, language and object layout, REKI scores 90.4% over 10,030 perturbed episodes. That is the top score in Kyutai's comparison, ahead of Qwen-RobotManip at 89.0% and π0.5 at 85.7%. Its weakest axis is the robot's starting position, at 75.6%. On the original four LIBERO suites it reaches 97.6%.

On RoboTwin Clean2Rand, where a two-arm model is finetuned only on clean scenes and then tested with randomised backgrounds, lighting, clutter and table height, REKI averages 65.8%. Qwen-RobotManip scores 68.5%, and Kyutai counts it at 4.7 billion parameters. REKI falls to 57.8% under clutter and 48.7% when all four randomisations are combined.

RoboCasa365 is the hardest test in the set. REKI scores 38.4% across 50 kitchen target tasks, ahead of RLDX-1 at 36.0% and Qwen-RobotManip at 35.9%, both of which Kyutai says were pretrained on in-house data. It sits well behind Xiaomi-Robotics-1 at 57.4% and ABot-M0.5 at 40.4%, the latter a world-action model rather than a VLA.

Kyutai also measures what each ingredient adds. Memory raises success by 1.5 points on LIBERO-Plus, 5.5 on RoboTwin clean scenes and 5.4 on RoboCasa365. Pretraining helps most out of distribution: it adds 13.8 points on Clean2Rand, including 30.3 under clutter, and 4.3 on LIBERO-Plus. Removing past frames at test time brings a memory-trained model back to memoryless performance, which suggests the gain does come from reading the past.

Speed and training cost

Kyutai reports that, with compilation, REKI predicts an action chunk in 21.8 milliseconds on one NVIDIA H100 from two 256 by 256 camera images. Reading the cached registers adds 0.1 milliseconds, under 1% of that time, and the cache uses about 2 MiB of GPU memory per past frame.

Kyutai timed other open models on the same hardware and inputs, compiling those that shipped without a compiled path. By its measurements, X-VLA takes 25.5 milliseconds, π0.5 through the openpi code 33.8, ABot-M0 46.1 and InternVLA-A1.5 51.3. These are Kyutai's runs of other teams' code, not figures from those teams.

Training is also modest by current standards. Pretraining ran for 200,000 steps on 32 H100 GPUs. The released finetuning recipes use one eight-GPU node for LIBERO and RoboTwin clean scenes, three nodes for the mixed RoboTwin run and four for RoboCasa365. For the real-robot demo, Kyutai finetuned REKI on a UR5 arm for 3,000 steps, about an hour, using 50 demonstrations per task. Kyutai says memory helped most on longer, multi-step tasks there too, but it did not publish a success-rate table for those tests.

How to use REKI

Five checkpoints are public in the REKI collection on Hugging Face: the pretrained base model plus finetunes for LIBERO on a Franka Panda arm, two RoboTwin variants on a bimanual ALOHA setup, and RoboCasa365 on a mobile PandaOmron. The project page also lists a sixth finetune for the Fourier GR-1 humanoid, but that checkpoint was not publicly reachable when AI Lookout checked on 17 October. The pretrained model is meant for finetuning, not for direct use.

The code needs Linux, an NVIDIA GPU with CUDA 12 and the pixi package manager. A short Python call loads a finetuned policy, takes camera images, the robot's state vector and a text instruction, and returns a chunk of actions. Kyutai says to call it once per second for the released models, matching the one-second stride used in training, and to reset it at the start of each episode so the memory starts empty.

For real robots, the repository includes a policy server that speaks Hugging Face's LeRobot async-inference protocol, and a LeRobot plugin runs the finetuned models in LeRobot's tools. The README carries a clear security warning: the protocol unpickles client messages, so "anyone who reaches the port can run code on the machine." The server binds to localhost by default, and Kyutai advises an SSH tunnel or a trusted network.

Teams that want a hosted route instead of running their own GPUs have other options, such as Physical Intelligence's Pi API beta for its π models. REKI is aimed at labs that want to own the whole stack and inspect it.

Why public data matters here

Kyutai's argument is about reproducibility. Many of the strongest robot models are pretrained partly on data their makers collected in-house and never released, so outside researchers cannot rebuild them or tell how much of a result comes from the data. REKI's pretraining mix is built entirely from public sets.

That mix holds about one billion frames. Real-robot teleoperation makes up 639.8 million frames, from sources including DROID, BridgeData V2, AgiBot World, RoboMIND and part of Open X-Embodiment. Simulation adds 193.9 million frames, and egocentric human video from EgoDex, EgoVerse and Xperience adds 170.9 million. Another 12.2 million vision-language samples teach spatial reasoning. Kyutai filters every source and keeps each dataset's own control convention instead of forcing all robots into one shared action format. The data covers 14 robot state layouts, from single arms to mobile manipulators and humanoids.

Human video is a growing ingredient across the field. Nature Will's Natura-1 leans on it heavily for robot hands, at a much larger 50 billion parameters. REKI is a data point that a far smaller model can stay competitive when the data is curated carefully.

Limitations and open questions

The benchmark gains are real but bounded. Every headline number comes from simulation, and each score uses a model finetuned for that benchmark. The 38.4% on RoboCasa365 is a reminder of how far general household manipulation still has to go, even for the better models in Kyutai's comparison.

Kyutai's own model card lists three limitations. A robot with a new state layout needs a new input layer trained from scratch. The replanning interval at inference must match the training stride, or the stored frames fall out of distribution. And the policy reflects its demonstrations, which are mostly tabletop tasks with parallel-jaw grippers, so Kyutai says to expect weaker behaviour on other tasks or hands without finetuning.

The memory is also short. Three frames one second apart covers about two seconds of history. That is enough to break the back-and-forth loops Kyutai measured, but not to remember where an object was hidden a minute ago. Evaluations that put models on real hardware, such as Artificial Analysis's AA-Robotics test, show how quickly simulated scores can diverge from physical results.

Two parts of the stack are not out yet. The README says the pretraining code and data pipeline will come "in a later update," though the full pretraining recipe is published as a config file. Until then, outside groups can finetune and evaluate REKI but cannot rerun its pretraining end to end, and the non-commercial licence keeps the weights out of products.