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.
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.