🤖 AI

CoTinyVLA: Chain-of-Thought Distillation for a Sub-Billion-Parameter Vision-Language-Action Model

CoTinyVLA is a sub-billion-parameter Vision-Language-Action model that achieves state-of-the-art robustness on the LIBERO-Plus benchmark by leveraging structured supervision techniques—including dual-view temporal inputs, hierarchical chain-of-thought distillation, and paraphrase augmentation—rather than increasing model size.

Original authors: Minhyeok Lee, Chiyoung Kim, Chanhoe Gu, Seongrok Kim, Sanghyuk Roy Choi, Donghwan Hwang, Donghun Ryu, Seokhyun Kim

Published 2026-07-29

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Minhyeok Lee, Chiyoung Kim, Chanhoe Gu, Seongrok Kim, Sanghyuk Roy Choi, Donghwan Hwang, Donghun Ryu, Seokhyun Kim

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where robots aren't just mindless machines following rigid code, but helpful companions that understand our spoken words and can figure out how to move their own arms to get things done. This is the dream of "embodied AI," a field where computers learn to see the world through cameras, understand human language, and translate those two things into physical actions. For a long time, the smartest robots needed massive brains—computer models with billions of "neurons"—to handle this. These giant models were like supercomputers that needed huge, expensive servers to run, making them impossible to fit inside a small robot that could roll around a house or help in a kitchen. The big question researchers have been asking is: Can we make a robot that is just as smart and reliable, but small enough to fit in a backpack?

This paper introduces a new robot brain called CoTinyVLA. Think of it as a tiny, super-efficient robot brain that manages to outperform the massive, heavy-duty models currently leading the field, all while using only a fraction of the memory. The researchers didn't just shrink the brain; they taught it a better way to think. Instead of trying to memorize every possible situation, they gave the robot a "cheat sheet" for reasoning. They taught it to break down a big task into a simple plan (like a to-do list) and then think through each small step before moving. They also gave it a special pair of eyes—one looking from far away to see the whole room, and one on its wrist to see exactly what its hand is touching—and taught it to watch a short video of the last few seconds to understand motion. The result is a robot model with only 0.9 billion parameters (tiny compared to the 7-billion-parameter giants) that can handle tricky, messy real-world situations better than models eight times its size.

The Problem: Big Brains, Small Robots

For years, the best robots for following instructions have been like giant, heavy tanks. To understand a command like "pick up the blue cup and put it on the table," these robots use massive computer models with 3 to 7 billion parameters. While these models are incredibly smart, they are also huge. They require about 20 gigabytes of computer memory just to run. That's like trying to fit a full library into a backpack; it simply doesn't fit on the small, battery-powered computers found on mobile robots or assistive devices.

The researchers wanted to know: Do we really need such a giant brain to be smart? Or can we build a tiny, efficient robot that is just as good at handling the unexpected messiness of the real world?

The Solution: A Tiny Brain with a Big Strategy

The team built CoTinyVLA, a robot brain with only 0.9 billion parameters. To make this tiny model as strong as the giants, they didn't just feed it more data; they changed how it learned and what it paid attention to. They used three main tricks, which they call "structured supervision," to teach the robot to think better.

1. The "Two-Eye" Time Machine
Imagine trying to catch a ball. If you only see one picture of the ball, you don't know if it's coming toward you or moving away. You need to see a short video to understand the motion.
CoTinyVLA is taught to look at the world through two different "eyes" at the same time:

The Third-Person Eye: A camera looking at the whole room to see where everything is.
The Wrist Eye: A camera on the robot's hand to see exactly what the gripper is touching.
Instead of just looking at the current moment, the robot watches a short "movie" of the last 16 frames (8 from each eye). This gives it a sense of time and motion, helping it understand how fast things are moving and where they are going.

2. The "Plan and Think" Cheat Sheet
This is the most important trick. Before the robot moves, it is taught to write down a story.

The Plan: At the start of a task, the robot writes a high-level "to-do list" (e.g., "First, grab the cup. Second, lift it. Third, put it on the table"). This plan stays the same for the whole task.
The Think: Before every small movement, the robot writes a quick note about what it's doing right now (e.g., "I am closing my gripper," or "I am lifting the cup").
The robot learns this by watching a much bigger, smarter robot (a 35-billion-parameter "teacher") solve the same tasks. The tiny robot copies the teacher's thinking process. This helps the tiny robot understand why it is doing something, not just what to do.

3. The "Paraphrase" Game
Robots often get confused if you say the same thing in a different way. If a robot is trained only on the phrase "pick up the cup," it might get stuck if you say "grab the mug."
To fix this, the researchers taught the robot with 40 basic instructions but expanded them into 800 different versions. They swapped words (like changing "pick" to "grab" or "lift"), changed the objects' descriptions (like "black bowl" to "dark bowl"), and even added polite phrases like "Could you please...". This taught the robot to understand the meaning of the command, not just the specific words.

The Results: Tiny Wins Big

The researchers tested CoTinyVLA on LIBERO-Plus, a tough test suite designed to see how well robots handle changes in the world. The test includes over 10,000 different scenarios where things are messed up: the robot starts in a weird position, the lighting changes, the background is different, or the instructions are phrased strangely.

The results were surprising. CoTinyVLA, with its tiny 0.9 billion parameters, beat the strongest 7-billion-parameter models on all four major test categories:

Spatial: 90.8% success (beating the big models by 4.7 points).
Object: 87.3% success (beating the big models by 2.8 points).
Goal: 86.6% success (beating the big models by a huge 15.9 points).
Long: 80.7% success (beating the big models by 3.0 points).

The biggest win was on the "Goal" category, where the tiny robot was nearly 16 points better than the best giant robot. This is especially impressive because the tiny robot runs on a computer that uses only 2.25 GiB of memory, which is small enough to fit on many real-world robots.

Why It Matters

The paper shows that you don't need a massive brain to be a smart robot. By teaching a small robot to "think" in a structured way (making plans and checking its steps) and by giving it the right kind of visual and language training, it can handle the messy, unpredictable real world better than much larger models.

The researchers also found that the "Plan" part of the thinking process is crucial. If you take away the robot's ability to write a plan, its success rate drops by 40 to 45 points. This proves that the robot isn't just guessing; it's actually using the plan to guide its actions.

In short, CoTinyVLA proves that with the right teaching methods, a small, efficient robot can be just as capable as a giant supercomputer, bringing us one step closer to having helpful, intelligent robots in our homes and workplaces.

Technical Summary: CoTinyVLA

Problem Statement

Vision-Language-Action (VLA) models have emerged as a unified interface for translating natural language into robot control. However, state-of-the-art systems achieving high robustness on the LIBERO-Plus benchmark typically rely on backbones with 3 to 7 billion parameters. These models demand significant memory resources (often exceeding 20 GiB in bfloat16), making them incompatible with the strict memory budgets of embedded robotic platforms such as mobile manipulators and humanoids.

The central challenge addressed by this work is whether a compact model (sub-billion parameters) can achieve the same level of robustness as larger systems. Specifically, the authors investigate whether structured supervision—rather than sheer scale—can provide the necessary robustness against visual, kinematic, and linguistic perturbations.

Methodology: CoTinyVLA

The authors present CoTinyVLA, a 0.9B-parameter VLA built on a Qwen3.5-0.8B backbone. The model achieves robustness through three distinct components, each targeting a specific axis of the robustness problem:

1. Dual-View Temporal Input

Instead of a single static image, the model receives a temporal history at each control step:

Inputs: Eight third-person frames and eight wrist-camera frames (16 total), prefixed with explicit textual markers (e.g., [Third frame i]).
Proprioception: An 8-dimensional vector (end-effector pose + gripper joints) projected as a soft token.
Rationale: This provides explicit temporal and multi-view context, allowing the compact backbone to infer motion, approach velocity, and gripper-object contact without relying on implicit positional embeddings.

2. Hierarchical Chain-of-Thought (CoT) Distillation

A 35B-parameter vision-language teacher (Qwen3.5-35B) generates structured reasoning traces for a 0.9B student. The reasoning is split into two levels:

Episode-Level Plan: Generated once per episode, decomposing the instruction into an ordered list of natural language subgoals.
Chunk-Level Think: Generated for every action chunk, constrained to a fixed three-slot schema:
- Phase: Current subaction step (aligned with the Plan).
- Gripper: Discrete state (OPEN, CLOSED, PARTIALLY_CLOSED), derived from proprioception to avoid visual ambiguity.
- Next: Short description of the immediate action.
Training Objective: A weighted sum of action regression loss and language model cross-entropy over reasoning tokens ( $\alpha=1.0, \beta=0.1$ ). The reasoning span acts as an auxiliary structured prediction objective that conditions the action head without adding inference-time parameters.

3. Paraphrase-Based Instruction Augmentation

To prevent overfitting to the 40 base instructions in the training set:

Expansion: Each base instruction is expanded into 20 paraphrases (800 total variants) via verb substitution, object synonym replacement, and politeness variation.
Training Strategy: During training, the instruction is replaced with a paraphrase with probability 0.8. This specifically targets robustness to the Language Instructions perturbation axis.

Key Contributions

Performance with Compact Scale: CoTinyVLA (0.9B) exceeds the strongest 7B baselines on all four LIBERO-Plus suites (Spatial, Object, Goal, Long) by margins ranging from 2.8 to 15.9 points, operating within a 2.25 GiB inference memory footprint.
Two-Level Reasoning Schema: The authors demonstrate that the episode-level Plan is "load-bearing." Test-time interventions show that replacing the Plan with an empty or contradictory span causes a 40–45 point drop in success. Furthermore, caching the Plan across an episode halves the steady-state inference cost.
Decomposition of Robustness: Through controlled ablations, the paper attributes specific components to specific perturbation axes:
- Paraphrase Augmentation: Primarily improves robustness to linguistic variation (+12.3 points on Language Instructions axis).
- Hierarchical CoT: Primarily aids physical-state perturbations (Robot Initial States, Objects Layout).
- Input Structure: The allocation of a fixed image budget across cameras and time is a design variable worth 8.6 points in total score.

Experimental Results

The model was evaluated on LIBERO-Plus, which perturbs 40 base tasks across seven dimensions (Camera, Robot Initial States, Language, Light, Background, Noise, Layout) with 10,030 total perturbed tasks.

Overall Performance: CoTinyVLA achieves 90.8% (Spatial), 87.3% (Object), 86.6% (Goal), and 80.7% (Long).
Comparison to 7B Baselines: It leads the strongest 7B baseline (OpenVLA-OFT+) by 4.7, 2.8, 15.9, and 3.0 points respectively. Crucially, the confidence intervals for these differences exclude zero.
Hard Axes: The model shows the largest gains where baselines are weakest. On the Goal suite, the strongest baseline scores only 39.9% on Robot Initial States, whereas CoTinyVLA reaches 73.6%.
Standard LIBERO: On the unperturbed benchmark, CoTinyVLA averages 97.5%, matching the strongest 7B baseline (RIPT-VLA) and outperforming other sub-1B models.
Inference Efficiency: Closed-loop inference peaks at 2.25 GiB of GPU memory. The dominant cost is autoregressive generation (76% of steady-state time), which can be halved by caching the episode Plan.

Significance and Claims

The paper claims that the robustness usually attributed to 3–7B parameter backbones does not require them. Instead, structuring supervision along the axes the benchmark perturbs is sufficient to exceed larger systems.

Design Levers: The work establishes that input structure (how frames are divided between cameras and time) and reasoning hierarchy are independent design variables that can be optimized for compact models.
Limitations: The authors note that the evaluation is limited to simulation (Franka Panda) and a single embodiment. Sim-to-real transfer and performance on longer horizons (where the Long suite score is lowest at 80.7%) remain challenges. Additionally, the method relies on a strong 35B teacher for distillation, and the semantic equivalence of the generated paraphrases was not exhaustively verified beyond lexical statistics.

In conclusion, CoTinyVLA demonstrates that a 0.9B model can outperform systems eight times its size across all four robustness suites, provided that the training signal is structured to address temporal, reasoning, and linguistic variations explicitly.