Kyutai opens REKI, a 2.4B robot policy with cached memory

Kyutai has released REKI, a 2.4-billion-parameter vision-language-action model trained exclusively on public datasets. A VLA converts camera images, natural-language instructions, and robot state into executable actions. Kyutai reports that REKI matches or exceeds several models around twice its size, including systems pretrained on proprietary robot data.

Kyutai has published the full stack through its source repository, including data curation, training, inference, evaluation, deployment code, and pretrained and finetuned weights. The central design change places temporal memory inside the action head, adding little latency while reducing repeated motion failures.

Public data, compact footprint

Across LIBERO-Plus, RoboTwin Clean2Rand, and RoboCasa365, Kyutai reports that models outperforming REKI are generally around twice its size. The company describes this as a stronger tradeoff between model size and benchmark performance.

LIBERO-Plus tests robustness under changes to camera angle, lighting, language, background, and layout. RoboTwin Clean2Rand shifts simulated scenes from clean training conditions to randomized environments, while RoboCasa365 evaluates household manipulation tasks. The published numbers come from Kyutai’s evaluations and await independent reproduction.

Memory moves into the action head

Many VLAs provide temporal context by sending previous frames through the vision-language backbone, recurrently unrolling the model during training, or adding a separate memory network. Those approaches increase training cost, inference latency, or both.

REKI assigns 32 learned register tokens to each frame and places them before the action tokens. The registers cross-attend to the vision-language model’s output and self-attend to registers from earlier frames. They cannot attend to action tokens, so their keys and values remain independent of the generated action sequence and can be cached.

Each camera frame therefore passes through the vision-language backbone once. REKI computes the frame’s memory during the first action-refinement step, then reuses the cached registers during later steps and subsequent frames. The registers also remain independent of flow time and robot state.

Measured cache overhead

• Latency: With a three-frame context and two 256-by-256 camera inputs, REKI predicts an action chunk in 21.8 milliseconds on one H100. Reading cached registers adds 0.1 milliseconds.
• Memory: Each cached past frame consumes about 2 MiB of GPU memory.
• Computation: Register memory is calculated once per frame during the first refinement step.

Fewer loops on long tasks

A memoryless policy can alternate between two visually similar poses when each observation resembles demonstrations that proceed toward the other pose. Kyutai attributes this back-and-forth behavior to perceptual aliasing, where distinct points in a task appear similar to the policy.

RoboTwin episodes containing these oscillations fell from 18.6% without memory to 4.1% with REKI’s register cache. The reduction was largest in two-arm tasks, where coordination depends more heavily on recent motion history.

Kyutai also finetuned REKI on a physical UR5 arm using 50 demonstrations per task. Training took about one hour on a single node, and the memory mechanism produced its largest gains on longer, multistep tasks.

Two-part model, one batched pass

REKI pairs a Qwen3.5-2B vision-language backbone with a 200-million-parameter flow-matching action expert. Every action-expert block cross-attends to the visual and language context. Adaptive RMSNorm injects the robot’s current state and the flow timestep into the network.

Flow matching trains the action expert to transform noise into a coherent sequence of robot commands. During inference, the expert iteratively refines that sequence into an action chunk, allowing the robot to execute several related commands from one prediction.

Training uses windows of three frames sampled one second apart. All three are packed into one batched operation, allowing a single vision-language forward pass to process the temporal window.

Single-H100 latency

Public pretraining, source-native controls

Pretraining ran for 200,000 steps on 32 H100 GPUs using three categories of public data:

• Robot teleoperation: RoboSet, Galaxea, AgiBot World, RoboCOIN, RoboMIND, RDT-1B, DROID, BridgeData V2, RT-1, BC-Z, and motion-planned simulation data.
• Egocentric human manipulation: EgoDex, EgoVerse, and Xperience, totaling roughly 350,000 episodes and 170 million frames.
• Vision-language data: Curated FineVision and LLaVA-OneVision-1.5 subsets for spatial reasoning, plus RoboPoint, RefSpatial, and PixMo. This category was capped at 10% of sampled frames.

REKI preserves each dataset’s native action convention during pretraining. This avoids forcing robot platforms with different joints, grippers, and control schemes into one shared action representation.

Ablations reported by Kyutai show that pretraining improved out-of-distribution performance by 13.8 points on RoboTwin Clean2Rand, including 30.3 points in cluttered scenes, and by 4.3 points on LIBERO-Plus.

Code, weights, and a small API

The release provides a base pretrained checkpoint and finetuned variants for LIBERO, RoboTwin Clean2Rand, RoboCasa365, and a Fourier GR-1 humanoid tabletop setup. Available embodiments include Franka Panda, bimanual ALOHA, mobile PandaOmron, and the GR-1 humanoid. The weights are hosted in a Hugging Face collection.

The published Python interface loads a checkpoint, clears temporal memory between episodes, and predicts an action chunk from images, proprioceptive state, and a task instruction:

from reki import RekiPolicy

policy = RekiPolicy.from_pretrained(
    "kyutai/reki-2b-libero",
    device="cuda",
)

policy.reset()  # Clear the register cache at each episode.

actions = policy.predict(
    images={
        "camera_top": img0,
        "camera_wrist_left": img1,
    },
    state=proprio,
    task="put the bowl on the plate",
)

An inspectable baseline for robot learning

REKI gives developers a complete path from public training data to deployment code. Its reported 21.8-millisecond latency corresponds to roughly 46 action-chunk predictions per second on a single H100, and its cached memory adds little compute or GPU storage.

Kyutai produced the benchmark and latency results, so independent replications will determine how consistently they transfer across hardware, tasks, and training setups. The accompanying paper, code, data pipeline, and weights expose the components required for those tests and for embodiment-specific finetuning.