Abstract.
Different research lines use the term world model in different ways, yet they share a common aim: to capture how the world evolves under action in a form that supports perception, simulation, and planning. Two prominent realizations are neural predictors that learn dynamics in continuous vector spaces, and hand-built physics engines that expose explicit state and physical laws. Neural predictors scale from data but leave the form of the dynamics implicit; physics engines are inspectable and editable but difficult to construct at scale. We introduce VisualPatchWorld (VPW), which represents world dynamics as code. VPW first selects a qualitative dynamical form with short active probes, then fits that form’s free parameters from recorded state–action traces by minimizing multi-step prediction error. The resulting programs can be rolled forward like a simulator, inspected in source form, and used inside model-predictive control; image-derived scene graphs can supply the live state at replan time. Across comparisons with prior code-based world models, VPW attains mean planning success and exceeds the strongest code baseline by points. The largest gains arise when choosing the correct qualitative dynamics is essential. Under the same planner, the induced models approach ground-truth engine success on navigation and grasp-rich control; a residual gap remains for contact-rich pushing, and checking a shortlist of promising plans in the engine closes most of that gap. These results establish a practical route toward automatically constructed code world models that are useful for planning. Code is available at https://github.com/HKBU-KnowComp/VisualPatchWorld/.
1. Introduction
Different research lines attach different meanings to the term world model, but they share a common goal, illustrated in Figure 1. Following the functional taxonomy of Li (Li, 2026), a useful world model should help an agent produce observations, maintain an explicit account of what is happening in the world, and decide what action to take next. Li refers to these roles as rendering, simulation, and planning. They are different projections of the same underlying knowledge of how the world works. Simulation is central: an explicit account of state and dynamics makes both visual appearance and action consequences computable. Hand-built physics engines approximate this ideal most closely, yet they remain difficult to scale because each new environment still requires a human-authored model of how the world changes.
A complementary line of work learns world models with neural networks. Methods such as Dreamer and LeWM (Maes et al., 2026; Hafner et al., 2025) train from interaction data and represent future evolution in continuous vector spaces. These models are data-driven, scalable, and effective for choosing actions from learned representations, but they leave the form of the dynamics implicit. When a predicted future is wrong, there is no editable equation or program that a human or algorithm can inspect and repair. Another line writes the dynamics in code. Methods such as PatchWorld, WorldCoder, and PoE-World (Bai et al., 2026; Tang et al., 2024b; Piriyakulkij et al., 2025) recover executable programs and move closer to a physics-engine style world model. They often train for accurate next-step prediction, however, so a program may fit local transitions while still choosing poor actions over longer horizons.
Existing approaches thus either learn scalable but opaque neural dynamics, or write executable programs without ensuring that the recovered dynamics have the right qualitative form and are useful for action selection. This raises three questions. How can simulator-style dynamics be recovered automatically from interaction trajectories? How can a method choose the correct qualitative form of the dynamics, instead of fitting parameters of a wrong form? How can the recovered model rank candidate action sequences so that a short-horizon planner can optimize them, and what remains missing relative to a ground-truth physics engine?
VisualPatchWorld (VPW) addresses these questions by representing world dynamics as code. Code serves as a structured latent representation: rather than storing dynamics in neural activations, VPW writes an executable transition program that can be rolled forward like a simulator, inspected in source form, and used to evaluate candidate actions. Every environment follows the same two-level induction process in Figure 3. Level 1 selects a qualitative sketch with short active probes over a small candidate family—contact forces, linear navigation, grip-gated object motion, or joint-space arm kinematics—and Level 2 fits that sketch from offline state–action traces under multi-step rollout loss. For planning, the fitted program scores candidate action sequences inside model-predictive control, while image-derived scene graphs can supply the live state at replan time.
These design choices yield strong closed-loop gains. Under a shared planner that already succeeds at least of the time with the ground-truth physics engine, VPW attains mean success across four control domains, exceeding the strongest code baseline by points. The largest improvements appear where qualitative structure is decisive: arm reaching rises from to , cube manipulation reaches , and pushing improves from near zero for prior code methods to . Relative to the ground-truth engine, induced scoring is near ceiling on navigation and grasp-rich control; a larger gap remains on contact-rich pushing, and re-scoring a shortlist of promising plans in the engine closes most of that gap.
Contributions.
- •
Two-level program induction for code world models. We cast simulator-style world-model recovery as a staged problem and present VisualPatchWorld, which induces executable transition programs on every domain by first selecting a dynamical sketch through active probing and then fitting its parameters under multi-step rollout loss for planning.
- •
Planner-facing scoring with the induced program. VPW evaluates candidate action sequences with the induced code world model under receding-horizon control and separates image-based state estimation at replan time from search-time scoring.
- •
Evidence against code baselines and a physics engine. On four control domains, VPW improves over programmatic code-world-model baselines under a shared planner. Relative to a ground-truth physics engine, induced scoring is near ceiling on navigation and grasp-rich control, while contact-rich pushing benefits from selective engine re-scoring of a short candidate list.
2. Problem Definition
We study the problem of recovering simulator-style world models from interaction data. Given trajectories of observations and actions, the goal is to produce an executable transition program that humans and algorithms can inspect, edit, and roll forward in time. The long-term visual setting takes as input a dataset of image observations and actions, , and outputs a program over structured scene descriptions. Here we factor that pipeline: dynamics are induced from structured state–action traces, and image-derived scene graphs provide the live state for closed-loop replanning.
Mining task.
Let denote an object-centric scene description extracted from an observation. The mining task is to learn an executable program such that over multi-step horizons. Because consumes structured state rather than raw pixels, the problem naturally splits into visual abstraction and dynamics induction over triples . This separation supports controlled evaluation: oracle state removes perception error from the dynamics question, whereas image-derived state measures how much perception noise degrades planning.
Executable world model.
We require to satisfy a simulator-style contract. The program must accept structured state, update that state under a candidate action, roll forward over action sequences, and expose its transition law in a form that can be inspected and edited. This requirement distinguishes a mined code world model from a neural latent predictor: when a rollout fails, the transition law itself can be examined and revised, instead of being retrained as an opaque embedding.
Evaluation criteria.
We evaluate a mined world model by whether it supports closed-loop control on held-out start and goal pairs. Receding-horizon model-predictive control serves as a downstream application test, not as the training loss itself. Starts and goals differ from the training episodes, but remain within the same domains unless an explicit out-of-distribution test is stated. Accurate one-step prediction on is necessary but not sufficient for planner-usable dynamics.
Evaluation questions.
A single planning score is difficult to interpret because failure can arise at several stages. We organize evaluation around the questions posed in the introduction: whether the recovered program behaves like a simulator-style world model under multi-step rollouts; whether it uses the correct qualitative form of the dynamics; and whether its scoring of candidate action sequences supports planning relative to a ground-truth physics engine. In practice, we localize errors with controlled splits over perception source, hypothesis class, rollout fidelity, and planning protocol, as detailed in Section 5. We study this problem on four LeWM domains (Maes et al., 2026) covering navigation, contact manipulation, and low-dimensional continuous control.
3. Related Work
Latent visual world models.
Latent world models learn dynamics directly from pixels for planning and control. Joint-embedding and model-based approaches such as JEPA and Dreamer encode environment evolution in continuous embeddings (Maes et al., 2026; Hafner et al., 2025). LeWM (Maes et al., 2026), DINO-WM (Zhou et al., 2025), and PLDM (Sobal et al., 2025) are the primary latent references in Table 1, while GCBC, GCIQL, and GCIVL (Ghosh et al., 2021; Kostrikov et al., 2022; Park et al., 2025) provide offline goal-conditioned policy baselines. Recent work adds more structure inside the latent: Dyn-O and FIOC-WM learn object-centric dynamics and interactions (Wang et al., 2025; Feng et al., 2025), and causal world models couple learned causal variables to language agents for planning (Gkountouras et al., 2025). RLVR-World shows that optimizing world models for verifiable prediction metrics improves downstream utility (Wu et al., 2025). These methods are strong and scalable, but a failed rollout does not expose an editable transition law.
Executable code world models and visual abstraction.
A complementary line induces executable transition programs. PatchWorld (Bai et al., 2026) recovers Python dynamics from symbolic trajectories via counterexample-guided search; WorldCoder (Tang et al., 2024b) learns monolithic Python models from interaction; GIF-MCTS (Dainese et al., 2024) searches over code edits on the Code World Models Benchmark; Curtis et al. (Curtis et al., 2025) induce low-complexity probabilistic programs for POMDP components; PoE-World (Piriyakulkij et al., 2025) composes weighted programmatic experts from brief demonstrations; OneLife (Khan et al., 2026) synthesizes conditionally activated programmatic laws under a tight exploration budget; and Lehrach et al. (Lehrach et al., 2025) synthesize game-playing code world models for (IS)MCTS. These methods typically assume structured state is already available and optimize next-step or trajectory fit. Object-centric scene descriptions bridge images to such programs by exposing positions, orientations, and relations in units a transition program can consume. VPW uses this bridge as a planning interface: oracle state isolates the dynamics question, image-derived state measures perception cost at replan time, and a VLM baseline tests whether semantic recognition alone is metric enough for planning.
Structure selection and contact-aware planning.
Choosing the right dynamical form is also central in scientific law discovery. LLM-SR and LaSR cast equation discovery as program search guided by language models (Shojaee et al., 2025; Grayeli et al., 2024), while NewtonBench (Zheng et al., 2026) shows that static regression fails on complex systems and that discriminating probes help identify the correct law class. VPW applies a restricted form of this idea in robot control: active probes select among a small environment-specific family of dynamical forms, after which the chosen form is fit. Differentiable simulators offer another executable template, but stiffer contact models can harm CEM planning even when one-step metrics improve (Zhong et al., 2022). This observation motivates VPW’s use of smoother induced contact laws, together with optional engine-based verification during search.
4. Method
VisualPatchWorld turns interaction trajectories into an executable code world model in four stages, summarized in Figure 2 and Algorithm 6. First, each observation is converted into a structured scene description that records object poses and relations. Second, paired before/after descriptions are exported as transition records for learning. Third, an executable Python program is induced by the shared two-level process in Figure 3: Level 1 selects a dynamical sketch by active probing, and Level 2 fits the free parameters of that sketch under multi-step rollout loss. Fourth, the induced program is tested inside a receding-horizon planner, with an optional check of promising plans in the ground-truth physics engine.
Separating sketch selection from parameter fitting is essential. Open-ended code generation can produce programs that parse and fit local transitions while still encoding the wrong dynamical form, and parameter fitting alone can achieve low one-step error without recovering contact or kinematic structure needed for control, as shown in Section 5.4. VPW therefore runs the same two-level induction process across domains, changing only the small sketch family per environment, and evaluates the fitted program under the planner’s own objective. The remainder of this section details the four stages.
4.1. Stage 1: Visual abstraction
The first stage replaces raw pixels with a structured representation that preserves the geometric and relational cues that dynamics depend on. We call this representation a scene graph: a text description containing environment metadata, object poses, and relational attributes such as distance, near-contact flags, and relative direction. All abstraction paths emit the same schema, so later differences reflect perception quality rather than format mismatch.
We implement three interchangeable extractors, ordered by how much perception error they remove. The oracle path reads simulator state directly and removes perception error, isolating the dynamics question. The tool path applies computer-vision heuristics to RGB frames and is our default image-observation interface when environment-specific extractors exist. The VLM path uses a vision-language model over RGB frames with Qwen/Qwen3.5-397B-A17B; it recovers semantics but not reliable metric coordinates, so we use it as a semantic baseline, illustrated in Figure 6 and Appendix B. Figure 5 contrasts tool-extracted and oracle graphs on live frames. Collision geometry used by the tool path, such as polygon vertices and agent radius, is detected from pixels rather than read from simulator source code. The tool path is an engineered perception module, not an end-to-end pixel learner; its segmentation, orientation, calibration, and smoothing steps are specified in Algorithm 1 of Appendix A.
4.2. Stage 2: Trajectory export
The second stage converts recorded rollouts into symbolic transition records for program induction. Each record is a triple containing the scene description before the action, the action itself, and the scene description after a frame stride . We refer to the resulting file as a simulator-state trace when the scene descriptions come from oracle/simulator state.
A critical requirement is that action discretization matches the frame stride . If macro-actions are misaligned with the exported transitions, one-step prediction can look strong while multi-step rollouts degrade. The export procedure is given in Algorithm 2 of Appendix A.
4.3. Stage 3: Two-level program induction
The third stage learns an executable Python transition program such that . On every domain, VPW uses the two-level induction process in Figure 3. Level 1 selects a qualitative form of the dynamics, which we call a dynamical sketch. Level 2 then fits the free parameters of that sketch under multi-step rollout loss. This separation keeps structure choice and parameter estimation separable: the procedure is shared across domains, while the compact hypothesis family is domain-specific, with instantiations in Section 5.1.
Level 1: Sketch selection by active probing.
Before fitting constants, VPW chooses the sketch by active probing: it runs short discriminating experiments through black-box environment reset and step calls, and retains the candidate that best explains the observed outcomes, as in Algorithm 3. Each domain provides a compact hypothesis family over qualitative alternatives, for example contact versus free motion, linear versus nonlinear transport, grip-gated versus always-coupled object motion, or joint-space versus Cartesian kinematics. Probing commits to one sketch; Level 2 then fits its free parameters on the offline state traces shared with the code baselines.
Level 2: Parameter identification.
Once the sketch is fixed, VPW instantiates it as a Python template with unknown constants and estimates those constants by multi-step rollout error—the accumulated prediction error over the planner horizon—as in Algorithm 4. This objective penalizes models that fit a single step but drift over longer rollouts. In practice, we run multiple restarts of differentiable optimization on the training rollout loss and keep the restart with the lowest held-out rollout error. Contact-rich templates may additionally use collision-geometry features such as contact point, normal, and lever arm. The output is an executable transition program that plugs directly into the Stage 4 planner.
Optional acquisition loop.
After a sketch is fixed, an optional loop can gather additional transitions and revise parameters inside that sketch. Headline models use a single Level 1 plus Level 2 pass. The full induction-and-planning loop appears in Algorithm 6 of Appendix A.
4.4. Stage 4: Planning protocol
The fourth stage tests whether the mined program supports goal-directed control. Low one-step error does not guarantee usable search. We therefore plan with receding-horizon model-predictive control optimized by the cross-entropy method (CEM-MPC). At each replan step, the planner samples candidate action sequences, rolls them forward under a scoring model, retains the best samples, updates the sampling distribution, and executes the first actions before re-observing the state, as in Algorithm 5 of Appendix A.
Every planning condition is defined by two independent choices, detailed in Section 5.1. The first is the replan observation: whether the planner’s current state comes from the tool path over live images or from oracle simulator state. The second is the scoring model used to rank imagined futures during search. We consider three scoring settings. Under induced scoring, the mined program evaluates every candidate; this is the pure executable-model planner. Under hybrid scoring, the mined program still scores all samples, after which the ground-truth engine re-scores the top shortlist and the planner chooses among those re-checked plans. Under simulator scoring, the ground-truth engine scores every candidate and the induced model is not used in search; this setting is the physics ceiling.
We freeze the planner horizon, receding step, frame skip, and CEM budget for each environment; budgets appear in Appendix Table 9 and Section 5.1. All conditions execute actions in the true simulator. Separating what is observed at replan time from what scores imagined futures lets us attribute failures to perception, dynamics, or scoring, as reported in Table 1.
5. Experiments
An executable world model is useful for planning when it recovers both appropriate dynamical structure and a scoring landscape that a planner can optimize. We evaluate VPW on the LeWM four-task suite in Table 2, asking three questions: whether it outperforms programmatic code baselines under shared frozen planners; how close induced-only CEM comes to a MuJoCo ceiling; and whether selective hybrid verification closes remaining contact gaps. Component ablations appear in Section 5.4; additional perception analysis is in Appendix C.
5.1. Experimental Setting
| Method | Type | Train data | Replan obs. | Planner/scorer | Two-room | Reacher | PushT | Cube | Mean |
| Neural/policy references | |||||||||
| LeWM (Maes et al., 2026) | Neural | RGB | RGB/latent | Latent WM | 87 | 86 | 96 | 74 | 85.8 |
| DINO-WM (Zhou et al., 2025) | Neural | RGB | RGB/latent | Latent WM | 100 | 79 | 74 | 86 | 84.8 |
| DINO-WM+p | Neural | RGB+proprio. | RGB/latent | Latent WM | 100 | — | 92 | — | — |
| PLDM (Sobal et al., 2025) | Neural | RGB | RGB/latent | JEPA WM | 97 | 78 | 78 | 65 | 79.5 |
| GCBC (Ghosh et al., 2021) | Policy | RGB | RGB/latent | Policy | 100 | — | 75 | 84 | — |
| GCIQL (Kostrikov et al., 2022) | Policy | RGB | RGB/latent | Policy | 100 | — | 20 | 64 | — |
| GCIVL (Park et al., 2025) | Policy | RGB | RGB/latent | Policy | 100 | — | 33 | 56 | — |
| Executable code world models (frozen planner, induced-only) | |||||||||
| PatchWorld (Bai et al., 2026) | Program. | Sim-state traces | Oracle state | Induced code | 98 | 8 | 0 | 66 | 43.0 |
| WorldCoder (Tang et al., 2024b) | Program. | Sim-state traces | Oracle state | REx pool | 60 | 6 | 0 | 74 | 35.0 |
| POMDP-Coder (Curtis et al., 2025) | Program. | Sim-state traces | Oracle state | Prob. program | 98 | 18 | 0 | 66 | 45.5 |
| PoE-World (Piriyakulkij et al., 2025) | Program. | Sim-state traces | Oracle state | PoE experts | 6 | 18 | 0 | 84 | 27.0 |
| GIF-MCTS (Dainese et al., 2024) | Program. | Sim-state traces | Oracle state | MCTS code | 6 | 20 | 0 | 66 | 23.0 |
| CWM-Game (Lehrach et al., 2025) | Program. | Sim-state traces | Oracle state | Tree CWM | 2 | 30 | 2 | 66 | 25.0 |
| VPW Tool+Induced | Program. | Sim-state traces | RGB tool | Induced only | 96 | 60 | 22 | 66 | 61.0 |
| VPW Oracle+Induced | Program. | Sim-state traces | Oracle state | Induced only | 96 | 72 | 22 | 86 | 69.0 |
Environments.
We use the same four environments as LeWM (Maes et al., 2026), with the expert HDF5 trajectories and planning protocol from LeWM Appendix F.1. Table 2 summarizes the domains. Each evaluation uses 50 starts with a goal sampled 25 steps ahead. We freeze one planner per environment so that MuJoCo ground-truth success is at least 90%; budgets appear in Appendix Table 9. Two-room and Reacher use CEM with a budget, PushT uses CEM-MPC with a budget, and Cube uses library shooting. Neural reference rates follow LeWM Fig. 6; re-running the released LeWM checkpoints yields 87%, 86%, 96%, and 74% on Two-room, Reacher, PushT, and Cube.
| Env | Domain | Primary challenge |
|---|---|---|
| PushT | 2D contact push | Contact law, timing |
| Two-room | 2D navigation | Walls, goals |
| Cube | 3D manipulation | Multi-object 3D |
| Reacher | DMC continuous | Low-dim joints |
Per-environment sketch families.
The Stage 3 procedure in Section 4.3 is shared across domains; each domain supplies a compact Level 1 hypothesis family. PushT recovers contact-driven PD control with a quasi-static block. Two-room recovers linear navigation. Cube recovers grip-gated contact. Reacher recovers joint-space dynamics with forward kinematics. Table 5 reports the recovered dynamics and planning success for these outcomes.
Training data and planning interface.
All executable methods learn from the same offline simulator-state traces: structured transitions exported from simulator ground truth as in Stage 2 of Section 4. At planning time the induced program reads live state. Tool rows extract scene graphs from pixels, while Oracle rows read simulator state. Under Hybrid scoring, CEM scores every candidate with the induced model and MuJoCo re-scores the top 30% before plan selection, following Stage 4. The mined program remains the search engine. Tool+Induced uses LeWM’s RGB interface at replan time; dynamics are still trained on simulator-state traces. Tool extractors are environment-specific; see Appendix B.
Models and backends.
All LLM-facing programmatic baselines share Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo with a common API client and call budget. Port details appear in Appendix D. VPW does not use that coder for reported dynamics: Level 1 probing and Level 2 rollout fitting instantiate Python templates without open-ended LLM synthesis. A VLM path with Qwen/Qwen3.5-397B-A17B is a semantic baseline for Stage 1; the tool and oracle extractors in the main planning rows are non-LLM.
Reporting conventions.
Main-table cells are single-run point estimates on a shared 50-start seed-42 set, so code baselines and VPW see identical starts. For VPW Oracle+Induced we also report five-seed means over seeds 42–46 in Appendix F, where the suite mean is . We report four VPW conditions by pairing Tool or Oracle replan with Induced or Hybrid scoring, together with MuJoCo+CEM as the physics ceiling. Hybrid and MuJoCo rows analyze remaining contact and scoring gaps relative to the induced-only baseline comparison. Per-cell protocols appear in Appendix Table 10, with additional Reacher analysis in Appendix E.4 and E.5.
| Reacher | PushT | |||
|---|---|---|---|---|
| Method | open-loop err | CEM succ. | (diag.) | CEM succ. |
| PatchWorld | 0.86 | 8 | 0.0 | 0 |
| WorldCoder | 0.86 | 6 | 0 | |
| POMDP-Coder | 0.23 | 18 | 0.0 | 0 |
| PoE-World | 0.11 | 18 | 0.0 | 0 |
| GIF-MCTS | 0.23 | 20 | 0 | |
| CWM-Game | 0.13 | 30 | 27.8 | 2 |
| VPW Oracle+Ind. | 0.04 | 72 | 16.2 | 22 |
5.2. Baselines
Table 1 has two blocks. The upper block reproduces neural latent world models and offline goal-conditioned policies from LeWM Fig. 6 (Maes et al., 2026), including LeWM (Maes et al., 2026), DINO-WM (Zhou et al., 2025), PLDM (Sobal et al., 2025), GCBC (Ghosh et al., 2021), GCIQL (Kostrikov et al., 2022), and GCIVL (Park et al., 2025). These RGB or latent references indicate task difficulty under a different supervision regime. The lower block is the executable comparison. We evaluate six programmatic ports, PatchWorld (Bai et al., 2026), WorldCoder (Tang et al., 2024b), POMDP-Coder (Curtis et al., 2025), PoE-World (Piriyakulkij et al., 2025), GIF-MCTS (Dainese et al., 2024), and CWM-Game (Lehrach et al., 2025), against VPW under identical sim-state traces, oracle replan state, and induced-only CEM scoring. Each port emits a deterministic transition program with the shared coder; implementations are detailed in Appendix D. Hybrid and MuJoCo ceilings are reported separately in Section 5.6.
| Success % | Sim queries / plan | |||||
|---|---|---|---|---|---|---|
| Env | Ind. | Hyb. | MuJoCo | Ind. | Hyb. | MuJoCo |
| Two-room | 96 | 100 | 100 | 0 | 900 | 3000 |
| Reacher | 72 | 100 | 100 | 0 | 900 | 3000 |
| PushT | 22 | 96 | 96 | 0 | 2700 | 9000 |
| Cube | 86 | 84 | 94 | 0 | 120 | |
5.3. Comparison against code baselines
| Env | Recovered dynamics | Plan (%) |
|---|---|---|
| PushT | Contact PD, quasi-static block | 22 |
| Two-room | Linear navigation | 96 |
| Cube | Grip-gated contact | 86 |
| Reacher | Joint dynamics + forward kinematics | 72 |
| Method | 1-step | Plan (%) | |
|---|---|---|---|
| PatchWorld (LLM) | px | — | 0 |
| Linear template | 4.9 px | — | — |
| Collision-gated | 2.4 px | 11.8 px | — |
| VPW (L1+L2) | 1.0 px | 10.0 px | 22 |
| Method | Type | Train data | Replan obs. | Planner/scorer | Two-room | Reacher | PushT | Cube | Mean |
|---|---|---|---|---|---|---|---|---|---|
| VPW Tool+Induced | Program. | Sim-state traces | RGB tool | Induced only | 96 | 60 | 22 | 66 | 61.0 |
| VPW Oracle+Induced | Program. | Sim-state traces | Oracle state | Induced only | 96 | 72 | 22 | 86 | 69.0 |
| VPW Tool+Hybrid | Program. | Sim-state traces | RGB tool | Induced+top-30% MuJoCo | 100 | 70 | 88 | 78 | 84.0 |
| VPW Oracle+Hybrid | Program. | Sim-state traces | Oracle state | Induced+top-30% MuJoCo | 100 | 100 | 96 | 84 | 95.0 |
| MuJoCo+CEM | Program. | — | Simulator state | MuJoCo only | 100 | 100 | 96 | 94 | 97.5 |
Under the frozen planners of Section 5.1, VPW Oracle+Induced attains a 69.0% four-task mean. This exceeds the strongest programmatic baseline, POMDP-Coder at 45.5%, by 23.5 points, and exceeds PatchWorld at 43.0% by 26.0 points, under identical starts and planner settings. Relative to PatchWorld in Table 1, gains concentrate on Reacher, where frame-level CEM raises success by 64 points, and on Cube, where grip-gated contact adds 20 points. PushT improves by 22 points over near-zero success for prior code methods, while Two-room remains near ceiling for both VPW and the strongest ports.
Structure choice explains the gap.
Code baselines and VPW share training traces, oracle replan state, and the frozen CEM planner. They differ in hypothesis class. The LLM ports synthesize free-form transition programs for replay fit. VPW instead probes a small sketch family on every domain, commits to the recovered template, and fits its constants. The recovered forms are joint kinematics with forward kinematics on Reacher, contact-driven PD control on PushT, linear navigation on Two-room, and grip-gated contact on Cube. Table 3 and Figure 4 compare all ports on the same rollouts. On Reacher, PatchWorld and WorldCoder fail under Cartesian fingertip updates, and the remaining ports stay far from VPW’s joint-space tracker, with planning success between 6% and 30% versus 72% for VPW. On PushT, several ports predict a frozen block or unstable jumps. VPW recovers contact-driven motion ( versus ground truth ), enough to raise induced-only planning from 0–2% for the ports to 22%; hybrid scoring closes most of the remaining gap in Section 5.6. On Cube, the grip-gated latch raises VPW to 86%, above WorldCoder at 74% and slightly above PoE-World at 84%. Gains concentrate on Reacher executability, Cube grasping, and PushT structure selection. With shared simulator-state traces and a shared CEM planner, choosing the correct dynamical class closes the planning gap where that class matches the domain.
5.4. Ablation of structure selection
Table 5 summarizes the two-level outcomes. All four programs parse; planning success tracks whether the recovered class matches the domain. Table 6 then isolates PushT on identical graphs. Parse success alone is not enough: free-form PatchWorld plans at , a linear template remains misspecified, and only L1+L2 reaches planning success. Remaining PushT gains come from hybrid scoring in Section 5.6.
5.5. When induced CEM is enough
We next ask whether induced-only scoring is enough once the planner is strong. Under the frozen protocols of Section 5.1, Table 1 reports Oracle+Induced success and Table 7 reports the matching MuJoCo ceiling. Relative to that ceiling, induced scoring recovers 0.96 of MuJoCo success on Two-room, 0.91 on Cube, 0.72 on Reacher, and 0.23 on PushT. On Two-room and Cube, the recovered dynamical class already produces a ranking landscape that CEM can optimize, so induced scoring is near the engine ceiling. On Reacher, frame-level CEM yields a MuJoCo ceiling with induced success at , while coarser macro-MPC settings remain much weaker, as shown in Appendix E.5; planner granularity is therefore first-order (Zhong et al., 2022). On contact-rich PushT, structure recovery is necessary but not sufficient: contact events are sparse and load-bearing, so small ranking errors at the moment of contact discard plans that would succeed under the engine. Planning utility is accordingly not monotonic in one-step fidelity. The next subsection tests a planner-aware remedy that keeps the induced model as the search engine. Appendix Table 9 lists the same comparison with per-environment budgets.
5.6. Hybrid scoring for contact gaps
Hybrid scoring keeps the induced program as the search engine. It scores all CEM candidates, and MuJoCo re-scores the top 30% before the plan is chosen, as in Algorithm 5. Each CEM iteration therefore uses induced rollouts plus MuJoCo rollouts, against MuJoCo rollouts for full simulator CEM. This yields a 70% reduction in physics queries while retaining induced search over the full candidate pool. Table 7 reports the simulator-assisted ladder, and Table 4 reports the query budget. For CEM environments, hybrid uses physics queries; Cube library shooting verifies a shortlist of size independent of .
Hybrid matters most where induced scoring fails. PushT rises from 22% to 88% under Tool+Hybrid and to 96% under Oracle+Hybrid. Two-room Hybrid reaches 100%, matching MuJoCo. On Cube Oracle, Hybrid at 84% is within one trial of Induced at 86% on : when induced ranking is already near the ceiling, hybrid need not help. Hybrid is therefore a selective contact check: the induced program proposes candidates, and the engine verifies only a shortlist. Oracle+Hybrid at 95.0% nearly matches MuJoCo+CEM at 97.5%.
6. Discussion
Why structured code works for planning.
Executable programs provide a stable planning interface: CEM can roll out predictions, score goal distance, and replan with fresh observations. Once the dynamical sketch matches the domain, planning improves sharply over free-form code generation, and the transition law remains inspectable, as shown in Table 3 and Section 5.4. The shared two-level procedure matters as much as the final constants: Level 1 commits to a qualitative form, Level 2 fits that form for multi-step prediction, and the planner then optimizes under the recovered scoring landscape.
What remains versus the engine.
Under strong controllers, induced scoring recovers most of the MuJoCo ceiling on Two-room and Cube, reaches on Reacher against a engine ceiling, and leaves a large PushT contact gap, as reported in Tables 1 and 7. Selective hybrid verification, using physics queries per CEM iteration as in Table 4, closes most of that contact gap while keeping the induced program as the search engine. In short, code world models already suffice for many control domains; contact-rich ranking is where a light engine check still pays off.
Implications.
These results suggest a practical division of labor. Structure selection and parameter fit yield editable, planner-ready dynamics from interaction traces. Image-derived scene graphs can supply live state at replan time without changing the induction pipeline. When induced ranking saturates, hybrid verification is an optional refinement rather than a requirement for every task. Future work can push further toward visual end-to-end induction, larger sketch libraries, and real-robot deployment while retaining the same planner-facing interface.
Scope and setup.
The primary executable comparison is the lower block of Table 1; neural rows are RGB or latent difficulty references. Dynamics are fit from structured state traces; Tool+Induced uses image-derived scene graphs at replan time. Each domain supplies a compact Level 1 sketch family under a shared induction procedure. Frozen planners are chosen so MuJoCo ground-truth success is at least 90%, following Section 5.1. Reacher success depends on replan granularity; see Appendix E.4.
7. Conclusion
VisualPatchWorld learns world dynamics as inspectable code. It selects a qualitative transition form by active probing, fits its parameters from state–action traces, and uses the resulting program for model-predictive control with optional image-based replan state. Across comparisons with prior code world models, VPW improves the strongest baseline by 23.5 mean success points and approaches a ground-truth physics engine on navigation and grasp-rich control; contact-rich pushing remains harder under induced-only scoring. Selecting the right dynamics sketch and fitting it for multi-step prediction yields planners that are both competitive and editable.
Future work should induce these programs from visual scene-graph trajectories, broaden the sketch families, and test out-of-distribution and real-robot settings.
References
- J. Bai, Y. Guo, Y. Dong, J. Xiong, T. Zheng, Y. Li, T. Fang, Y. Li, Y. Gao, H. Huang, Z. Xie, H. T. Tsang, Z. Wang, L. Liu, J. Z. Pan, and Y. Song (2026) PatchWorld: gradient-free optimization of executable world models. External Links: 2605.30880, Link Cited by: Appendix D, §1, §3, §5.2, Table 1.
- A. Curtis, H. Tang, T. Veloso, K. Ellis, J. B. Tenenbaum, T. Lozano-Pérez, and L. P. Kaelbling (2025) LLM-Guided Probabilistic Program Induction for POMDP Model Estimation. In Proceedings of The 9th Conference on Robot Learning, J. Lim, S. Song, and H. Park (Eds.), Proceedings of Machine Learning Research, Vol. 305, Seoul, Korea, pp. 3137–3184. External Links: Link Cited by: Appendix D, §3, §5.2, Table 1.
- N. Dainese, M. Merler, M. Alakuijala, and P. Marttinen (2024) Generating code world models with large language models guided by monte carlo tree search. In Advances in Neural Information Processing Systems, External Links: 2405.15383 Cited by: Appendix D, §3, §5.2, Table 1.
- F. Feng, P. Lippe, and S. Magliacane (2025) Learning interactive world model for object-centric reinforcement learning. In Advances in Neural Information Processing Systems, External Links: 2511.02225 Cited by: §3.
- D. Ghosh, A. Gupta, A. Reddy, J. Fu, C. Devin, B. Eysenbach, and S. Levine (2021) Learning to reach goals via iterated supervised learning. In International Conference on Learning Representations, External Links: 1912.06088 Cited by: Appendix D, §3, §5.2, Table 1.
- J. Gkountouras, M. Lindemann, P. Lippe, E. Gavves, and I. Titov (2025) Language agents meet causality: bridging LLMs and causal world models. In International Conference on Learning Representations, External Links: 2410.19923 Cited by: §3.
- A. Grayeli, A. Sehgal, O. Costilla-Reyes, M. Cranmer, and S. Chaudhuri (2024) Symbolic regression with a learned concept library. In Advances in Neural Information Processing Systems, External Links: 2409.09359 Cited by: §3.
- D. Hafner, J. Pasukonis, J. Ba, and T. Lillicrap (2025) Mastering diverse control tasks through world models. Nature 640, pp. 647–653. External Links: Document Cited by: §1, §3.
- Z. Khan, A. Prasad, E. Stengel-Eskin, J. Cho, and M. Bansal (2026) One life to learn: inferring symbolic world models for stochastic environments from unguided exploration. In International Conference on Learning Representations, External Links: 2510.12088 Cited by: §3.
- I. Kostrikov, A. Nair, and S. Levine (2022) Offline reinforcement learning with implicit q-learning. In International Conference on Learning Representations, External Links: 2110.06169 Cited by: Appendix D, §3, §5.2, Table 1.
- W. Lehrach, D. Hennes, M. Lázaro-Gredilla, X. Lou, C. Wendelken, Z. Li, A. Dedieu, J. Grau-Moya, M. Lanctot, A. Işcen, J. R. Schultz, M. Chiam, I. Gemp, P. Zielinski, S. Singh, and K. P. Murphy (2025) Code world models for general game playing. arXiv preprint arXiv:2510.04542. Cited by: Appendix D, §3, §5.2, Table 1.
- F. Li (2026) Note: World Labs blog, Substack External Links: Link Cited by: Figure 1, §1.
- L. Maes, Q. L. Lidec, D. Scieur, Y. LeCun, and R. Balestriero (2026) LeWorldModel: stable end-to-end joint-embedding predictive architecture from pixels. External Links: 2603.19312, Link Cited by: Appendix D, §1, §2, §3, §5.1, §5.2, Table 1.
- S. Park, K. Frans, B. Eysenbach, and S. Levine (2025) OGBench: benchmarking offline goal-conditioned RL. In International Conference on Learning Representations, External Links: 2410.20092 Cited by: Appendix D, §3, §5.2, Table 1.
- W. T. Piriyakulkij, Y. Liang, H. Tang, A. Weller, M. Kryven, and K. Ellis (2025) PoE-World: compositional world modeling with products of programmatic experts. In Advances in Neural Information Processing Systems, External Links: 2505.10819 Cited by: Appendix D, §1, §3, §5.2, Table 1.
- P. Shojaee, K. Meidani, S. Gupta, A. B. Farimani, and C. K. Reddy (2025) LLM-SR: scientific equation discovery via programming with large language models. In International Conference on Learning Representations, External Links: 2404.18400 Cited by: §3.
- V. Sobal, W. Zhang, K. Cho, R. Balestriero, T. G. J. Rudner, and Y. LeCun (2025) Learning from reward-free offline data: a case for planning with latent dynamics models. In Advances in Neural Information Processing Systems, External Links: 2502.14819 Cited by: Appendix D, §3, §5.2, Table 1.
- H. Tang, K. Hu, J. P. Zhou, S. Zhong, W. Zheng, X. Si, and K. Ellis (2024a) Code repair with LLMs gives an exploration-exploitation tradeoff. In Advances in Neural Information Processing Systems, External Links: 2405.17503 Cited by: Appendix D.
- H. Tang, D. Y. Key, and K. Ellis (2024b) WorldCoder, a model-based LLM agent: building world models by writing code and interacting with the environment. In Advances in Neural Information Processing Systems, External Links: 2402.12275 Cited by: Appendix D, §1, §3, §5.2, Table 1.
- Z. Wang, K. Wang, L. Zhao, P. Stone, and J. Bian (2025) Dyn-O: building structured world models with object-centric representations. In Advances in Neural Information Processing Systems, Cited by: §3.
- J. Wu, S. Yin, N. Feng, and M. Long (2025) RLVR-World: training world models with reinforcement learning. In Advances in Neural Information Processing Systems, External Links: 2505.13934 Cited by: §3.
- T. Zheng, K. K. Tam, N. H. K. Nguyen, B. Xu, Z. Wang, J. Cheng, H. T. Tsang, W. Wang, J. Bai, T. Fang, Y. Song, G. Y. Wong, and S. See (2026) NewtonBench: benchmarking generalizable scientific law discovery in LLM agents. In International Conference on Learning Representations, External Links: 2510.07172 Cited by: §3.
- Y. D. Zhong, J. Han, and G. O. Brikis (2022) Differentiable physics simulations with contacts: do they have correct gradients w.r.t. position, velocity and control?. External Links: 2207.05060, Link Cited by: §3, §5.5.
- G. Zhou, H. Pan, Y. LeCun, and L. Pinto (2025) DINO-WM: world models on pre-trained visual features enable zero-shot planning. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 267, pp. 79115–79135. External Links: 2411.04983 Cited by: Appendix D, §3, §5.2, Table 1.
Appendix A Pipeline Algorithms
This appendix supplies implementation detail and extended evidence for the main claims. Appendix A presents Stage 1–4 algorithms; Appendix B shows representative scene graphs and induced programs; Appendix C reports perception audits; Appendix D documents matched baseline ports and failure modes; Appendix E records planner protocols and scoring analyses; and Appendix F reports multi-seed confidence intervals.
Appendix B Scene Graphs and Induced Models
Figures 5–7 illustrate Stage 1 scene graphs and Stage 3 programs on all four LeWM environments.
RGB-replan tool scene graphs.
Figure 5 shows the tool extractor used by the Tool+Induced and Tool+Hybrid conditions in Section 5.1. Color segmentation, PCA orientation, and optional affine calibration map live RGB frames to PatchWorld scene graphs. As summarized in Table 8, the resulting graphs recover oracle geometry with accuracy sufficient for replanning.
VLM scene-graph baseline (PushT).
Figure 6 shows PushT scene graphs produced by the VLM baseline Qwen/Qwen3.5-397B-A17B. Object identities and qualitative relations are typically correct, yet metric coordinates remain uncalibrated (236 px RMSE). We therefore treat VLM graphs as a semantic reference and use the calibrated tool extractor for RGB replanning (Section 5; Table 1).
Induced executable world models.
Figure 7 shows the induced transition programs. Level 1 selects the dynamical sketch reported in Table 5; Level 2 fits that template on the simulator-state split used at planning time. These programs are the executable models underlying the perception analysis in Appendix C and the Oracle+Induced rows of the main table.
Appendix C Induction and Perception Analysis
This section provides perception evidence for the claim that planning gains arise from recovering the correct qualitative dynamics and fitting its parameters, rather than from open-ended LLM repair alone.
Visual abstraction.
Table 8 reports object precision/recall and position RMSE on held-out perception audits, measured in pixels on PushT and in normalized world coordinates elsewhere. VLM coordinate error is reported for PushT only.
| Environment | Oracle RMSE | Tool RMSE | VLM RMSE | P/R |
|---|---|---|---|---|
| PushT | 1.9 px | 1.8 px | 236 px | 1.00 |
| Two-room | — | 0.19 | — | 1.00 |
| Cube | — | 0.08 | — | 0.67 |
| Reacher | — | 0.12 | — | 1.00 |
Two-level induction and PushT ablation.
Tables 5 and 6 appear in Section 5.4. Planner budgets for the Plan columns are listed in Table 9.
Appendix D Baseline Ports and Failure Modes
The programmatic baselines in Table 1 share the same simulator-state training split and the same per-environment frozen planners as VPW Oracle+Induced (Table 9; settings in Table 10). All LLM ports use Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo (Section 5.1). We report planning success in percent, write when CEM completes with no successes, write when no loadable model is produced, and write — for unevaluated cells.
PatchWorld.
We adapt counterexample-guided repair to LeWM oracle traces and evaluate under the same CEM-MPC shell as VPW (, seed 42). The port retains contrastive transition selection, LLM synthesis, formal replay validation, and beam-patched repair until convergence or a round budget (Bai et al., 2026).
WorldCoder (REx port).
We retain the offline REx candidate pool and omit online optimism and live environment interaction. Candidates are scored by one-step held-out accuracy, and the LLM repairs from counterexamples (Tang et al., 2024b, a).
POMDP-Coder (Curtis et al. port).
We keep the generate–test–refine loop, but emit deterministic PatchWorld-style transition programs for CEM on oracle graphs. The resulting numbers are adapted to the shared LeWM planning interface rather than reproduced from the original POMDP suite (Curtis et al., 2025).
PoE-World (product-of-experts port).
We run Steps 1–3 of the paper on simulator-state traces—expert synthesis, L-BFGS weight fitting, and prune-and-wrap—and omit hierarchical Atari planners and online expert debugging (Piriyakulkij et al., 2025).
GIF-MCTS.
We search over Generate/Improve/Fix edits with MCTS. Node value is held-out transition accuracy; selection uses UCT with action-type balancing; and each environment is allotted 50 LLM calls (Dainese et al., 2024).
CWM-Game (Lehrach et al. port).
We retain tree-search CWM synthesis with Thompson sampling and unit-test feedback, replace (IS)MCTS with CEM-MPC, and use 50 retries (scaled from the paper’s 500). Value-function synthesis, hidden-state inference, and OpenSpiel imperfect-information play are omitted so that evaluation matches the shared LeWM planning interface (Lehrach et al., 2025).
Neural and offline-RL reference rows.
The upper block of Table 1 reproduces the LeWM Fig. 6 rates (Maes et al., 2026) under the LeWM Appendix F.1 protocol, including LeWM, DINO-WM / DINO-WM+p (Zhou et al., 2025), PLDM (Sobal et al., 2025), GCBC (Ghosh et al., 2021), GCIQL (Kostrikov et al., 2022), and GCIVL (Park et al., 2025). These pixel and latent rows provide reference context; they are not matched structured-code baselines.
D.1. Baseline failure case studies
Table 3 and Figure 4 in the main text quantify the comparison. The qualitative cases below illustrate why structure choice dominates planning outcomes on Reacher and PushT.
Reacher: wrong kinematics class.
PatchWorld and WorldCoder treat the fingertip as a free Cartesian particle:
# PatchWorld / WorldCoder Reacher (fair plan 8% / 6%) finger.x += dx; finger.y += dy arm.x += 0.5*dx; arm.y += 0.5*dy # PatchWorld heuristic
POMDP-Coder, PoE-World, GIF-MCTS, and CWM-Game avoid the most severe instability, yet still lack a fitted joint-space law with forward kinematics (open-loop mean error – versus for VPW; planning success – versus ). VPW updates joints and reconstructs the fingertip through fitted forward kinematics:
# VPW Reacher (fair plan 72%) q <- q + B * [1, dx, dy] # fitted joint Delta-q finger <- FK(q) # fitted FK features
PushT: missing or unstable contact.
PatchWorld, POMDP-Coder, and PoE-World leave the block frozen (). WorldCoder and GIF-MCTS produce unstable multi-hundred-pixel jumps. CWM-Game moves the block weakly () but still plans at 2%:
# PatchWorld PushT (fair plan 0%) agent.x += dx; agent.y += dy # block unchanged
VPW recovers a contact-driven PD sketch with quasi-static block response and fits the corresponding PD and contact gains:
# VPW PushT (fair plan 22% induced-only) a <- PD(agent, SCALE*action; KP, KV) block <- quasi_static_push(a, contact_springs)
Induced-only contact ranking remains imperfect (22% versus MuJoCo 96%). Hybrid verification raises Tool+Induced PushT success to 88% (Section 5.6).
Appendix E Planner Protocols and Scoring
This section details the frozen planners and scoring analyses behind Sections 5.5–5.6.
E.1. Fair frozen-planner ranking
Table 9 freezes, for each environment, a planner whose MuJoCo ground-truth success is at least , then evaluates Oracle+Induced under the same settings. The reported ratio is induced success divided by MuJoCo success. Cube uses the same expert-macro library for both MuJoCo and induced scoring.
| Env | Planner | Budget | MuJoCo | Ind. | Ratio |
|---|---|---|---|---|---|
| Two-room | CEM | , | 100 | 96 | 0.96 |
| Reacher | CEM | frame; , ; finger | 100 | 72 | 0.72 |
| PushT | CEM-MPC | , | 96 | 22 | 0.23 |
| Cube | Library | , , 400 macros, | 94 | 86 | 0.91 |
E.2. Planner protocol for main-table cells
Table 10 lists the observation source and success rate for each main-table cell under the frozen settings of Table 9. Under induced scoring, candidates are ranked with induced code only; under hybrid scoring, the top 30% are re-scored in MuJoCo for CEM environments; under sim scoring, ranking uses MuJoCo alone. Code baselines use the Oracle+Induced planner settings with induced scoring.
| Condition | Two-room | Reacher | PushT | Cube |
|---|---|---|---|---|
| Tool+Induced (tool / ind.) | 96 | 60 | 22 | 66 |
| Tool+Hybrid (tool / hyb.) | 100 | 70 | 88 | 78 |
| Oracle+Induced (oracle / ind.) | 96 | 72 | 22 | 86 |
| Oracle+Hybrid (oracle / hyb.) | 100 | 100 | 96 | 84 |
| MuJoCo+CEM (sim / sim) | 100 | 100 | 96 | 94 |
E.3. Cube planning ladder (, seed 42)
Table 11 decomposes Cube performance under the frozen library-shoot planner. Planning rates match the corresponding cells of Table 1.
| Condition | Succ. | Tool RMSE |
|---|---|---|
| LeWM (RGB) | 74 | — |
| Tool+Induced (fair library) | 66 | 0.08 |
| Tool+Hybrid | 78 | 0.08 |
| Oracle+Induced | 86 | — |
| Oracle+Hybrid | 84 | — |
| MuJoCo+CEM | 94 | — |
E.4. Reacher: fingertip versus joint-angle success
The main-table Reacher protocol uses frame CEM with finger_match (fingertip-to-target distance below ). Table 12 reports a coarser macro-MPC sensitivity analysis on the same starts (seed 42). Under , both metrics remain low.
| Condition | finger_match | qpos_match |
|---|---|---|
| Tool+Induced | 4 | 2 |
| Tool+Hybrid | 6 | 0 |
| Oracle+Induced | 8 | 8 |
| Oracle+Hybrid | 14 | 4 |
| MuJoCo+CEM | 16 | 4 |
| LeWM (RGB, latent goal image) | 86 (LeWM suite) | |
E.5. Reacher: frame MPC multi-seed results
Table 13 pools five frame-MPC seeds under the main-table settings. Tool+Induced attains 61.2% [55.0, 67.0] and Tool+Hybrid attains 74.4% [68.6, 79.4], compared with macro-MPC means near 6% in Table 12.
| Condition | Mean SD | Pooled 95% CI |
|---|---|---|
| Tool+Induced | 61.2 5.2 | [55.0, 67.0] |
| Tool+Hybrid | 74.4 4.8 | [68.6, 79.4] |
| Oracle+Induced | 76.0 3.2 | [70.3, 80.9] |
| Oracle+Hybrid | 100.0 0.0 | [98.5, 100.0] |
| MuJoCo+CEM (frame, warm) | 100.0 | — |
E.6. Two-room scoring landscape
We illustrate the scoring-landscape analysis of Section 5.5 with a single-environment case. The Two-room induced model is a linear ridge map with no wall, door, or collision term. Imagined trajectories therefore pass through walls, and the induced score varies smoothly with actions. MuJoCo scoring instead exhibits a near-discontinuity at walls through clamping and penalties, which macro rollout (, frameskip ) amplifies. Under the matched CEM shell (, seed 42, ), MuJoCo+CEM reaches 100% and Oracle+Induced reaches 96% (mean goal distance ; success radius ); both Oracle+Hybrid and Tool+Hybrid reach 100%. Hybrid scoring yields similar gains in contact domains elsewhere, raising PushT from 22% to 88% and Cube from 66% to 78%.
Appendix F Reproducibility and Multi-Seed Intervals
Release.
Code, configuration files, and evaluation scripts will be released with the camera-ready version. Evaluation uses the frozen planners in Table 9, with 50 starts per seed, seed 42 for the main table, and the multi-seed intervals below.
Multi-seed confidence intervals.
Main-table cells are seed-42 point estimates () so that VPW and the code baselines share evaluation starts. Table 14 reports five-seed results under the same frozen planners. Oracle+Induced attains a suite mean of (seed-42 suite mean ); PushT remains near under induced-only scoring and rises to under hybrid scoring. MeanSD is computed across seeds; Wilson 95% intervals pool trials per row. Corresponding Reacher frame Tool/Hybrid intervals appear in Appendix E.5.
| Condition | Seeds | Mean SD | 95% CI |
|---|---|---|---|
| Oracle+Induced | |||
| Two-room | 42–46 | 94.8 2.3 | [91.3, 96.9] |
| Reacher | 42–46 | 76.0 3.2 | [70.3, 80.9] |
| PushT | 42–46 | 19.6 3.3 | [15.2, 25.0] |
| Cube | 42–46 | 79.6 8.3 | [74.2, 84.1] |
| Suite mean | 42–46 | 67.5 1.5 | — |
| Tool/Hybrid conditions | |||
| Two-room Tool+Hybrid | 42–46 | 100.0 0.0 | [98.5, 100] |
| Two-room Oracle+Hybrid | 42–46 | 100.0 0.0 | [98.5, 100] |
| Two-room MuJoCo+CEM | 42–46 | 100.0 0.0 | [98.5, 100] |
| PushT Tool+Hybrid | 42–46 | 95.2 5.0 | [91.8, 97.2] |
| Cube Tool+Hybrid | 42–46 | 83.2 6.7 | [78.1, 87.3] |