TinyAstral: Transferring Self-Evolving Harnesses to Tiny Generalist Manipulation Agents

TinyAstral. Transferring Self-Evolving Harnesses to Tiny Generalist Manipulation Agents. By Kehong Gong and ten others, from Huawei Technologies, the Huawei Noah Research Institute, and one other institution. Published on the thirtieth of October.

A robot agent built on a vision-language model is more than its planner. It also depends on the harness around that planner: the tools, the feedback, the memory, and the logic for recovering when something goes wrong. The question here is whether those harness improvements, made around a large teacher, can be carried into a compact agent that costs less compute to run.

TinyAstral answers with two stages that keep the two parts apart. First, hold the model fixed and evolve the harness. Then, hold the harness fixed and shrink the model. Gains won in the first stage are meant to survive the second.

In the first stage an open-weight teacher is frozen, and its harness is improved through recursive self-improvement. Frontier language model agents read the teacher's trajectories and propose edits to the harness. An edit is kept only if it passes a paired statistical test.

In the second stage the final harness is frozen. The teacher runs inside it to collect trajectories that include reasoning and recovery from failure, and a small student is distilled from them. The student then replaces the teacher inside the same harness.

On RoboTwin, evolving the harness raises the teacher's success rate from thirty-three point four percent to sixty-three point six percent. The final four billion parameter student reaches sixty-two point eight percent. Across four harness versions, the distilled students land close to their matching teachers, and later versions give stronger students. That is the transfer claim in numbers: harness gains carry into compact models. The same gains also carry over to other frozen planners without retraining.

On identical episodes, the final student beats open agents of the same four billion parameter size. It also beats the open twenty-seven billion parameter model SenseNova-RoboRSI, which also improves its harness by recursive self-improvement, and it beats the authors' own teacher when that teacher is placed in three competitors' harnesses. It stays close to its teacher on all three training benchmarks. On three further benchmarks never used for self-improvement or training, it scores close to a five hundred and fifty-two billion parameter planner running the same harness.

Cost is the point of going small, and on the measured deployment episodes the student uses about one fifth of its teacher's accelerator time.

The comparison that carries the argument is the teacher dropped into other harnesses and losing to its own student, which keeps the evolved harness. Improvements made around a large model, it shows, can be inherited by a far smaller one. Separating harness and model lets each be improved on its own terms: the harness by automated edits under a statistical test, the model by distillation.

TinyAstral. Transferring Self-Evolving Harnesses to Tiny Generalist Manipulation Agents. By Kehong Gong and ten others, from Huawei Technologies, the Huawei Noah Research Institute, and one other institution. Published on the thirtieth of October. This is the long version: the whole paper rather than the abstract.

A robot agent built on a vision-language model is two things at once. There is the planner, which decides which object to pick, which arm to use, and when the job is done. And there is the harness around it: the tools, the feedback they return, the task memory, and the recovery logic. Work that evolves the harness tends to wrap a large frozen model, expensive to run on every step. Work that distills small agents copies a strong agent's trajectories, but does nothing to improve the system being copied. The question here, from a team at Huawei, is whether the two can be chained: first improve a big teacher's harness, then carry that improvement into a model small enough to run on one accelerator.

Two definitions carry everything that follows. The harness decides how an action happens: segmentation, grasp geometry, collision-free motion planning. The planner decides what to do. Each turn it reads camera images, the instruction and the last tool result, writes its reasoning, and makes exactly one tool call. Then there is how success is counted. The agent must end the episode itself by calling done, naming the conditions it believes hold. The harness checks them with cameras and gripper sensors, and if a check fails it rejects the call and returns the measurement. The benchmark's success flag never enters the model's input. Strict success counts an episode only if the agent declared done and the task really holds in the final state.

Stage one evolves the harness while the teacher, Qwen3.8-Flash-Next, stays frozen. Humans write the rules, the budget and the acceptance criteria in advance. Then a master, a set of frontier language-model agents, reads the teacher's logged images, tool calls and reasoning, and sorts each failure into one of ten classes, such as off-target placement or false completion. For a cluster of failing tasks it writes candidate fixes: new tools, perception fixes, failure handling, and what the authors call more honest tool returns. Tools report what they measured rather than what they intended, so a placement re-measures the object after release and reports the offset if it missed.

The constraints are strict. Code may not branch on the task name. Every new component must fire through an explicit trigger that writes a marker to the log, and a code audit verifies that when the trigger does not fire, the candidate behaves step for step like its parent. Candidate and parent then run interleaved on about eleven hundred and fifty pre-registered task and seed pairs. A candidate is accepted only if a task-clustered bootstrap puts the lower bound of its gain on the targeted and triggered pairs above zero, and vetoed if the untouched pairs regress by two points or more. Of two hundred and ninety-six candidate capabilities, a hundred and forty-two were rejected.

Stage two freezes the final harness. The teacher collects trajectories, kept only on strict success, and each training target is its stated reasoning followed by its tool call. Because successful episodes rarely show recovery, the authors replay part of a successful episode, inject a slip, a missed grasp or a moved object, and let the teacher continue. Offline real-robot data is converted into the same format. The resulting decision samples fine-tune Qwen3.5-4B, which replaces the teacher inside the same harness.

Harness evolution lifts the frozen teacher on RoboTwin from thirty-three point four percent to sixty-three point six, and the final four billion parameter student reaches sixty-two point eight. The comparison that tests the thesis is different. A separate student was trained at each of four harness snapshots, with the same recipe. They score thirty-six point two, forty-nine point eight, sixty, and sixty-two point eight, each within about a point of its own teacher. Better harness, better student. The evolved harness also lifts DeepSeek-V4.1-Flash, never used during evolution, by thirty point six points, and in the final harness the untrained small model reaches only forty-one point two, so distillation adds real value on top.

Stripping the teacher's reasoning from the training targets costs nineteen point three points on LIBERO-PRO, and forty-nine of three hundred episodes then run out of tool calls, against seven with reasoning kept. The real-robot data makes no detectable difference to simulated success; its benefit is in offline next-call accuracy on real images. On three benchmarks never used in training, the student lands within two point four points of the much larger DeepSeek planner in the same harness, and uses about one fifth of the teacher's accelerator time per episode.

The paper has no limitations section. Several limits are visible in what it reports. RoboTwin is both the development benchmark for evolution and the headline result: evaluation seeds are disjoint, but the harness was shaped on those tasks, and only RoboTwin gets per-task end-state notes. Results are single runs, reported without error bars. The compute claim rests on twenty SimplerEnv episodes. The real-robot evidence is a set of closed-loop examples on an SO-ARM101 arm, not success rates. The smallest student falls to fifty-four point seven on LIBERO-PRO, against seventy-eight point three. And the authors show a failure of self-judgment: a shoe off target, the student's own checks pass, and the simulator disagrees.

The idea to carry away is that a harness can teach. Improvements made around a frozen model, accepted only under pre-registered tests, do not stay locked inside it. They show up in its trajectories, and a small model trained on them inherits them almost point for point. The harness reports honest measurements, and the student learns to reason about them.