English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

RoboICL: One Demonstration Is All a Frozen GPT-6 Astra Needs to Learn a Robot Task

Forum topic · QianXun · 2026-10-02

Summary

RoboICL (arXiv:2609.34261) is a training-free in-context learning framework for dual-arm robot manipulation built on the frozen GPT-6 Astra model. Instead of collecting data and fine-tuning a policy or VLA model, it formats expert demonstrations and the robot's own rollout history into a unified context grammar (observation, action, execution receipt, new observation), then has the frozen model output the next bimanual action chunk. On three real-robot tasks, average progress scores jump from 14.45 zero-shot to 63.33 with one demonstration and 78.89 with three. Across 30 RoboDojo tasks it scores 50.64 versus 39.56 for the strongest baseline PhysicalRSI and 33.68 for the official zero-shot baseline. A bounded anchor memory and an ablation over the demonstration-vs-memory context budget (J + B = 24, best at 12/12) are key design elements. The project page releases 929 playable execution records with synchronized three-camera videos. The paper is an arXiv preprint with limited real-robot evaluation and no reported inference latency or token costs.

The default robotics pipeline—collect data, train a policy, deploy—costs money at every step. RoboICL (arXiv:2609.34261) takes a different route: it trains no robot-specific parameters and no VLA model. It simply organizes *one demonstration* plus *what the robot just did itself* into model-readable context, and lets a frozen GPT-6 Astra output the next bimanual action chunk directly.

Three numbers tell the story:

| Setting | Avg. progress score, 3 real-robot tasks | |---|---| | Zero-shot | 14.45 | | One demonstration | 63.33 | | Three demonstrations | 78.89 |

Same model, same tasks, weights untouched. The only difference is what sits in the context.

Demonstrations and memory are two different things

RoboICL splits the model's input into two streams, and this is the backbone of the design:

  • Demonstration context: non-overlapping action chunks sampled from expert trajectories. Fixed per episode.
  • Interaction memory: the robot's own rollout history for the current episode, updated after every executed action chunk.
Both streams share one grammar: observation → action → execution receipt → new observation. The receipt is easy to overlook—it records how much of the commanded action the controller actually executed, which suffixes were dropped, whether the controller interrupted. With it, the model knows the gap between what it *wanted* and what *happened*, and won't reason from stale state.

Bounded anchor memory: where the saved context goes

Long-horizon tasks face an unavoidable tension: context windows are finite, so by step 80 the state from step 3 has been pushed out—yet step 3 may be exactly what step 80 needs.

RoboICL's answer is bounded anchor memory. The window always keeps three things: the very first interaction, several anchors spread evenly along the timeline, and the most recent completed interaction. Omitted spans are not left blank—an explicit placeholder marker is inserted so the model doesn't treat the two flanking frames as contiguous time.

The hard part is allocating a fixed budget: J + B = 24, with J for demonstration chunks and B for online memory. Ablation on four tasks:

| Demonstration chunks J | Online memory B | Progress score | |---|---|---| | 8 | 16 | 57.50 | | 12 | 12 | 80.25 | | 16 | 8 | 80.00 | | 22 | 2 | 60.75 |

Neither side can be starved. Demonstrations without online memory drop to 57.50; online memory without demonstrations drops to 60.75; the middle 80.25 is the main-experiment config. This is the most practical table in the paper: the context budget is zero-sum, and tilting it one way costs points.

The 30-task report card

RoboDojo is a unified simulation-plus-real benchmark: 30 bimanual manipulation tasks in four categories. The Open category uses no task-specific demonstrations (zero-shot); the other three get one demonstration each.

RoboICL beats the official zero-shot GPT-6 Astra by 20–27 progress points in every category. Overall it scores 50.64, versus 39.56 for the strongest baseline PhysicalRSI and 33.68 for the official zero-shot. It ranks first in Memory and Open, ties the strongest baseline in Precision, and stays competitive in Long-Horizon.

One easily misread detail: the Open category is zero-shot—no task-specific demonstrations—yet scores 54.75, far above the zero-shot baseline. Organizing the robot's own online experience alone yields gains; demonstrations just add more when they're available.

On a ten-task subset, RoboICL scores 60.60, within 2.00 points of the π0.5 + GPT-6 Astra hybrid. On development tasks, an optional Jev-gated action reuse mechanism cuts GPT-6 Astra calls by 33% to 48%.

What the project page releases

This deserves its own section. The project page publishes 929 playable execution records—880 fully evaluated plus 49 partially completed—covering all 30 tasks and their 50 layouts. Each record includes synchronized three-view video (left wrist, head, right wrist), official scores and the evaluation protocol, and GPT-6 Astra's step-by-step execution rationale, aligned with playback.

The number 929 isn't padding: third parties can audit failure modes, recovery behavior, and whether zero-score trajectories contain latent capability, layout by layout. Releasing executable trajectories is uncommon for a benchmark paper.

Caveats

The paper is an arXiv preprint, submitted September 28, 2026, with code on GitHub at Mosi-AI/RoboICL. The progress score is RoboDojo's native staged metric (0–100), not a plain success rate—check definitions before cross-paper comparisons. Three real-robot tasks is a small sample. The Jev-gated action reuse was tested on two development tasks and is flagged as optional by the authors. The 4:1 to 2:1 demonstration-to-memory ratio comes from ablations on four tasks; stability on other task suites is not verified.

This work turns "show the robot once" from a demo trick into a measurable mechanistic path. The trade-off is that every decision requires re-feeding context to the model—a cost structure completely different from a small VLA. The paper reports no inference latency or token costs; that is probably the first bill this approach has to pay on the road to real deployment.

Sources: arXiv:2609.34261 (submitted 2026-09-28); ablation numbers and the 929 records from the project page and BestHub's breakdown; RoboDojo baseline scores from the official RoboProbe report.

Tags

#robotics#in-context-learning#gpt-6-astra#roboicL#dual-arm-manipulation#robodojo#vla#zero-shot-learning

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178635484