In task and motion planning (TAMP), discrete choices—such as which object to manipulate, which tool to use, or which subgoal to pursue—are coupled to continuous geometric, kinematic, and dynamic constraints.
Generalized TAMP exploits regularities across problem instances to produce reusable solutions, for example by learning samplers, feasibility predictors, search heuristics, or abstractions. In this paper, we study coding agents as a synthesis method that produces a single programmatic policy for each environment: AgenticGenPlan.
Within an environment, instances may differ in object count, configuration, and geometry, while sharing the state and action spaces, transition model, and reward function. States are fully observed and object-centric; perception and language understanding are outside the scope of this study.
1 obstacle
2 obstacles
4 obstacles
Different instances of the Obstruction task. The same program must retrieve the target block across these configurations.
Experimental setup
Access restrictions in the main setting
The agent receives a description of the task, observation and action spaces, and goal. It chooses its own simulator tests within a $20 model-usage budget per synthesis run.
No network or host-filesystem access. Code runs in an isolated Docker container with a separate filesystem.
No environment source code. A client API provides reset, step, and rendering. The simulator implementation runs outside the container and is inaccessible to the agent.
Only Python, NumPy, and SciPy. The agent must generate its own end-to-end policy.
No supplied TAMP components. We provide no hand-written predicates, operators, samplers, or skills.
We test this isolation through red-teaming: attempts to recover source code, import forbidden libraries, access host files, or reach the network.
Held-out evaluation
The resulting program is frozen. It selects actions with no further coding-agent or LLM calls.
Five independent runs per method and environment.
The same 100 held-out instances per environment for all programs and planners, sampled from the initial-state distribution used during synthesis.
Evaluation seeds checked for overlap. Seeds are generated randomly, and we verify afterward that none were used during synthesis.
60 seconds per evaluation instance for every method.
+ source comparison. In this additional setting, which we run with Claude Code with Opus 5 and Codex with GPT-6 Astra on all 28 environments, the agent can inspect the environment implementation and import its helper functions, including inverse kinematics solvers. During synthesis, it can also set arbitrary simulator states.
Includes 280 additional GPT-6 Astra programs and 28,000 evaluation episodes: 140 in the main setting and 140 + source.
Gallery
Examples of tool use, task strategies, failure recovery, and typical failures in the synthesized programs. Main setting uses the simulator API; + source also provides the environment source code.
Strategies and behaviors
Failures
Project video
An overview of the task setup, a synthesis example, experimental results, and selected behaviors.
Experimental results
Mean success rates over 100 held-out instances per run, averaged across five runs and the selected environments.
Mean held-out success rate by method. The future coding agents row is a placeholder with an unknown score.
Method / backend
Setting / access
Coverage
Future coding agentsMore and better in the future
—
—
?
Equal-environment averages. GPT-6 Astra, in the main setting and + source, uses five completed experiment runs per environment; the other methods use Tables I–II. All environment means use the same two-decimal precision. The two + source rows are listed separately. Missing planner results are excluded from its average.
In the main setting, the agent receives text and interactive simulator access, without demonstration videos. The text below is verbatim from the archived experiment record.
Loading the environment description…
Effect of source access
Source access serves as a reference for how the agents perform with complete knowledge of the environment. It raises mean success for both agents, from 74% to 84% for Claude Code with Opus 5 and from 86% to 95% for Codex with GPT-6 Astra. Source access is not sufficient on its own: LLMGenPlan also receives the source code, uses Opus 5, and has the same $20 budget, yet reaches 28%, while Claude Code with Opus 5 + source is higher in 27 of 28 environments. The source code provides both information and implementations that programs can reuse. With it, the agents can read goals and success checks directly, whereas in the main setting they must infer them from rewards and images, and sometimes settle on an inaccurate goal. On SweepIntoDrawer, for example, source access raises Claude Code with Opus 5 from 0% to 57%.
Mean held-out success over all 28 environments for each coding agent, in the main setting and with source access.
Coding agent
Main setting
+ source
Loading…
Equal-environment means over all 28 environments, five runs each.
Computation at test time
Claude CodeOpus 5 · Main setting11.741 ms
Claude CodeOpus 5 · + source42.480 ms
CodexGPT-6 Astra · Main setting1.299 ms
CodexGPT-6 Astra · + source50.392 ms
Policy computation per action on the 15 environments where all four settings have at least one run with 100% held-out success. Each method is averaged over its own runs with 100% held-out success, equally across environments. Table III ↗
Citation
@misc{merler2026coding,
title={Coding Agents for Generalized Task and Motion Planning Problems},
author={Matteo Merler and Bowen Li and Josh Roy and Yichao Liang and Qianwei Wang and Yixuan Huang and Tom Silver},
year={2026},
eprint={2609.30233},
archivePrefix={arXiv},
primaryClass={cs.RO},
url={https://arxiv.org/abs/2609.30233},
}
