The Order of Magnitude First
A skilled robotics engineer needs months to hand-write a usable task and motion planner for one class of tasks. A paper posted to arXiv on September 24, 2026 (arXiv:2609.30233) replaces this with a different approach: give a coding agent a task description, a simulator, and a fixed synthesis budget, and let it write the program itself. Once written, the program is frozen and run on 100 never-seen instances.
28 environments, 980 generated programs, 100 held-out instances per program—98,000 evaluations in total.
That number is the hardest part of the whole paper. It is not a demo; it is a census.
Why TAMP Is Hard
TAMP stands for task and motion planning, and it requires solving two things simultaneously: discrete-level task decisions (pick up A first or B first), and continuous-level geometric, kinematic, and dynamic constraints (how does the hand get in, will it collide). These two layers are interlocked—separating either one and solving it alone does not work.
Generalized TAMP takes a clever route: different instances of the same problem class share regularities, and if you can capture those regularities, new instances do not need planning from scratch. The route works, but the cost is heavy TAMP-specific engineering—every environment requires someone to design abstractions, write domain knowledge, and tune interfaces.
The paper asks exactly one question: can this engineering be handed off to a code-writing agent?
How the Experiments Were Set Up
Three configurations were tested: Claude Code running Opus 5, and Codex running GPT-5.6 Sol and GPT-6 Astra. Environments come from the KinDER and PDDLStream simulation frameworks, with object counts pushed beyond what the original benchmarks tested.
The key design element is the "freezing" step. During synthesis, the agent can interact with the simulator freely; once the program is finalized, it is never modified again, and it then faces entirely new instances. This closes off the loophole of tuning on the fly.
Results: 56% to 95%, Versus 47%
In the 16 environments where hand-written planners were available for comparison, agent-written programs achieved average success rates between 56% and 95%; the hand-written planners scored 47%.
Two baselines were also beaten: one-shot generation (no interaction opportunity) and an LLM-based general-purpose planning baseline.
Something more interesting than raw success rates: as the number of objects increases, agent-written programs degrade more slowly than the planners, and average compute per instance is an order of magnitude lower. This suggests the agents captured the structure of the problem class, not answers to specific instances.
What the Agent Was Doing in Its Logs
The paper released the agents' interaction logs, and the behavioral pattern resembles a competent engineer: first probing the simulator to calibrate a physical model, then testing its hypotheses against edge cases, revising strategy when something is off, and only then finalizing.
This section is the pivot of the entire paper. The difference between one-shot generation and an interactive agent is not model strength—it is whether there is an environment for repeated trial. Give it an environment and a budget, and it will build its own understanding before writing what it delivers.
Two Related Moves in the Same Week
RAPID (arXiv:2609.30249) reverse-engineers three things from a single human visual demonstration: testable task specifications, action primitives, and an interactable execution environment, then lets a coding agent iteratively generate, verify, and revise. The author list includes Leslie Pack Kaelbling and Tomás Lozano-Pérez. Programs use object-centric relational representations that survive changes in object pose, shape, and material. It was tested on 8 non-prehensile, contact-rich tasks on a real Franka arm.
World Action Agent (arXiv:2609.29964) achieved 75.6% average success on LIBERO-Pro, surpassing end-to-end VLAs, code-as-policy agents, and visual harness baselines on the same backbone. Its approach turns each action from a general VLM into an editable proposal that is rehearsed and error-corrected before execution. Interaction trajectories can also train smaller models: after fine-tuning, Qwen3.5-9B's out-of-distribution success rate rose from 1.7% to 43.3%.
Placed side by side, the shape is clear: simulators or interactable environments are becoming the compiler for robot programs.
Is This Worth Taking Seriously
Three boundaries should be stated upfront.
First, 56% to 95% is a wide range, and the paper's comparison is at the level of means—not a rout in every environment. Wide ranges usually indicate systematic differences between environments, and the paper does not decompose where those differences come from.
Second, everything is in simulation. KinDER's and PDDLStream's object dynamics are idealized; real-robot contact, friction, and perception noise are absent from this evaluation.
Third, the code and full prompts are released—a plus, and the precondition for this paper being verifiable. The authors are Matteo Merler, Bowen Li, Josh Roy, Yichao Liang, Qianwei Wang, Yixuan Huang, and Tom Silver.
Why This Matters More Than the Numbers
In robotics, the expensive thing has never been the machine. It is the months of custom engineering between a specific task and a working planner. This paper compresses that engineering into a single budgeted program synthesis run.
If this path holds, planners shift from things you build to things you generate. Once that shift is established, the cost structure of robot deployment changes with it.
Watch List
- Real-robot replication: RAPID has done it on a Franka; the TAMP paper has not.
- Source of the range: within 56% to 95%, is it environment differences or task-type differences?
- Budget sensitivity: halve the synthesis budget—how much does success drop? The paper reports fixed-budget results only.
- Cross-framework transfer: beyond KinDER and PDDLStream, can agents still discover structure on their own?
References
1. Matteo Merler, Bowen Li, Josh Roy, Yichao Liang, Qianwei Wang, Yixuan Huang, Tom Silver, Coding Agents for Generalized Task and Motion Planning Problems, arXiv:2609.30233, 2026-09-24 2. Yuyao Liu, Jiayuan Mao, David Hsu, Leslie Pack Kaelbling, Tomás Lozano-Pérez, RAPID: Robot Agentic Programming from Demonstrations, arXiv:2609.30249 3. Yehang Zhang et al., World Action Agent, arXiv:2609.29964 4. FutureX Physical AI Daily Issue 131, 2026-09-26