RoboScript: Can In-Context Learning Beat Robot Manipulation Policies?. World In-Context Learning for Agentic Robot Manipulation • Heng Fang et al. • Huazhong University of Science and Technology; ArcheOne AI • arXiv preprint • 2026. Cold Open. Imagine showing a dual-arm robot how to place a phone in its stand. On the next attempt, the phone starts across the table. The recorded right-arm trajectory is now the wrong answer, even though the task is unchanged. What should survive that change? The useful knowledge concerns the phone’s role, how to grasp and orient it, and what successful placement looks like. A particular trajectory is one expression of that knowledge. RoboScript takes a demonstration, lets a frozen model practice in simulation, and saves the resulting lessons in a reusable task memory. Its next attempt can improve while the model’s weights stay fixed. That creates a question for robot learning: can an editable procedure, revised through interaction, compete with a policy trained on demonstrations? And what does a simulator contribute that putting a demonstration in the prompt does not?. The Idea. World In-Context Learning, or WICL, is the learning recipe; RoboScript is the infrastructure implementing it. Here, “world” means the RoboTwin physics simulator. The adaptive component is a foundation-model agent’s task memory. The model uses its existing capabilities to interpret observations, choose tools, and revise instructions for subsequent attempts. Task-specific learning changes that external artifact rather than network parameters. Start with what the model controls. Before individual task memories are learned, a shared skill-building stage uses demonstrations across the benchmark tasks to construct reusable manipulation routines. During execution, the agent requests operations such as grasping, placing, or moving. Motion planning converts those requests into robot motion. Each action produces a receipt describing what happened, including whether the target was reached and whether the gripper appears to hold something. This makes the interface consequential. “I commanded a grasp” and “I am holding the object” are different statements. The receipt gives the reasoning system evidence for choosing its next action, rather than requiring it to infer success from its own command. Perception is deliberately geometric. Depth establishes positions, sizes, and orientations; vision-language machinery helps identify which object or part those measurements belong to. Geometric proposals, grounding models, and an object registry turn camera observations into a structured scene. The language model reasons over measured geometry instead of supplying all the spatial structure itself. The Task Memory is Markdown plus typed parameters for object roles, workflow, grasping, placement, and lessons. Think of an instruction such as approaching a handle from its side and placing the held object relative to a target. Those relationships can be grounded in a fresh scene. A linter excludes scene coordinates and simulator identifiers. Learning begins with one expert demonstration, packaged with keyframes and robot-motion keypoints. A reader drafts the memory, an actor practices in the demonstration’s scene, and a reviser edits the memory from execution results. Repeated successful execution is the stopping criterion. The demonstration supplies a feasible starting procedure; practice tests whether the agent can carry it out. Rehearsal then moves to new training scenes. Failed attempts trigger edits to a temporary memory; successful retries admit those edits into the shared version. Allowed revisions shrink with experience. The final memory is frozen for evaluation, where the robot can reobserve and recover from failed actions without resetting the scene. A separate reflection stage can write guidance for subsequent evaluations. Deployment also has an explicit information boundary. The acting system receives sensor-accessible observations and planner feedback. Simulator truth can supervise learning, while deployment tools expose observations available to a physical robot. The official environment check determines success. Two earlier research lines explain the lineage. Code as Policies showed that language models could assemble robot behavior through perception and control APIs. Reflexion showed how feedback could improve frozen agents through written memory. RoboScript brings those ingredients into a manipulation lifecycle built around practicing, retaining corrections, and executing the resulting procedure in new scenes. Its distinctive engineering move is making experience persist as an explicit task artifact. The Result. The benchmark is RoboTwin 2.0: fifty dual-arm manipulation tasks, evaluated in clean scenes and scenes with randomized backgrounds, lighting, distractors, and table heights. Its conventional policy-training setup supplies fifty clean demonstrations per task, then tests clean-to-clean and clean-to-randomized transfer. That split gives the episode its central experimental question. Preserve the task, change the surrounding scene, and ask whether the acquired behavior still works. The target is successful physical manipulation, rather than a convincing description of what the robot intends to do. RoboScript uses one clean demonstration per task and rehearses only in clean scenes. The authors evaluate ten episodes per task in each setting, giving a thousand evaluation episodes under the official success check and step limits. The headline configuration, using GPT-6.1-Sol, reaches 83.4% mean success across both settings. That puts it 21.7 percentage points ahead of 4D-WAM, the strongest trained action policy in the paper’s comparison. The shape of the result is more revealing than the ranking. On clean scenes, RoboScript and the leading trained policy perform similarly. Under randomization, RoboScript’s aggregate success stays almost unchanged while the policy’s success falls sharply. The headline margin is primarily a robustness result: task memories learned through clean-scene rehearsal remain effective when the visual conditions change. The key ablation asks whether world interaction itself matters. On a ten-task subset, memory learned through interaction outperforms memory extracted from the demonstration alone in a paired, statistically significant comparison. That supports the central mechanism: attempted behavior contributes useful information beyond the demonstration’s description. I find that comparison more informative about learning than the leaderboard position. A demonstration gives the agent a candidate procedure. Rehearsal submits that procedure to an executable test. The important transformation is from an interpretation of an example into instructions that have survived attempts to use them. The authors also transfer memories from simulated ALOHA to a physical dual-arm PiPER through robot-specific parameter remapping. Hardware tasks include bell pressing, coordinated roller grasping, moving a playing card, and stacking bowls. These trials use action sequences planned offline before execution. The transferred artifact is the task procedure, with its workflow and relative specifications preserved across embodiments. The Biggest Weakness. The biggest weakness is causal attribution: the headline compares complete systems, then invites a conclusion about where skill should be stored. RoboScript changes perception, action abstraction, and the learning protocol together. Depth-derived object geometry, reusable skills, motion planning, and rehearsal are all active ingredients. The benchmark’s trained-policy protocol fixes demonstration data; it does not supply a version of RoboScript’s own control stack that updates weights instead of memory. That distinction matters especially for visual robustness. Routing spatial reasoning through measured geometry is already a strong architectural choice about which appearance changes should influence control. My inference is that some resilience could come from this decomposition independently of whether corrections are stored as text. The reported comparison does not isolate those explanations. The world-feedback ablation answers a narrower question: does interaction help this agent construct a better memory? It does not compare contextual adaptation with gradient-based adaptation under matched observations, tools, and opportunities to practice. A decisive experiment would hold the perception stack and manipulation primitives fixed. Both learners would receive the same demonstration and simulator-interaction budget. One would revise contextual memory; the other would learn to select and parameterize those same primitives through weight updates. Both would then face identical held-out scenes and execution rules. That would distinguish the contribution of the learning mechanism from the contribution of the surrounding robot architecture. It would also make “one demonstration” comparable as an expert-input budget without confusing it with total experience. This is not a demand to discard the current benchmark. The existing comparison is useful for choosing between system designs. It is a demand to distinguish a strong systems result from a general claim about learning paradigms. RoboScript demonstrates the competitiveness of its complete architecture here; it does not establish that storing skill in weights is itself why competing systems fail. Verdict. Pay attention if you build manipulation systems around calibrated cameras, reusable motion primitives, and a high-level task planner. RoboScript puts adaptation at the level where those systems express intent: object roles, subgoals, grasp choices, and recovery rules. For that audience, the valuable artifact is a learned procedure you can open and inspect. There is a useful neighboring design in Harness VLA. It also combines memory and an agent, while exposing a frozen VLA as a primitive for contact-rich behavior. Analytic routines handle functions such as staging and transport, and the agent decides when to invoke or retry the learned controller. That work makes explicit memory and learned motor control complementary components. Together, these designs suggest a productive research agenda: decide which knowledge belongs in the task procedure, which belongs in the action interface, and which belongs in a learned controller. RoboScript gives researchers a concrete implementation for investigating the procedural layer. Consider a hypothetical placement that stops just short of its target. A useful memory revision would identify the spatial relation to check and the relative parameter to adjust. “Try harder next time” contributes nothing operational. A testable correction connects diagnosis to the next physical attempt. That is the engineering habit worth borrowing: make experience leave an inspectable artifact. Ask what changed after failure, why that change should help, and how another scene can test it. Treat a revised procedure as something that deserves regression testing. The public implementation supports this style of investigation through separate learning methods, perception services, motion interfaces, and benchmark integrations. Researchers can investigate a component while retaining the rest of the execution framework. Simulation consequently acquires another role in the development process. It becomes a place to refine the instructions a reasoning system uses to operate a robot. The output of practice can be an explicit account of how to perform a task. The takeaway: use simulator experience to improve robot task knowledge in an inspectable memory, while keeping the foundation model frozen. Outro. Watch for reusable task memories becoming artifacts that move between robot embodiments and learning systems. A demonstration supplies a starting procedure. Rehearsal tests its interpretation. Memory gives useful corrections somewhere to persist. That sequence offers a concrete way to think about learning beyond the next optimizer step. After a robot makes a mistake, we can ask more than which parameters should change. We can ask what the robot should remember, how precisely it should express that lesson, and what experiment would establish that the lesson helps. This has been Embodied AI 101.