ExoPredicator: Learning Abstract Models of Dynamic Worlds for Robot Planning
Authors: Yichao Liang
Thanh Dat Nguyen
Cambridge Yang
Tianyang Li
Joshua B. Tenenbaum
Carl Edward Rasmussen
Adrian Weller
Zenna Tavares
Tom Silver
Kevin Ellis
Venue: ICLR 2026 Poster (2026)
Keywords: learning abstractions for planning
neuro-symbolic ai
concept learning
Primary area: neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)

Abstract: Long-horizon embodied planning is challenging because the world does not only change through an agent's actions: exogenous processes (e.g., water heating, dominoes cascading) unfold concurrently with the agent's actions. We propose a framework for abstract world models that jointly learns (i) symbolic state representations and (ii) causal processes for both endogenous actions and exogenous mechanisms. Each causal process models the time course of a stochastic cause-effect relation. We learn these world models from limited data via variational Bayesian inference combined with LLM proposals. Across five simulated tabletop robotics environments, the learned models enable fast planning that generalizes to held-out tasks with more objects and more complex goals, outperforming a range of baselines.

Published as a conference paper at ICLR 2026
EXOPREDICATOR: LEARNING ABSTRACT MODELS OF DYNAMIC WORLDS FOR ROBOT PLANNING
Yichao Liang!? 1.2 Dat Nguyen', Cambridge Yang", Tianyang Li², Joshua B. Tenenbaum",
Carl Edward Rasmussen', Adrian Weller Zenna Tavares?, Tom Silver Kevin Ellis
University of Cambridge, Basis, *Cornell University, *Princeton University, "Massachusetts Institute of Technology. "The Alan Turing Institute, !co-advising
ABSTRACT
Long-horizon embodied planning is challenging because the world does not only change through an agent's actions: exogenous processes (e.g., water heating. dominoes cascading) unfold concurrently with the agent's actions. We propose a framework for abstract world models that jointly learns (i) symbolic state rep- resentations and (ii) causal processes for both endogenous actions and exogenous mechanisms. Each causal process models the time course of a stochastic cause- effect relation. We learn these world models from limited data via variational Bayesian inference combined with LLM proposals. Across five simulated tabletop robotics covironments, the learned models enable fast planning that generalizes to held-out tasks with more objects and more complex goals, outperforming a range of baselines.
INTRODUCTION
For an agent think about the future consequences of its actions, does it need simulate the world pixel-by-pixed frame-by-frame, or can it reason more abstractly? Consider planning flight to an- other country: we can reason about buying tickets, changing airplanes, and crossing borders without committing to the color of the airplane or the milliseconds before takeoff. Absent abstraction, plan- ning over long time horizons would be intractable, because every minute detail of the world would need to be simulated. This intuition is captured by abstract world models, (Konidaris) 2019 Wong et al. 2025) which retain information essential for decision-making while hiding irrelevant details.
Recent work on learning abstract world models (e.g., (Liang et al., 2024 Athalye al. 2024 assumes that the world changes only by direct, instantancous actions. But in the real world, our actions are not instantaneous, and only half the story: the external world has its causal mechanisms, which unfold continuously in time concurrent with our own actions. For instance, consider boiling water (Figure D. After switching on kettle, the water's temperature continuously rises independently of the agent's 's subsequent actions until it finally boils. A good abstract world model must therefore abstract not just the states, but also the temporal granularity: decision-maken should know that switching on kettle triggers another causal mechanism, which eventually results in boiling, without reasoning about the exact timecourse of the water's temperature (i.e., robot could chop vegetables while waiting for the water to boil). Such abstraction is conceptually separate from pptionn/skillsshihh-eeee actions, which abstract the timecourse of one's own actions, but do not abstract the timecourse of external causal processes in the outside world.
The standard planning representation used for decades, PDDL, also fails to capture this: classi- cal PDDL treats actions instantaneous; while PDDL 2. (Fox & Long. 2003) adds durative ac- tions, it still does not explicitly model autonomous exogenous processes without extensions such as PDDL+(Fox & Long 2002). Learning symbolic PDDL planning model (Silver et 2023 Liang et al. 2024) combinatorially explodes with respect to temporal granularity. Vision- langunlanggagee models
(VLMs) and vision-languaae-action models (Team al. 2023 Black et al. 2025) could in princi-

---

Published as a conference paper at ICLR 2026
Abstract Plan:
Jug Filling
Endingtious actions concummnt ssagenout processas
Burner Preheating
Water Heating
Switch on Faucet
Swittch on Burner
Wait
Switch Off Faucet
Move Jug to Burner
Wait
Gost Bail Watter
Dynamic environments include both endogenous processes (actions under the agent's direct control, such as Switch On Faucet) and exogenous processes (e.g., Jug Filling with Water) that evolve on their own. Planning requires reasoning about both kinds of processes.
Figure I:
ple reason about external causal mechanisms, but generalize poorly to novel situations, particularly when reasoning about temporal physical constraints.
To address these challenges, we introduce framework for learning world models that abstract both the state space, and the timecourse of causal processes. We contribute the following: (1) symbolic yet learnable representation of abstract world models for environments with temporal dynamics and external causal processes. (2) A state abstraction learner that leverages the commonsense knowledge of foundation models. (3) An efficient Bayesian inference method for learning the parameters and structures of these causal models. (4) A fast planner for reasoning with the proposed representation.
BACKGROUND AND PROBLEM FORMULATION
We consider learning abstract world models for robot planning in environments whose causal mech- anisms include both the agent's own action space, and external mechanisms directly under the agent's control. The actual environment operates frame-by-frame exposes a state space with object tracking features and pixel-level visual appearance thigh-resolution perception). We assume built-in motor skills, such as Pick/P lace, common assumption (Ku- mar al., 2024 Silver et al. 2021). The goal to learn world model abstractly describing the timecourse of causal processes, and to generalize to held-out pacision-making tasks.
(high temporal granularity), and
Environments. environment is a tuple (X' 24, C, f. A) where X' is state space, C R" is low-level action space (e.g. motor torques), C is set of controllers for skills (e.g. P Pick/Placee transition function, and
f: x U
set of object types (object classifier outputs).
Tasks. Within an environment, task T is tuple (O, To, g) of objects O initial state and goal g. The allowed states depend on the objects O, so we write the state space as Xo (or sometimes just X' when the objects clear from context). Each state Xo includes associated object features, such as 3D object position. The environment is shared across tasks.
3 ABSTRACTING STATES, TIME, AND CAUSAL PROCESSES
Environments present a high-dimensional observation space that evolves frame-by camne-b--rrame. frame. Abstract world models hide this complexity behind stale abstraction, which distills small set of features from observations, together with causal processes, which describe temporal dynamics (Figure 2b.
State Abstraction with Predicates. A predicate vi after being parameterized by specific objects - is Boolean feature of states. A predicate is represented as Python function that queries a VLM inspect the robot's visual input. We treat this as function objects predicts whether predicate holds in a state. A set of predicates V induces an abstract state corresponding all the predicate/object combinations (ground atoms) that hold that state:
m (X' + B) that given m
= ABSTRACT (x) {(), 01, ..., 0m) o6(0, Oml) holds in state x, for & E and oj E O}
Thus abstract state is the collection of symbolic facts the agent believes about the world. This style of state abstraction standard robot task planning (Garrett et al. 202I). We write S for the set of possible abstract states.
2

---

Published as a conference paper at ICLR 2026
Causal Processes: Temporal Abstraction
EndogenousPracess Swittchurnnernn [robot.
SwitchBurnerOn delay
Timeline
Precondition:: [BumerOffibrneer, HandEmptyrobors) Add Effects: (Burnrönsburmer]
[BurnerOf(bbrrer]]
Strength: 1, 1,555
Dalay Distribution: DicceaaaussianDellyy...... 6.7500)
Option Spec: SwitchhBunerOntrrdie
EvegenousProeesse Filliatee
faucett) conditions overall: (FaucetOnifaucet, jugatFaucetjjug faucetil
[FauretOnttauced,
jug]:
FillWater delay
Add Effects: [jugtsull(juil
Strength: 1,2791
Switchh Burner On
Walt Do Nothing
Delay Distribution: DicceteGaussinneelayyB... 6.7873)
FaucetOn. BurnerOff,
FaucetOn. BurnerOn,
FaucetOn, BurnerOn. Filled,
Predicates: State Abstraction
filleristate: Sequence(Object)- bool:
objects:
import VLMM
abstract
obstract
abstract
pot, objects
abjects([pot) return L. Lvvvvllato simple assertion
attantion
Plpptt is filled with water.", attention_image)
def fauces on(state, ...b def burner onjstate,
Import VLM
Import VLM
Figure 2: Raw input maps to a state abstraction via predicates: short Python programs detecting binary features. Learning the state abstraction means synthesizing these programs. Temporal dy- namics of abstract states are governed by causal processes: either endogenous processes (actions), or exogenous processes in the outside world. Causes realize their effects only after delay, and can be interleaved. Learning causal processes allows planning by breaking frame-by-frame dynamics into discrete jumps between abstract states. (Illustration simplified; see text.)
Informal intuition. A causal process coarsely models cause-effect relation. For example, opening faucet above bucket triggers chain of cause-effect relations: a stopper opens, hidden pipes fill with water, water rises in the bucket, and eventually the bucket is filled. For decision making, many such details are irrelevant, or omitted from the state abstraction. A causal process therefore abstracts away such details by saying that certain conditions (the "cause") later lead to other conditions (the "effect"). We further distinguish two kinds of causal processes. Endogenous processes correspond the agent's high-level actions or skills. They represent operations that under the agent's 's direct control, such as switching faucet on. Exogenous processes describe the background dynamics of the environment. They represent processes that unfold autonomously once certain conditions hold, independent of whether the conditions were created by the agent or by some external mechanism, such as a kettle filling with water after being placed under running tap. This separation allows the agent to reason about the consequences of its actions while also anticipating changes initiated by the environment itself. Figure 2 (top right) shows concrete examples of such causal processes (e.g., switching burner on, filling jug), with their conditions, delayed effects, and whether they are endogenous or exogenous
Causal Processes:
Causal Processes: Formalization. Abstract world models are equipped with set of causal pro- cesses L. Each causal process L E defined by a schema tuple, (PAR, C, O, E, W, pdelay) (see fig. 2
top right, for concrete schema examples), where:
PAR (parameters) a list of typed variables present the condition or effect the process.
C is the condition start, set of atoms that must be true for the process to be activated.
O is the condition overall, set of atoms that must remain true throughout the process's 's duration.
the effect, an add and delete set of atoms describing the state change upon completion.
'Our terminology differs from standard definitions in causality (Pearl 2009) and recent RL literature (e.g.. Efroni et al. (2021)), where "exogenous" typically refers variables that are determined outside system or are irrelevant to the task. In contrast, our exogenous processes are task-relevant and can be triggered by the agent (and are thus causally downstream), but differ in that they evolve autonomously without requiring continuous agent actuation. This aligns with the definition of "processes" in temporal planning frameworks like PDDL+ (Fox& & Long 2X22
3

---

Published as a conference paper at ICLR 2026
W E R (log strength) quantifies how likely the effect will happen when the conditions satis- fied.
pllay is probability distribution over the delay between the process's activation and effect (Ap- pendix
Endogenous processes further include a skill c E C. schema is instantiated into ground causal process L = (PAR, C, Q. E. W, p'kluy (and optionally g) by substituting its parameters with specific objects. For example, the endogenous process Swit thitchhuure Bureron has parameters ? Probot and ?burner. Its condition C' requires that the burner is off and the robot's hand is free. Once executed, its effect E (the burner being on) occurs after a delay sampled from pdelay.
Interdependence of state abstraction and causal processes. The right abstractions depend on downstream tasks, as our goal is generalization to unseen planning problems. Tasks demanding a more detailed state abstraction will generally require modeling more temporal dynamics. This couples the causal processes to the state abstraction.
Probabilistic Semantics. The causal processes define how abstract states evolve over time, Math- ematically, defines a probabilistic generative model over sequences of abstract states {s; fine- grained timesteps t E N. At each step, active causal processes contribute pressure for their effect atoms to change, while a separate frame term prefers all atoms to remain as they are. To write this compactly, we use indicator functions for the conditions al start: C1(81:)) is iff all atoms in the condition-at-star set of ground process are satisfied at state 8, but not satisfied at state 81-1, and 0 otherwise; similarly, (2(sc+1-11) is iff all atoms in the overall-condition set O hold at every step between + and 1. We probabilistically model the effect of ground process as a potential Ey upon each feature j of the abstract state:
WL s
if E EI.Add i Del otherwise.
log Ey
WL (1 - 88)
We similarly define frame axiom potential log F(s/1//11) = WP x s/ = which encour- ages states to stay constant over time; WF is a learnable parameter. Because causal processes have stochastic delays, we associate each ground causal process L with random variables (A+) for the delay should the process trigger time t, i.c. A PL distribution over delays and abstract states is
delay With these definitions in hand, the joint
p( ( Ia
so)
II 8t sca, (A II II( (I(())))))
(autoregressive)
p see (A = II p { sel, scn (1))
(next-state factorizes over features)
p (ss) sees (A F(s
II Ey (s/ 1ed
(cause-effect)
LEC P<t
pl p(At1sg)) Pr.
delay (At)
(delay distribution for when condition at start holds)
But this formalization simulates every fine-graing timestep: reasoners should abstract away tem- poral details like the milliseconds before domino falls. We describe next how to do that.
4 PLANNING WITH CAUSAL PROCESSES
We model the world as changing abruptly in discrete "jumps" between abstract states. Planning can clump together stretches of time where the abstract state remains constant. We define a big-step transition function, Toig. which runs the world model until the abstract state changes, and optionally takes as input an action to initiate. The agent doesn't 't always need to manipulate an object directly; can also choose to wait for exogenous process to unfold on its own (such waiting for water to
4

---

Published as a conference paper at ICLR 2026
Online Learning Algorithm
Learned Model:
üuglattes, Jugbifully
iteration
Plan after learsing: Pickyeboc, jugtt Pacejabot (ight hucee! Pickyoboc jugó, Rucet)
Learne precess:
ExoFracesoi ExsProcenst::
Conditions: (BunerOftbe)) juphttunerbaa, balt, jighsulthhs, juglsHothhan
Explore/Interact via Planning with existing model
Eftects: MumanilapyDiz, 74, 7500)
Water Spilled!
DIf Learned Modet
iteration
-Leamed predicates: (ugisHer,
(iggsee_jgghull,, JeghPull, Neckyillnn)
beff after Sertonnninotio frucen Pidembal, 2e0 facced *SwarhOniisbet hucedd swiichd-jrabcl burnett)) +9wachomtybbt Sauceo
Leamed process:
ExpProcess2 (bo), h2. hXS
Condition:: [Burnen (umnrorim-,,, pephttarmentha, 7001, jughteutcchh Jughslleshh00
Learn Predicates, Processes Parameters
Conditions start (Buneroffthon,, (ugls jiglo Macspilllggxat) And Effects: Humanttapppyha, hd,, helll tifects.
ExoFracesc (hx1)
Conditions (PeacetOniaat), MajughhteusetiPet Nottptlinghhet
Effects:
No Water Spilled!
Delece Offects: Diedsplllegh111
The online learning loop, where the agent repeatedly uses its current model to plan and interact with the world, then refines that model by learning new predicates and causal processes from the experience. The figure shows example where the agent's 's initial model in iteration i leads to failed plan (Water Spilled!). After observing this failure and updating its knowledge ("Diff Learned Model"), the agent creates successful plan in iteration
Figure 3:
("Diff plan after learning").
boil). The agent achieves this by initiating special NoOp (no operation) action, which terminates as soon as the abstract state changes. Formalizing Toig is relatively technical; see Appendix A..
This big-step function allows planner to perform forward search in the space of high-level tions, simulating the concurrent and delayed effects of both its own actions and the environment's exogenous dynamics. Given causal processes L. and task, the agent performs A search over quences of ground endogenous processes. The search uses Thig to determine successor states and we design version of the fast-forward heuristic (Hoffmann) 2001 guide the search (Appendix(A.2) A.2
5 PROCESS LEARNING AND PREDICATE INVENTION
Our goal is to learn how the outside world works: we assume an unfamiliar environment, but not an unfamiliar body. We therefore equip the agent with some basic predicates (such whether holding an object) and endogenous causal processes defining its own action space, such as Pick/Place (Appendix B and learn the remaining causal processes and state abstractions.
We initialize with 1-2 demonstration trajectories, and then perform online learning (Figure B On- line learning involves planning solve training tasks collect further trajectories (when planning fails, random actions are taken). At each stage of online learning, we have a dataset of state-action trajectories Diow {(Z0, Cp:.... Cr- 11--1,100 1....,TT) 2T)). Given predicates V, this generates a dataset of ab- stract state-action trajectories Dats (So, Cy. 1r 1.-1...) ST)]. Given this dataset, we learn predi- cates (Section (.3)p exogenous processes (section 5.2). and continuous parameters (Section 5.1 described in reverse order, because each component is used in the previous component during learning.
5.1 PARAMETER LEARNING VIA VARIATIONAL INFERENCE
Each causal process has continuous parameters for the delay distribution Pf, bilistic weight Wi, and we have a global parameter WP for the frame axiom. Fixing all dis- crete structure including the predicates we seek parameters maximizing the marginal likelihood p(Dam)) = p(s1=ll0)) [{tt.) p(s (A so). This is intractable because there are combina- torially many ways of timing the cause-effects.
delay and the proba-
We therefore approximate the marginal likelihood by introducing variational distributions over the time at which each process realizes its effect: categorical distribution of encodes belief about Aft the "arrival time" of the effect coming from the process L due to its activation time This a change of basis from delays to absolute times, A/ = A + t, which leads to a tidier ELBO decomposition. We provide the full expression and derivation of the following variational lower
5

---

Published as a conference paper at ICLR 2026
bound on the marginal likelihood in Appendix A.3 log 1(s1() 2 By [log(((A5))
which optimize using Adam (Kingma 2014).
Bg
log log (((s)) {A+)
+ Hg (AF)
delay model
abstract dynamics
entropy regularizer
5.2 LEARNING EXOGENOUS PROCESSES: BAYESIAN MODEL SELECTION, LLM GUIDANCE
We learn causal processes by assuming a fixed set of predicates v (which fixes the abstract state space Sy); segment the trajectories into shorter clips, where each clip consists of sequence of constant abstract states followed by a final state in which one or more atoms change value; cluster segments according to which features in the abstract state were changed; then learn one process per cluster by optimizing Bayesian criteria. To make optimization tractable, we use an LLM to propose different symbolic forms for processes and then score them with Bayesian objective.
Given a set of trajectories Dahe. we would ideally learn the causal processes L maximizing
C = arg max p(C arg max ((D p(Pat:)
(intractable)
C
where p(C) is minimum description length prior and (D (C (2) is approximated by Section 5.1 As this optimization is intractable, we learn a separate process Le for each cluster C:
U
{Le}
where Le arg max
(still intractable)
(ECLUSTER((PM.)
But computing arg max, (LL) means optimizing over combinatorially many discrete struc- tures for L. To narrow down the discrete search, we prompt language model with the cluster and ask to propose a small number candidate processes:
-==
U
{Lc}
where Lc max L)C)L) LÉPROMPT(C)
(tractable)
(ECLUSTER(P
Appendix A.4 fully specifies this algorithm, which builds on Chitnis et al. (2022).
5.3 LEARNING STATE ABSTRACTIONS: PROGRAM SYNTHESIS AND LOCAL SEARCH
The abstract state space is defined by a collection of short Python programs (predicates) which check for abstract feature within the raw perceptual input. Learning the state abstraction therefore means synthesizing that set of programs. One strategy for learning the predicates is to propose a large set of candidate predicates and then use discrete search select subset optimizing certain objectives (Silver et al., 2023) In our setting, we propose predicates by prompting an LLM with trajectories, and seek a subset of those predicates, Vr*,, maximizing:
V
aig max VEP(PROMPT((..))
p(Diow L (V)))((C((()))))
where P (+) is the powerset, p( is prior favoring fewer predicates, and we have made explicit the dependence of L upon the predicates V (Section 5.2p. But the above objective intractable for
two reasons, which we address as follows (Appendix A.5
Expensive outer loop:
The powerset exponentially large. Rather than exhaustively enumerate every subset of predicates, we do a local hill-climbing search starting from v Ø and greedily adding new predicates from the LLM (Silver et al. 2003).
Expensive inner loop: Scoring candidate subset of predicates is expensive, requiring varia- tional inference and causal process structure learning (Sections 5.1 and 5.2p. We therefore run structure learning and parameter estimation only once, using all proposed predicates, and cache the resulting processes and parameters for reuse when scoring different subsets of predicates.
6 EXPERIMENTS
We design our experiments to answer the following questions: (Q1) How does ExoPredicator per- form compared to state-of-the-art methods, including hierarchical reinforcement learning (HRL..

---

Published as a conference paper at ICLR 2026
Coffee
Grow
Boil
Domino
Fan
Train Tasks
Eval. Tasks
Figure 4: Environments. Top row: train task examples. Bottom row: evaluation task examples.
Successful Task Solving Trajectory in Domino and Fan
ExogenousProcess [2x1, 2x2, 2x3]:
Conditions: [IFFrontirectionnxx1, 2x3), NOT-Islmmovable 2x1), Tilting(?x1), Upright(?x2))
ExogenousProcess [?x0, 2x1, 7x2, 7x3, 2x4, 2x5]:
Conditions: [BallAtLoc(2x0, 7x3), ClearLoc(Xx4) FanFaces|7x1.2 FanOff(xx2) FanOn(2x1), SideOf(2x4, 2x3, 2x5)
Add Effects: [Tilting(xx2)
Delete Effects:
Add Effects: [BallAtLoc(xx0, ?x4)] Delete Effects: [BallAtLoc(2x0,, 2x3)]
Figure 5: Successful ExoPredicator trajectories in the Domí no (top) and Fan (bottom) environ- ments. The code highlights the key learned exogenous processes, describing how dominoes cascade and how the fan's wind moves the ball. These processes incorporate predicates invented by the agent, like NOT- Is Inmovable and FanFaces which enable efficient and effective planning.
VLM planning, and operator learning approaches, in terms of overall solve and sample effi- ciency? (Q2) How do the learned abstractions perform relative to manually engineered abstractions, and relative the case where learning performed? (Q3) How useful are the Bayesian model selection and the I.L.-guidance components in model learning?
Experimental Setup. We evaluate eight approaches across five simulated robotics environments, illustrated in Figure 4 using the PyBullet physics engine (Coumans & Bai] 2016). All results are averaged across five random seeds. For each seed, we train the agent with one or two training tasks, each of which includes one demonstration. We then evaluate their performance on 50 held-out test tasks, which include more objects and more complex goals. In each online learning iteration, the agent performs rollouts in training task with each rollout lasting maximum of 300 timesteps.
We describe the environments and their corresponding predefined closed-loop skills, which shared across all approaches. All environments have NoOp skill in addition to the ones listed for each environment. See Appendix for more details.
Environments.
1. Coffee. The agent is asked to fill the cups with coffee. To do so, the agent needs first to get coffee from the coffee machine, then pour it into cups, both of which are exogenous processes. The environment provides 4 skills: P Pick, Place, Push, and Pour.

---

Published as a conference paper at ICLR 2026
2. Grow. The agent is tasked with watering plants in pots. A plant will only grow when watered by a jug that has the same color as its pot. The provided skills include P Pick, Place and Pour.
3. Boil. A cooking domain where the agent is asked to fill jugs with water using the faucet and boil it with the burner, without overspilling any water, which may happen when the faucet on and no jug is under it or the jug underneath is full, which are all exogenous processes. Four skills are defined in this domain, including F Pick, Pla Place, and Switch On/Off.
Domino. A domino puzzle environment with two types of tasks. The agent is tasked to only move the blue dominos and push the green dominoes such that all the purple target dominoes are toppled. Additionally, there are "impossible" tasks, where there are red target dominoes whose mass is too large be toppled in cascade. Impossible tasks are "solved" if the agent predicts that the goal is unachievable. Inter-domino dynamics are exogenous processes. The included skills are Pi ck, Pl Place, and Push.
Fan. A maze environment where ball blown by fans. The agent must control the fans in each cardinal direction to move the ball to the green target location while avoiding obstacles. The provided skills are turning the Switch On/Off.
Approaches.
Manual. A planning agent with manually engineered predicates and processes for each domain.
2. Ours. Our ExoPredicator approach.
3. MAPLE (Nasiriany et al., 2022). An HRL baseline that learns to select ground controllers by learning an action-value function, but does not explicitly learn abstract world models and perform lookahead planning. This approach is provided with 1000 training tasks and given a budget of 10000 interaction rollouts per online learning iteration.
4. ViLA (Hu et al. 2023). A VLM planning baseline that prompts a VLM (Gemini-2.5-Prro to plan sequence of ground skills. We experiment with variants, which either exclude (zero-shot; zs) or include (few-shot; fs) the demonstrations. Both this and MAPLE are provided with the full set of predicates in Manual, which they can use termination conditions for the NoOp action.
5. VisPred (VisualPredicator) (Liang al. 2024). An online STRIPS-sty/ operator learning and planning agent. We provide it with all the necessary predicates used in Manual, which sidestep the challenge of predicate learning, to highlight the difference between our causal processes representation with traditional STRIPS-style representations.
6. No Bayes. An ablation that uses LLM to learn processes without Bayesian model selection.
No LLM. An ablation that replaces the LLM condition proposer with a fast-to-compute heuristic. Note that we still use an LLM for predicate proposal.
8. Manual-d (Manual minus tuned delay parameters). A planning agent that uses the Manual abstraction, but has the same delay parameter (e.g.. 1) across all processes.
9. No invent. An ablation that uses the initial abstractions and does not perform any learning.
Results and Discussion. Isows the evaluation solve rate for all approaches and the learning curve of our online learning agents.
(Q1). Our approach consistently outperforms the VLM planning (ViLa), HRL (MAPLE) and STRIPS-style operator learning and planning (VisPred) approaches, achieving a near-perfect score across all domains. For each environment, ExoPredicator learns 1-4 exogenous processes and con- verges after at most three online interaction iterations (fig. 6b). Once trained, it can solve nearly all tasks in Coffee, Domino, and Fan, and over 80% in Boil and Grow. comparison, we find that MAPLE is unable to achieve a high level of success even with 1000 times more interactions and evaluated only on the training distribution. We hypothesize that this is largely due to the chal- lenge of exploration with sparse rewards. ViLa (zero-shot) was not able to do well in any domains. The few-shot variant achieves good performance in simple domains where satisficing plans share significant similarity with the demonstration plan (e.g., in Coffee, one simply needs to perform Pour and NoOp more times than in the demonstration). We observe that its performance degrades significantly in other domains where it must identify additional rules through trial and error (c.g., the requirement of matching colors in Grow) or domains that require compositional generalization (sequencing skills in potentially new ways). VisPred also struggles in these tasks because it learns
8

---

Published as a conference paper at ICLR 2026
Coffee
Grow
Boil
Domino
Fan
Manual
(14
LIM
Nemusid
20
40
60
80
100
20
80
100
20
40
60
100
20
60
60
100
20
80
80
120
(a) Percentage solved in different domains (1) by different agents.
Coffee
Domino
Percentage Solved
75
25
10 Online Learning Iteration
10
Online Learning Iteration
Online Learning Iteration
Online Learning Iteration
Online Learning Iteration
Manual
MAPLE
Ours
VisPred
(b) Learning curves different online learning agents.
Figure 6: Performance metrics for various agents across different domains. The error bars/shaded regions show + standard deviation.
in a highly constrained model space. It attempted to learn the exogenous processes as different op- erators for the NoOp skill, but fell short due an overly strong inductive bias. This bias restricts preconditions to only include atoms with variables already present in an operator's effects or option, which especially limiting for the NoOp skill, where "robot" is the only variable. Moreover, does not learn about the varying delays for different processes, feature crucial for effective and efficient planning (e.g., Boil). 1). note that ExoPredicator is unable to solve all tasks Boi 1, partly because it failed to recognize the full disjunctive condition under which spill can happen: learned a process for water spilling when there is nothing under the faucet, not when the jug underneath is full.
(Q2). Ours achieves the same (in Coffee and Fan) or better (in Grow and Domino) performance as Manual which uses manually engineered abstractions. We attribute this the parameters learned via variational inference instead of being manually tuned. Furthermore, the near-zero performance of No invent and Manual-d underscores the importance of model learning and parameter learning. For example, in Domino their incomplete knowledge of the environment's dynamics and delay caused them classify
tasks unsolvable.
(Q3). Both the Bayesian model learning and the LLM guidance play a critical role efficient, effective, and robust model structure learning. Without LLM guidance, the size of the search space for each process becomes astronomically large (sometimes reaching 25"), making it intractable to score all possible conditions. Without computing the Bayesian posterior of the data and model, the selection is based entirely on the prior in the LLM,, which is not always reliable, especially with uncommon or unseen environment dynamics.
RELATED WORKS
Temporal Planning. Classical planners handle effects after a delay with durative actions (PDDL 2.1) (Fox& & Long (003) and with autonomous processes and events (PDDL+) (Fox & Long 2002): (RDDL. (Sanner et al. 2010), while heuristic search-based temporal planners such as COLIN (Coles et al.) (0122) or OPTIC (Benton et al. 2012) support numeric fluents and deadlines. These works assume the full domain description is given. Our contribution complementary: we learn models models-including conditional stochastic delays directly from small number of trajectories.
Hierarchical Reinforcement Learning. HRL uses temporally extended actions to address long- horizon decision-makee making (Barto & Mahadevan 2003). While many skill-leaming approaches exist, they typically adopt the (semi-) Markov assumption at the option level: the distribution over out- comes depends only the initiation state and the chosen option Masson al. 2016 Nasiriany

---

Published as a conference paper at ICLR 2026
et al. 2022 Mishra et al. 2023). This fails to explicitly model exogenous dynamics variable delays, attributing all changes to the agent's actions. We relax this assumption by learning a model for these external dynamics and stochastic delays, allowing fixed set of skills to be flexibly used as the environment evolves.
Hierarchical Reinforcement Learning. HRL temporally extended actions address long- horizon Decision-making (Barto & Mahadevan 2003). While many skill-learnigg approaches exist, they typically adopt the Markoo assumption the option level: the distribution over out- comes depends only on the initiation state and the chosen option (Masson et al. 2016 Nasiriany al. 2022, Mishra al. 2023). In such formulations, environment-driven or exogenous dynamics can be absorbed into the option's 's transition model, but are not usually represented as separate causal processes with their own activation conditions and delay distributions. Our approach complemen- tary: we learn an explicit model for these external dynamics and stochastic delays, allowing fixed set of skills to be used more flexibly as the environment evolves and enabling more generalizable planning.
Large Foundation Models for Robotics. Approaches such as SayCan (Ahn et al., 2022). RT-2
(Brohan et al. 2023), Inner Monologue (Huang et al. 2022), Code-as-Policy (Liang et al. 2023).
ViLA (Hu et al. 2023), and To (Black et al.) (025) treat planning as prompting: a pretrained LLM/VLM selects synthesizes the next action each step. These approaches inherit strong laagual- priors, but-because they do not learn a world model-struggle to reason about concurrent processes (e.g. water keeps heating) about actions whose effects materialize only if certain conditions persist. Our method calls foundation models for predicate invention (as in Visu- alPredicator) and model learning, yet it grounds their suggestions in experience and learns symbolic world models that supports look-ahead search.
Causal Reasoning and Causal RL. Structural causal models (SCMs) (Pearl 2009) and their dy- namic extensions form the foundation of various recent causal-RL. algorithms (Buesing et al. 2019 Hammond et al. 2023 Zeng al.) 2025). These approaches assume that the underlying causal graph either known or learnable at the feature level, but they do not tackle the challenges of symbolic abstraction or planning over durative processes. In contrast, ExoPredicator learns causally consis- tent SCM (Rubenstein et al. 2017) whose variables are invented predicates and whose mechanisms are the learned causal processes, which enables reasoning at a higher level of abstraction.
Learning Abstractions for Planning. Early work learned STRIPS NDR transition rules from demonstrations given a fixed predicate set (Pasula et al. 2007 Silver et al. 2021; 2022, Chitnis
ct al. 2022). Recent methods invent predicates to improve generalisation (Silver et al.) 2023
Liang et al. 2024); however, they typically abstract dynamics through agent-centric actions, without explicitly modeling exogenous causal processes that unfold time in the background, ExoPred- icator extends predicate-inve invention to environments with exogenous dynamics and delayed causal
effect.
CONCLUSION
We presented ExoPredicator, an integrated approach for learning and planning with causal processes in environments with exogenous dynamics and delayed effects. Our method demonstrates the ability to learn abstract world models from limited data, generalizing to new tasks with unseen objects and goals across various simulated environments, and outperforming key baselines. Future work will scale the framework to more complex, noisier, larger-scale environments, enhance learning with foundation models, and explore the interplay between skill and world modeling.
REFERENCES
Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Chuyuan Fu, Keerthana Gopalakrishnan, Karol Hausman, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.0166) 2022.
Ashay Athalye, Nishanth Kumar, Tom Silver, Yichao Liang, Jiuguang Wang, Tomás Lozano-Péres and Leslie Pack Kaelbling. From pixels to predicates: Learning symbolic world models via pretrained vision-language models. arXiv preprint 20x:125011000294 2024.
10

---

Published as a conference paper at ICLR 2026
Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 13:341-379, 2003.
J Benton, Amanda Coles, and Andrew Coles. Temporal planning with preferences and time- dependent continuous costs. In Proceedings of the International Conference Automated Plan- ning and Scheduling, volume 22, pp. 2-10, 2012.
Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, al. TO: A visionllngguae-acttinn flow model for general robot control. conr, abs/2410.24164 2024. doi: 10.48550. RSS 2025, 2025.
Anthony Brohan, Noah Brown, Justice Carbajal, Yevgen Chebotar, Xi Chen, Krzysztof Choroman- ski, Tianli Ding, Danny Driess, Avinava Duhey, Chelsea Finn, et al. Rt-2: Vision-language-acti models transfer web knowledge to rohotic control. arXiv preprint vrXiv:2307.158/1 2023.
Lars Buesing, Theophane Weber, Yori Zwols, Nicolas Heess, Sebastien Racaniere, Arthur Guez, and Jean- -aan-Baptiste Lespiau. Woulda, coulda, shoulda: Counterfactuullly-uuin policy search. In International Conference on Learning Representations, 2019.
Rohan Chitnis, Tom Silver, Joshua B Tenenbaum, Tomas Lozano-Peree Perno, and Leslie Pack Kaelbling. Learning neuro-symbolic relational transition models for bilevel planning. In 2022 IEEE/RS/ International Conference on Intelligent Robots and Systems (IROS), 416..p....16666661116161 4166-4173. IEEE, 2022.
Amanda Jane Coles, Andrew I Coles, Maria Fox, and Derek Long. Colin: Planning with continuous linear numeric change. Journal of Artificial Intelligence Research, 44:1-96, 2012.
Erwin Coumans and Yunfei Bai. Pybullet, python module for physics simulation for games, robotics and machine learning, 2016.
Yonathan Efroni, Dipendra Misra, Akshay Krishnamurthy, Alekh Agarwal, and John Langford. Provably filtering exogenous distractors using multistep inverse dynamics. In International Con- ference on Learning Representations, 2021.
Maria Fox and Derek Long. Pddl+: Modeling continuous time dependent effects. In Proceedings of the 3rd International NASA Workshop on Planning and Scheduling for Space, volume pp. 34, 2002.
Maria Fox and Derek Long. PddI2. 1: An extension to pddl for expressing temporal planning domains. Journal of artificial intelligence research, 20:61-124, 2003.
Caelan Reed Garrett, Rohan Chitnis, Rachel Holladay, Beomjoon Kim, Tom Silver, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Integrated task and motion planning. Annual review of control, robotics, and autonomous systems, 4(1):265-293, 2021.
Lewis Hammond, James Fox, Tom Everitt, Ryan Carey, Alessandro Abate, and Michael Wooldridge. Reasoning about causality in games. Artificial Intelligence, 2023.
Jörg Hoffmann. Ff: The fostarorward planning system. Al magazine, 22(3):57-57, 2001.
Yingdong Hu, Fanqi Lin, Tong Zhang, Li Yi, and Yang Gao. Look before you leap: Unveiling the power of gpt-4v in robotic vasion-language planning. arXiv preprint 2r 2023.
Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. Inner monologue: Embodied reasoning through planning with language models. arXiv preprint arXiv:2207.050m 2022.
Diederik P Kingma. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 2014.
George Konidaris. On the necessity of abstraction. Current opinion behavioral sciences, 29:1-7, 2019.
Nishanth Kumar, Tom Silver, Willie McClinton, Linfeng Zhao. Stephen Proulx, Tomás Lozano- Pérez, Leslie Pack Kaelbling, and Jennifer Barry. Practice makes perfect: Planning to learn skill parameter policies, 2024.
11

---

Published as a conference paper at ICLR 2026
Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code as policies: Language model programs for embodied control. In 2023 IEEE International Conference Robotics and Automation (ICRA), pp. 9493-9500. IEEE, 2023.
Yichao Liang, Nishanth Kumar, Hao Tang, Adrian Weller, Joshua B Tenenbaum, Tom Silver, João F Henriques, and Kevin Ellis. Visualpredicator: Learning abstract world models with neuro- symbolic predicates for robot planning. arXiv preprint arXiv:2410.23156, 2024.
Warwick Masson, Pravesh Ranchod, and George Konidaris. Reinforcement learning with param- eterized actions. In Proceedings of the AAAI conference artificial intelligence, volume 30, 2016.
Utkarsh Aashu Mishra, Shangjie Xue, Yongxin Chen, and Danfei Xu. Generative skill chaining: Long-horizon skill planning with diffusion models. In Conference Robot Learning, pp. 2905- 2925. PMLR, 2023.
Soroush Nasiriany, Huihan Liu, and Yuke Zhu. Augmenting reinforcement learning with behavior primitives for diverse manipulation tasks. In 2022 International Conference on Robotics and Automation (ICRA), pp. 7477-7484. IEEE, 2022.
Hanna M Pasula, Luke S Zettlemoyer, and Leslic Pack Kaclbling. Learning symbolic models of stochastic domains. Journal of Artificial Intelligence Research, 29:309-352, 2007.
Judea Pearl. Causality. Cambridge university press, 2009.
Paul K Rubenstein, Sebastian Weichwald, Stephan Bongers, Joris M Mooij, Dominik Janzing, Moritz Grosse- Weesse-. and Bernhard Schölkopf. Causal consistency of structural equation mod- els. arXiv preprint 170.v 2017.
Scott Sanner et al. Relational dynamic influence diagram language (rddl); Language description. Unpublished ms. Australian National University, 32:27, 2010.
Tom Silver, Rohan Chitnis, Joshua Tenenbaum, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Learning symbolic operators for task and motion planning. In 202/ JEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 3182-3189. IEEE, 2021.
Tom Silver, Ashay Athalye, Joshua B Tenenbaum. Tomas Lozano-Perte and Leslic Pack Kaelbling. Learning neuro-symbolic skills for bilevel planning. arXiv preprint arXiv:2206. 10680, 2022.
Tom Silver, Rohan Chitnis, Nishanth Kumar, Willie McClinton, Tomás Lozano-Pérez, Leslie Kael- bling, and Joshua B Tenenbaum. Predicate invention for bilevel planning. In Proceedings the AAAI Conference on Artificial Intelligence, volume 37, pp. 12120-12129, 2023.
Gemini Team, Rohan Anil, Sebastian Borgeaud, Yonghui Wu, Jean-Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M Dai, Anja Hauth, al. Gemini: family of highly capable multimodal models. arXiv preprint arXiv:2312.11800 2023.
Lionel Wong, Katherine M Collins. Lance Ying, Cedegao E Zhang, Adrian Weller, Tobias Ger- stenberg, Timothy O' O'Donell, Alexander Lew, Jacob D Andreas, Joshua Tenenbaum, et al. Modeling open-world cognition as on-demand synthesis of probabilistic models. arXiv preprint arXiv:2507.12547, 2025.
Yan Zeng, Ruichu Cai, Fuchun Sun, Libo Huang, and Zhifeng Hao. A survey on causal reinforce- ment learning. IEEE Transactions Neural Networks and Learning Systems, 2025.
12

---

Published as a conference paper at ICLR 2026
CONTENTS
Additional Approach details)
14
A.T
Causal Process Semantics
14
A.2
Fast Forward Heuristic for Causal Processes
15
A.3
Probabilistic Model and ELBO Derivation
16
Process Learning details
18
A.5
Predicate Learning Details
19
Additional Environment details
24
Coffee
24
B.2
Grow
25
B3
Boil
27
4
Domino
29
B.5
Fan
31
Additional Experiment Details
31
Learned Causal Processes
31
Further Learning and Planning Statistics
41
Priors and Distributions
41
13

---

Published as a conference paper at ICLR 2026
A
ADDITIONAL APPROACH DETAILS
A.1 CAUSAL PROCESS SEMANTICS
We formalize the semantics of our causal process model, which underpins the planner described in section 4 We begin by defining small-step transition function that describes the world's evo- lution at the finest temporal granularity, advancing one discrete timestep at a time. This detailed model allows us to precisely specify how and when processes are activated and their effects ap- plied. We then build upon this to define the big-step transition function, Thg. which abstracts away these fine-gnn fine-grained details. This function enables the planner to efficiently jump between significant changes in the abstract state, which is crucial for tractable long-horizon planning.
Small-Step Semantics. We model the world's evolution in discrete timesteps N. A complete snapshot of the world, or the world state, is tuple Wi = (st, Qt, H2), where:
is the set of ground atoms that are currently true.
Qi is the event dictionary, a dictionary of scheduled effects of the form (uar), keyed by their end time fend-
H2 is the history of all past atomic states, [so, 81,...,
The world's fundamental dynamics are defined by a small-step transition function, (wa, + W++1, which advances the world by a single timestep. The transition given potential agent command at (which may be an ground endogenous process or None) occurs in three stages:
1. Event Execution: Effects from events due at time t are applied. We initialize 8141 8ç, For every event (L, tstin) in Q: scheduled for time t, if its overall condition Og held from the step after activation up to the previous step, (i.e., for all s; E H₃ where i tstart, its effects applied: 82+1 < (8t+1 Del) U Add.
Process Activation: New events are scheduled based on the state s1+1 and the agent's command. Endogenous Activation: If the agent issues command a Lez and the process's start con- delay is sampled (with d 1). A new event dition L. is satisfied in St+1, delay d PL..
(Lear 1) added to the queue for time + d.
Exogenous Activation: For every exogenous process Lop its start condition Caan, is satis- fied in 8141 but was not satisfied in the previous state St-1 (i.e., is edge-triggered), delay d ~ PLa is sampled. A new event (Lex 1) is added to the queue for time L d.
State Finalization: The next world state w++1 (St+1, Qo, He U {se)), where Qj is the
updated event dictionary.
define big-step transition function, [ui Lon), which computes the resulting world state after executing single ground endogenous process L starting from world state Wi, or after simply waiting for the world to change (L., = NoOp).
Big-Step Semantics.
This function simulates the environment forward by applying the small-step transition function Tsmall iteratively. The simulation proceeds until the chosen action L has completed or a maximum hori- zon Kmax reached.
The transition Toig(We, L + Wi++ computed as follows:
1. Initialization:
Initialize a step counter: k 0.
Set the initial world state for the simulation: w/ +- wig
The endogenous process Lep is set as the command for the first step. Let the command for step i be denoted ag. So, ax + Len- For all subsequent steps 0, the command is null:
a; f
None.
Simulation Loop: While the action L is still considered active and & < Kmax:
Apply the small-step transition: wh+11 Teman (wk, ax))
Increment the step counter: k 1: 1.
14

---

Published as a conference paper at ICLR 2026
The action Lep simulation. This is tracked implicitly by the simulator state. A special case is the NoOp action, which is considered complete if any atom changes in the state, allowing the agent to wait for exogenous events.
is considered complete if its corresponding event has been executed within the
3. Final State: The resulting world state is the state at the end of the simulation loop: Wh+k < w/.
A.2 FAST FORWARD HEURISTIC FOR CAUSAL PROCESSES
The Fast-Forward (FF) heuristic (Hoffmann) 2001 is domain-independern planning heuristic that estimates the distance to goal by solving a relaxed version of the planning problem. We adapt this heuristic to our causal process framework, accounting for both endogenous and exogenous processes, as well as derived predicates.
Relaxed Planning Graph Construction The FF heuristic constructs Relaxed Planning Graph (RPG) by iteratively applying all applicable processes without considering delete effects. Given state with atoms s, the heuristic proceeds as follows:
1. Initialization: Start with the current atoms augmented with any derived predicates that hold given those atoms.
Forward Propagation: For each layer i:
Find all processes whose C' (condition at start) is satisfied by facts in layer
Add all add effects F.Add from these processes to create layer i (ignoring delete effects F.Del)
Incrementally compute new derived predicates based on newly added primitive facts
Termination: Stop when the goal atoms C layer i, or when a fixed point is reached (no new facts can be added).
Incremental Derived Predicate Computation To efficiently handle derived predicates, main- tain a dependency map from auxiliary predicates to derived predicates. When new primitive facts added to layer,
1. Identify which derived predicates might be affected based on their auxiliary predicate dependen- cies
Incrementally evaluate only those derived predicates on the updated state
Propagate newly derived facts through the dependency chain until fixed point is reached
This avoids redundant recomputation of derived predicates that cannot be affected by the new facts.
Relaxed Plan Extraction Once the RPG is built, we extract a relaxed plan via backward search:
1. Start with the goal atoms subgoals achieve
For each layer from 1:
For each subgoal appearing for the first time in layer é:
it's a derived predicate, replace it with its supporting auxiliary predicates it's a primitive predicate, find a process from layer that achieves it
Add the preconditions of selected processes as new subgoals
Count only endogenous processes toward the heuristic value
Heuristic Value The heuristic value (**(s) is the number of endogenous processes in the ex-
tracted relaxed plan. Exogenous processes are treated as having zero cost, reflecting that they oceur automatically when their conditions met. Formally:
(+) = KL E RelaxedPlan L is endogenous)
This provides an admissible estimate when all action costs are uniform, and guides the search toward states that require fewer agent interventions reach the goal.
15

---

Published as a conference paper at ICLR 2026
Implementation Notes The implementation uses several optimizations:
Add-effect indexing: We maintain a map from atoms to processes that add them, enabling effi- cient backward search during plan extraction
Early termination: If the RPG reaches a fixed point without achieving the goal, we return h = co
Zero-cost exogenous processes: These are included in the RPG construction but not counted in the final heuristic value, allowing the planner to leverage environmental dynamics
A.3
PROBABILISTIC MODEL AND ELBO DERIVATION
The derivation for the probabilistic model is:
p({s,, ), (A+])
= (the law of conditional probability) T
Ir (s,, (1 f
1=1
(the law of conditional probability)
T
(conditional independence of the delay vars.)
T
T
IIII p
(At)os)))
II
1e1811e-1, (
x
1=1
(by the structure of our model)
T
(L4) Pt
delay
πI (=1
1 1(
(8,) Dei II
f-1
Z
t-
4
L F=1
L-1 II
where Z, = Σ ((
(s(s)) Eg
S
#=1
(assume factored state 8t (s...)....))
delay (A
IIII
B ( (lleee
PL
Z
L d'=1
where z
Σ D Dete
E/ES
v==1
With the change of basis, our model becomes:
p([s),, (A+))
T
I
PL
delay
(A 1) C((ene))
x
F(s) s
(5) Dla
z
L F=1
where zi= Σ F(5/15/
II
II
B (8))
C (s (0 )0 10 (2/4=
RES
==1
16

---

Published as a conference paper at ICLR 2026
The derivation for the ELBO is:
logp (1st))
/ (((A)))
= =log
p( (8t), (())) (44))
(((A/1))
p((st). (A(1)
log B,y
a({)t))
p((st). 11(1)
BRg
log
((1411)
-Ba
logp((s<) ((gp((s)),(A+)) + Hl, [Aa3]]
By ((())) log (oel (Ag 11)]
+
expected log delay probability
t
Σ
log
((6((15-1)) + ΣV
Bg (n =0 log (EL(st)
unnormalized expected log state probability
T
J
Big
log
Σ
(a) (t0 F=1
+ +Hlg [(a)]]
EEESS
Z
(reverse bound the expected normalization constant; independence of 1!
(CL()))) By
log PL
delay
(A t))] +
T
log ((6(/1(-1)) +
By (( 1llog [=())
T
log
F(s
Eg (s)) (2l W]las=1]] + Hg [(4)]]
F/ES) = (expand the expectation out independently)
C1(s1))
Σ of (A log
PL
delay (A-
1=1
1-1+1
T
((66/19-11) + Σ>
Σ
(A = 100 log (B2()
log
t=l
Caldea)
log Σ
F(8)
#A =t)
E ((
+ (1-o of -))
Eless
tm
oxp(Ouls log By (8:))
HLg [at)]
17

---

Published as a conference paper at ICLR 2026
Evaluating this objective is computationally intensive due to the nested loops, but can be simplified by some algebraic refactoring. In the first term, the second sum only needs to loop through the non-zero terms, which are laws whose conditions satisfied at time
In the second term, the sum over j and L can be reduced to a sum over s/s that are in the effeets of some laws, and thus have non-zero log Fi (8t) plus the log frame strength from unchanged atoms, and the over l' can be reduced just steps where the law is activated, similar the first term above.
For experiments, we use a categorical variational distribution over the discrete support of the delays. The variational parameters are initialized to be uniform over this support.
A.4 PROCESS LEARNING DETAILS
Given a set of trajectories aasss set of predicates V, and the agent's known endogenous processes Len, we learn the set of exogenous processes Lex- Our method follows Chitnis et al. (2022) in assuming that for any given effect (a unique pair of add/delete atoms), there most one exogenous process that causes it. While this prevents learning multiple distinct causes for the same outcome, significantly simplifies the search problem. Any lost expressivity can be recovered by inventing more nuanced predicates. The learning algorithm proceeds in five steps:
Segment. First, we split each raw trajectory into shorter segments based on changes in the ab- stract state. Specifically, a new segment begins whenever the set of true predicates changes. Each segment therefore contains sequence of constant abstract states followed by a single timestamp where the state changes.
Next, we filter out any segments where the observed state change can be explained by one of the agent's known endogenous processes. For example, if the agent executes the Pick action and the Ho Holding predicate becomes true, that segment is attributed to an endogenous process and removed from consideration. This ensures only attempt to learn models for effects caused by the enviromment's own dynamics.
Filter.
3. Cluster. We then cluster the remaining segments based their effects. We assume that each exogenous process has single, atomic effect (e.g., one predicate changing from false to true) If a segment involves multiple predicate changes, we duplicate it into multiple clusters-one for each change-allowing us to learn a separate process for each atomic effect. This induces a de- terministic partition of segments effect, so the step introduces no clustering hyperparameters.
4. Intersect. For each cluster, we identify a set of potential preconditions for the associated ef- fect. This is done by taking the set intersection of all predicates that were true the start of every segment in the cluster. This step produces superset of candidate atoms for the process's conditions.
5. Select. The intersection from the previous step often contains many irrelevant atoms. To find the true preconditions, we first use LLM to propose small number plausible condition sets from this large superset (the prompt is detailed in the end of this section). We then use Bayesian model selection to score each candidate condition set C, and select the one that maximizes the posterior probability:
L. = arg max log D po = arg max (oogp(Passs.cc..l) + logp(T.c..)) Le..
where log (DDaatn ahs LC, ) is the approximate marginal likelihood from the previous section and log p( I.C.E) is a minimum description length prior that penalizes overly complex conditions.
Process condition proposal prompt
"This imposes loss of generality, because separate processes he learned for each changed predicate.
18

---

Published as a conference paper at ICLR 2026
You are an expert automated planning and causal reasening, Your task is to propose the most likely sets of conditions for specific precess effects to occur.
Given process with specific add effects and delete effects, you need to prepose multiple coherent sets candidate atoms that could serve as necessary conditions for the process to successfully achieve its effects.
Key principles for proposing condition sets:
1. **causal Relevance**: Each set should contain atoms that are causally necessary for the effects to occur
2. *xPhysical Constraints**: Include atoms representing physical constraints requirementa
3. DDomain Knowledge**: Use commen sense about how processes work
in the real world
4. **State Dependencies*+: Incluce atons that represent prerequisite states for the effects
5. Terminal-Progress Exclusion: If an add effect
termina/ccomllete state within a progression family, do not include any interreddiate/proorees predicates from the same family as preconditions (e.g., Partially=, Started, InProgress, HasSome).
Available predicates in the candidate atoms are: DISDICAATELLISINGG
For each process, will proviće:
Add effects: what the prosess makes true
Delete effects: What the process makes false
Candidate atoms: Potential precondition atoms to choose from
(PROCESS_ BADNLLDDDEEEETSS_LAADDIIII
Please propose as many likely condition sets as deem suitable for each precess. Each condition set should be coherent indices that together form plausible set of preconditions It's possible that there is large number of atoms in condition set in some cases.
combination
Think step by step if it's helpful before outputting your final response, formatted strictly as:
<answer>
Process 0:
Set 1: [2, 0, 41
Set 2: [1, 3, 0,
Set 3: [2, 4]
Process 1:
Set 1: [1, 3]
Set 2: [0, 1, 31
</answer>
A.5 PREDICATE LEARNING DETAILS
Our approach to predicate learning follows the general methodology of prior work (Liang et al. 2024 Silver et al. 2023), where foundation model (Gemini 2.5 Pro) is prompted to synthesize set of candidate predicates adhering to a predefined API. The final subset of predicates is then selected by maximizing approximate planning metric; subset receives higher if it enables the planner to find plans that are similar to successful demonstrations while requiring fewer planning resources.
19

---

Published as a conference paper at ICLR 2026
Our proposal process involves two stages. First, we prompt VLM with trajectory from the environment to propose a set high-level, symbolic concepts that could be useful for planning. We different prompts depending whether the provided trajectory successful resulted in failure. In the second stage, these concepts are translated into executable Python code that matches predicate object API.
Since the primary focus of this work is on learning abstract models in a more expressive and com- plex model space, we simplify the perception problem. We assume the agent has access state representation containing all the necessary object features to evaluate any relevant predicate, without needing ground them directly in image data.
In our experiments, we found it sufficient to generate a pool of candidate predicates only once, based on the initial demonstration trajectories. This of candidates is then retained and made available for the agent to select from during all subsequent online learning iterations. The full prompt templates used for predicate invention are provided below.
Predicate invention from successful trajectory prompt template
Context: You expert AI planning researcher. Your task is design task-specific predicates that can be used in a PDDI-like model to facilitate effective and efficient robot planning.
### Types and Features
The envi ronment has the following types, each with features:
ENV)
## Existing Predicates
You should consider the following existing predicates:
(PREDICATES_IA
### Robot's Goal
The robot's 's ultimate goal this environment is to make the predicate (RCAL_PREDICATE) truc.
### Demonstration Trajectory
The demonstrator performs sequence actions, ending with the goal being achieved. The state-feature-att trajectory is provided below.
EEXPRIIENCE IN ENVI
IN Your Task
Invent small set of the +most essential4 new predicates. These should be simple, primitive concepts that represent critical subgoals**,, #ccodiitions for subgoals**, +any conditions that must be maintained to prevent failure, even if failure is not shown in the demonstratione.
Note:
a continuous feature represents progress toward subgoai, define exactly one termi nal predi for its end state (with high thresheld near the value observed when the goal is achieved) and ignore intermediate progress states. wwoomttyyaffooreeeo
not invent predicates that rely on pese or derived geometry (distance, proximity, alignment, path, line-of-sigat, "within theta", abs () < tau), or on capabilities (Can*, AbleTo*, Near*), uniess such relations are already provided explicit non-pose features.
guardrail:
20

---

Published as a conference paper at ICLR 2026
There maybe some risk or violatien cendition that must remain safe for the goal to succeed, even failure is not shown. For such features include a maintenance predicate that keeps it within safe bound (e.g., T_low <- 0.1 for normalized features).
### Constraints
Do *not* propose any new predicates that are purely pose-based x, Y, 2 coordinates or 'rot', 'tilt'
(i.e., based angles).
Avoid composite predicates (no negation/AND/OR of other predicates). Each proposal should state one primitive property relation that can be verified from the given features. Assertion
clear and unambiguous, describing the variables ?<vari>, ><var2>, etc.,
relationship or properties so an external observer could label truth values from the provided object features alone.
Replace placeholders like <precicatel__ame>> <varl>, etc., with actual names; <typel> and <objl> with actual nanes and types from the state dictionary provided. +Do not use types that are not present in the states (e.g., int or float).
Do not use bold italic fonts in your response. Respond only with the output secticn outlined belox.
### Output Format Provide your predicate proposals in the following format:
"plaintext
Predicate cate Proposals
<predicatel name> (arel__aamm>aaeee (?<varl>:<typel>> 2<var2>: ...): <The assertion this predicate is making>.
Predicate invention from failed trajectory prompt template
Context:
You expert AI planning researcher. Your task is design task-specific predi that can be used in PDDL-1ike model to (a) detect. unreachable goals early and (b) avoid futile plans.
### Types Features
The environment has the following types, each with some features:
(TYPES_IN_ENV)
### Existing Predicates
You should consider the following existing predicates:
[PREDICATES_IN_EIT
### Robot's Goal
The robot's s goal in this envi ronment to make the predicate [G0AI__PPDDICATE)) true.
### Demonstration Trajectory
The demonstrator performs sequence actions, which they thought would achieve the goal but did not. The state-foature-action trajectory is provided below.
21

---

Published as a conference paper at ICLR 2026
EEXPERIENCE IN ENVI
#F Your Task
Invent small set of the most essential predicates whose primary purpose primitive, easily-checkable properties that must hold somewhere in the environment for the goal to be achievable. If a blocking condition is true (or a required enabling condition is false), rational planner conclude that the goal is unroachable under the available actions.
expose **blocking conditions*::
Prioritize:
Necessary preconditions for success that the demonst overlocked.
Irreversible or static properties (e.g., object class, material, color category) that make certain transitions impossible. Local checks that can be evaluated from the provided object features without simulating dynamics.
Note: Features such as colors may encode latent material or affordance classes. You may want to propose predicates that identify such classes when they impose hard constraints on feasible state transitions interactions (e.g.r non-dcformable, too-heavy, loN-friction, brittic, sealed, non-activatabled
For every new predicate, explicitly state how its truth value is decided from the 1isted non-pose features. Use deterministic rule with cencrete feature names and numeric thresholds categorical equalities (no vague phrases like *such as mass"). If invoking a latent property, tie it to an explicit feature pattern.
I Constraints
Geometry/pose prohibition (hard): Do not use or derive from pose fields (x, yaw, roll, tilt, wrist) or any geometric constructs (distance, proximity, alignment, vector, path, line-of-sight, "within theta", ()auu). Predicates mentioning these are invalid.
Soft blacklist (names/definitiins to avoid) aligned, path, near, distance, airstream, obstructed, adjacency (unless giver non-pese feature)
Avoid composite predicates (no negaticn/AND/OR predicates) Bach proposal should state one prinitive property or relation that can be verified from the given features. Assertions must be clear and unambiguous, describing the variables ?<vari>, 2<var2>, etc., so an external observer could label truth values from the provided object features alone.
other
relationship properties
Replace placcholders like <precicatel_name>, <varl>, etc., with actual names; use only types present in the states.
not use bold or italic fonts.
Respond only with the Output section below.
### Output Format
Provide your predicate proposals in the following format:
"plaintext
Predicate Proposals
<predicatel_nnme> (?<var1>:<typel) ?<var2>:<type2> ...); <The assertion this predicate is making>.
22

---

Published as a conference paper at ICLR 2026
Predicate implementation prompt template
Context: You are an expert AI researcher tasked with inventing task-speci fic state abstraction predicates for effective and efficient rebetic planning.
will describe the API you should use for writing predicates and the environment the robot is in.
The API for 'Predicate' and 'State' is: (STRUCT_DEPINITION)
The environment includes the follewing object-type variables with features:
(TYPES_IN_NN)
where 'bbox_left', 'bbox_lower', .... corresponds to the pixel index of the left, lower boundary the object bounding box the image starting from (0, 0) at the bottom ieft corner the image.
'pose_x', 'pose_y', and 'pose_z' correspand to the 3d object position in the world frame, these not comparable to the boox values.
The existing predicates are: (PREDICATES_IN_EW))
The states the predicates have been evaluated on are: (LISTED_STATES)
Please implement the following predicates which would have evaluation values that matches following specification:
[PREDICATE_SPECS,
implement each predicate " "'python
seperate Python block follows:
def <predicate name> name>_holds (state: State, objects:
Sequence Objectl) -> bool:
Implement the boolean classifier function here
Define the prodicate name here name: str
list of object-type variables for the predicate, using the ones defined in the environment
param_types List/Typel =
<predicate
name> namee Predicate (name, paran_types, elassifier)
when writing the proposals, strictly adhere to the follewing guidlines:
Use only object-type variables defined in the envirenment
when defining 'param types'. 'param_types'.
Don't use any undefined constants;
Don't use object features that are not present in the definiticn of that object type.
Adhere to the type hints in the predicate definition template.
Make use of helper functions such as the classi fier function in the existing predicates, it they' re helpfuL.
Your con't need to import anything.
23

---

Published as a conference paper at ICLR 2026
B ADDITIONAL ENVIRONMENT DETAILS
We describe the predicates and endogenous processes that we provide to ExoPredicator at the be- ginning learning. In contrast, the baselines (Manual, ViLa, MAPLE and VisualPredicator) provided with an expanded set of predicates that we intend our approach to discover autonomously.
B.1 COFFEE
Train/Test split The training tasks for this environment involve filling a single cup with coffee. The held-out test tasks require the agent to fill two or three cups. In both distributions, the size and color of the cups may vary.
Goal predicates.
(CupFilled)
(JucAboveCup, OnTable, NotAboveCup, CupFilled, Holding, MachineOn, JugInMachine, HandEmpty)
Initial predicates and endogenous processes.
EndóogenousProeess-oon
Farameters: robobtt
Conditions at start: []
Conditions overall: []
Conéitions end: []
Ada Effects: I]
Delete Effects: II
Ignore Effects: [JugAboveCup, NetAboveCup]
Log Strength: 1.0000
Delay Distribution: ConstantDelay (1. 0000)
Option Spec: NoOp robet))
Farameters: [Probot:rooot, bjug:jug, mmachine:coffee_neee
Conditions at start: [HandEmpty (?robot: robot), JugInKachine (?jug:
Conditions overall: []
Conditions end: []
Add Effects: [Holding (?robot rcbbtt, ?jug:
Delete Effects: [HandEmpty
JugInMachine (?iug: jug,
Ignore Effects: 11
Log Strength: 1.0000
Delay Distribution: siscretecauussiambbllyy (3.0000, 0. 0000)
Option Spec: PickJug (?robot robet, ?ug)
Parameters: (Probot:robot jjug:jug]
Conditions at start: [HandEmpty (Probot: OnTable (?jug: jug) I
Conditions overall: []
Conéitions at end: []
Add Effects: [Holding rccoot, ?iug: jug)
Delete Effects: (HandEmpty (Pobbot: OnTable (?jjugjjuuu
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Diseretccausssaneeeeyy (3.000) 0000, 0.1000)
Option Spec: PickJug (probootrrbbes ? jug)
Farameters: [Probot:rodot, ?jug: jug, cechiieecooffe_mmcchhhee Conditions at start: [Holding (?robot: : robot, jug), NotAboveCup (?
robot: robot, ?uug:jug)
Conditions overall: []
Conditions end: []
24

---

Published as a conference paper at ICLR 2026
Add Effects: [HandEmpty (Prohat:
JugInMachine (?jug: jug,
aachineecoffeeemmchhine
Delete Effects: [Holding (Probct: : robott, ?jug:jug)
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: DiscreteeGasssiambelaay 00000 0.1000)
Option Spec: PlaceJugInMachiin (wroonnnnnnrrrrrar (?robot: ?jug: jug, ?machine:
coffee_machine),
Enddgenoussrroess-Puufffie
Farameters: Proobot:rooot, ?jug:jug, ?to_cup:cup, ?from_cup: cupl
Conditions at start: [Holding : sjug:jug) JugaboveCup (?
jug:jug, ?from_cup:cup!?
Conditions overall: []
Conditions end: []
Add Effects: [JugAboveCup (?jug: jug, ?to_ ?to__up [to_euppcuup]
Delete Effects: [JugAboveCup (? dug, " ?tron_cup:cup), NotAboveCup (?
:ug))jug)!
Ignore Effects: [JugAboveCup, NetAboveCup]
log Strength: 1.0000
Delay Distribution: Di aecreeeaaussianeeellellle. (2.0000, 10000
Option Spec: Pour (?robot: robet, ?jug: jug, 2to_cup:cup),
Parameters: [?robot: :oobottrobbt, robot, ?jug:jug, ?cup:cup]
Conditions at start: [Holding : ?jug: NotAboveCup (?
robot:robor ?jug:jug)
Conditions overall:
Conditions end: []
Add Effects: [JugAboveCup (?jug: jug, ?oup: cup)
Delete Effects: [NotAboveCup (erruupprrrbbrs (?rebot: robot, ?jug:jug)]
Ignore Eitects: I1
Log Strength: 1.0000
Delay Distribution: DiscreteGaussiaanDeaay (2. 3000, 0.1000)
Option Spec: Pour (?robot rebott, robot, ?jug: jug, ?cup:cup),
Parameters: Prrobotrooos ?jug: jug, Pmachine:coffer mraceinee
Conditions at start: [HandEmpty (?robot: robot), JagInMachine (?jug: jug, smachhine:cooffeemmcchcci
Concitions overall: []
Conaitions at end: I]
Aca Eftects: IMachineOn (
Delete Effects: []
1gnore Effects: []
Log Strength: 1.0000
Delay Distribution: DiscreteGaussiaaeeelayyy 02.0000, 0.1000)
Option Spec: TurnMachineon (?robot: robot, ?machine:co (neeeeehhheeeeeeeeeceeeeeeee
Additional predicates. [JugFilled}
B.2 GROW
Train/Test split. the training tasks, the agent must grow plants in two pots. For each pot, least one jug of matching color is available, with maximum of two jugs present in the environment overall. The test tasks increase in complexity, requiring the agent to grow plants in three pots, again with at least one matching jug available for each and maximum of two jugs in total.
Goal predicates. {Grown)
25

---

Published as a conference paper at ICLR 2026
Initial predicates and endogenous processes.
{NotAboveCup, JugonTable, Holding)
TnddogeoousProoes--Pooo
Farameters: :orobot:rooot]
Conditions at start: []
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: []
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Dtereetcaausiinnbllayy...000 0.1000)
Option Spec: NoOp (frobot:
Farameters: 1?robot: ?jug: jugl
Conditions at start: [HandRmpty (?robot:
rorot)):rooot),, robot), (ugonllablee2jjug:u44
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (Probtttott,,,,b ?jug: jug)
Delete Effects:
JugOnTable (?jug: fug)
Ignore Effects: []
Log Strength: 1.0000
Delay iistribution: Discretccausssaneellyy (3.0000, 0.1000)
Option Spec: PickJug Prw.oot:rbbett......... ?jug:
Faramcters: [?robot: robot, ?jug: jug, reup:cup]
Conditions at start: [Holding (?robot robot, ?jug: jug), JugAboveCup (? jug:jug, ccup:
Conditions overall: []
Conditions at end: []
Aga Effects: [HandEmpty (trrbbtt:robot)) JugonTable (?jug: NotAboveCup (?robot:
(jug:jug)
Delete Effects: [Holding Pww.bttroobott ?ugg: JugAboveCup (?jug:
jug, ccup:cup)]
Ignore Effects: [HandEmpty, Helding, JugAboveCup, JugönTable, NotAboveCup]
Log Strength: 1.0000
Delay Distribution: DiscreteGauusieeneellayyy (3.0000, 0.1000)
Option Spec: Place (?robot rrebct, jug);
Parameters: [?robot: robet, ?jug:jugh ?from_ @from_cup:cup, 2to_cup:on cupl
Conditions at start: [Holding (?robot: robot, ?jug: JugAboveCup (?
jug:jug, ?from_cup:cup) Consiticns overall: 1]
Conaitions at end: IJ
Add Effects: [JugAboveCup (?jug: jug, ?to_cup:cup)
Delete Effects: [JugAboveCup (? jug, ?from_cup:cup)
Ignore Effects: [JugAboveCup, NetAboveCup]
Log Strength: 1.0000
Delay Distribution: Discretedaussianeelly (2. 0000, 0.1000)
Option Spec: Pour (?robot robot,, ?jug: jug, sto_cup:cup),
Parameters: [?robot: robet, juug:jug, ?cup:cup]
Conditions start: [Holding (?robot:ron) robot, ?jug:jug), NotAboveCup (?
gobot:robett ?jug:jug)
Conditions overall: []
Concitions at end: []
Add effects: [JugAboveCup (?jug: jug, ?oup: cup)
Delete effects: [NotAboveCup (?rcbot: robot, ?jug:jug)]
26

---

Published as a conference paper at ICLR 2026
Ignore Effects: [JugAboveCup, NotAboveCup)
Log Strength: 1.0000
Delay Distribution: DiscreteGaussianDel.s 1200, 0. 0.1000)
Option Spec: Pour (?robot robct, ?jug: jug, ?cup:cup)
Additional predicates.
{SameColor}
B.3 BOIL
Train/Test split. Training tasks require the agent to boil single jug of water. The evaluation includes tasks that involve boiling either one or two jugs.
Goal predicates. (HumanHappy)
Initial predicates and endogenous processes. { FaucetOn, FaucetOff, HumanHappy, JugAtBurner, Holding, JugAtFaucet, NoJugAtBurner, BurnerOff, HandEmpty, Burneron, N NoJugAtPaucet, (uggootta
EidogenousProcss--oopp
Parameters: probottroboot
Conditions at start: []
Consitions overall: []
Conaitions at end: I] Add iffects:
Delete effects: []
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: ConstantDelay (1. (1.0000)
Option Spec: (2roooooot robbtt),
Parameters: parobot:rooos ?jug: ?burner:burner
Conditions at start: [HandEmpty (?robot: robot), JugAtHurner (? jug: jug, ?burner:burner)
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (?robot: ?jug:jug) NoJugAt (?burner: burner)
Delete Effects: (Bandeptty(rrobet... robot), JugAtBurner (?jug: jug,
burner:burner)]
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Di aiscreteeausssinneell... (4.0000, 0. 0.1000)
Option Spec: PickJug (rrobotrrbbet. jug);
EndogenousProcss-Piide Pioaeeiiroaeooroocoeeeeeeeeee
Farameters: Probot:roooe ?jug: jug, ?faucet: faucet]
Conditions at start: [HandEmpty (?robot: robot), JugAtFaucet (?jug: jug,
:faucet: faucet)
Condition overall: []
Conéitions end: []
Add iffects: [Holding (2robet: ?jug: jug), NoJugAtFaucet (? faauce:: faucet)
Delete Effects:
(Probet: robot) JugAtFaucet (?jug: jug,
faucet:faucet]]
Ignore Effects: 11
Log Strength: 1. 0.0000
Delay Distribution: DiscretoGauseiannelayy (4.0000, 0. 0.1000) Option Spec: PickJug (?robot :robet, jug),
27

---

Published as a conference paper at ICLR 2026
Farameters: 1?robot: ropot, ?jug: jugl
Conditions at start: [HandEmpty (?robot: robot), JngdoctAtHurreeror/aucc (?jug:jug)]
Conditions overall: []
Conditiens at end: []
Add Effects: [Holding (3robet: :ugg
Delete Effects: [RandEmpty (?robot: robbt), SugglottABBurreeroFFauucee jug
1
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Di aereteaaaussiannellaaa (3. 0.1000)
Option Spec: PickJug (trobot: ?jug: jug),
Parameters: [?robot:robon ?jug:jug, 2burner:burner]
Conditions at start: [Holding (?robot : robot, ?jug:jug), NouugAtRurner ((burner:burner))
Conditions overall: []
Conditions at end: []
Add Effects: [HandEmpty : JugAtBurner B (?jug:jug, burner)
?burner:
Delete Effects: [Holding (?rebct robot,, ?ug): NoJugAtBurner (?
burner:burner))
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: ( 05.000 001000)
Option Spec: PlaceonBurner (Probttttootoooo ?burner burrner)
Parameters: [?robot:
robot, robot, Bjug:jug]
Concitions at start: [Helding wwr.ettrrbbotttt.............o.. ?uug:
Conaitions overall: II
Concitions at end: I1
Add Effects: (HandEmpty (Probct:robot)) juglottttBurnerrrFaact (?jug:
jug)
Delete Effects: [Holding (Probct: ?ugg:
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Biserreteeeussianbbllyy........ 0.1000)
Option Spec: BLacouuusiddBuurrrrraauuuuuu ( : robott,,
Parameters: [?robot: robot, ?jug: ?faucet: faucet]]
Conaitions at start: [Holding Probot:robol Pjug:jug) NoJugAtFaucet
:
Conaitions overall: I]
Conéitions end: []
Add Effects: (Handempty (?robet: probet:robott) robbt), faucet)
JugAt (2jug:jug) ffauctt:
Delete Effects: [Holding (?robot robot,, ?jug: jug), NoJugAtFaucet, (?
faucet:faucet]]
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Diseretetaussianeelyy (3.0000, 0.1000)
Option Spec: PlaceUnderFaucet
?faucet faucet),
Farameters: 1Probot:robot ?burner: Bourner:buree burrner)
Concitions at start: [BurnerOn ( Pburner burner), HandEmpty (?robot:
robot)
Conéitions overall: []
28

---

Published as a conference paper at ICLR 2026
Conditions end: []
Add Effects: [BurnerOff reburner:burnee ]
Delete Effects: [Burneron (ebourner:burner)
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: by (1. (1.0000, 0.1000)
Option Spec: Switcchurrerofff robot,
(Prcbboo (burner:burner),
Farameters: 12robot:rooot. :unnner:burrer
Concitions at start: [BurnerOft (?burner: bburner), HandEmpty (?robot:
robot)
Conditions overall: []
Conditions at end: []
Add Effects: [Burnerön inburner:burnee
Delete Effects: [Burneröff [bburne:burneet
Ignore Effects: []
Log Strength: 1.0000
Delay iistribution: Discretccaasssladoolayy3 (3,000,, 0.1000)
Option Spec:
(Prchttt courner:burner.
Parameters: [?robot: robot, ?faucet: faucett:
Conditions start: [FaucetOn (?faucet: faucet), HandEmpty (?robot: robot)
Conaitions overall: I]
Conciticns at end: II
Ada Effects: [FaucetOfı (?faucet:
Delete Effects: [Fauceton ( faucet)
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: Discretefaussiaabellay.... (1. 0.1000)
Option Spec: SwitchFaucetoff (?robot: ?faucet: faucet),
Parameters: probbotrobbor ?faucet faucet]
Conditions at start: [Faucetoff (?faucet: fauccct HandEmpty (?robot: robot)]
Conditions overall: []
Conéitions end: []
Add Rffects: [Fauceton (?faucet: faucet)) ]
Delete Effects: [Faucetoff (?faucet: Faucet)
Ignore Effects: 1]
Log Strength: 1.0000
Delay Distribution: Discretedaussiinnellayy (1.0000, 0.1000
Option spec: (Proottt ?faucet: slaucetffaucee faucet)
Additional predicates. NoWaterSpill BodughtTaauettoAAFaauutttaar
MaterBoiled
JugFilled,
B.4 DOMINO
Train/Test split. The training tasks takes place in compact 3x2 grid, where the agent must arrange one movable domino to successfully topple single target domino. The test tasks are more complex in three ways: the workspace is enlarged 4x3 grid, the number of movable dominoes increased to two, and the goals may require toppling either one or two target dominoes.
Goal predicates.
Toppled
29

---

Published as a conference paper at ICLR 2026
Initial predicates and endogenous processes.
Upright. InFrontDirection,
InitialBlock, MovableBlock, Toppled, AdjacentTo, DominoAtPos, Holding, Handdnn Tilting, PosClear
IndogenousProoess-ool
Parameters: (Poobot:robot]
Conditions at start: []
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: []
Ignore Effects: [AdjacentIo, DeminoAtPos, DominoAtRot, PosClcar]
Log Strength: 1.0000
Delay Distribution: ConstantDelay (1. 1000)
Option spec: (?robott robet.,
ErodgenoossProosssPPPtoooooo
Parameters: [?robot: robot, ?demino: domino, ?pos:loc, Prot:engle]
Conditions at start: [DomincAtPos 1?domino:dominne ?pos:loc),
Prot:angle), HandEmpty (?robot robot), MovableBlock prdoinno:dmmioo)) Upright (7domino: domino)
DomincAtRot :
Conditions overall: []
Conditions end: []
Add Effects: (Holding (?robot: rebot,, Pdomino:dominne PosClear (?pos:
loc)
Delete Effects: [DominoAtPos (?demino: :omino, ?pos:loc), DominoAtRot (?
Domino:doming :rot:angLe), HandEmpty :robot)
Ignore Effects: [DominoAtPos, DeminoAtRot, PosClear, Tilting, Toppled Upright]
Log Strength: 1.0000
Delay cistribution: piscreteeaaussianeeely..... (4. 0.1000)
Opticn Spec: Pick (?robot :rooot
robct, ?domino:domino),
Farameters: fProbot:rooet ?deminol domino, loc, Prot: anglee
?demino2: demino, ?posi:
Concitions at start: IAdjacentTo ( (?posl: :oc, ?domino2 domino), Holding
(?robot: perobot:rbbot. robot, ?dominoi : domino), PosClear ::pos1:loc), Upright (?
:oninee2ddmino:
Conditions overall: []
Conditions end: []
Add Effects: (DominoAtPos (?deminol:
: domino, ?posl :loc), DominoAtRot. (?
dominol: :ommino,, Prot:angle), HandEmpty : :robot)
Delcte Effects: [Holding (?rebot: robot, ?dominol demine), PosClear (?
posl:lcc)]
Ignore Effects: [AdjacentTo, DemineAtFos, DomineAtRot, PosClear, Tilting]
log Strength: 1.0000
Delay Distribution: bi biscretecaussiianee (3.0000, 0. 1000)
Option Spec: Place (?ropot srbbct, sdeminol:dominng ?domino2 domino, posl:loc, Prot:angle),
Farameters: rooobot:rooot, ?demino: domino]
Concitions at start: [HandEmpty (?rebot: robot), InitialBlock (?donino: nomino), Upright (?domi no:domi no)
Conditions overall: []
Conditions at end: []
Add Effects: ITilting (?domino: demino)
Delete Effects: [Upright (?demino demino)
Ignore Effects: [AdjacentTo, DeminoAtPos, DominoAtRot, PosClear]
Log Strength: 1.0000
Delay Distribution: Discretetaussianeelayy
0.1000)
Option Spec: Push (?robot: robot, ?domino:domino)
30

---

Published as a conference paper at ICLR 2026
Additional predicates.
(Not
B.5 FAN
Train/Test split. Training tasks are conducted on a small 3x3 grid containing a single wall obsta- cle. In contrast, tasks feature larger 6æ4 grid and more intricate mazes constructed with either two or three walls.
Goal predicates.
(BallA:Loc)
Initial predicates and endogenous processes. {Side0f, BallAtLoc, ClearLoc, FanOn, FanOff
EnologenousPrcces-Nooo
Parameters: :roobtt:
Conaitions at start: II
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: []
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: ConstantDelay (1.00lly11100000 0000)
Option Spec: NoOp :rooott:rbbtt))
EndogenousProcese Turnnno
Parameters: (Probot:robot, fan]
Conaitions at start: (
Concitions overall: |]
Conaitions at end:
Add Effects:
Delete Effects: [FanOn (ffanffan)
Ignore Effects: []
Log Strength: 1.0000
Delay Distribution: DiscreteGaussianneelayyl (2.0000, 0.1000)
Option Spec: SwitchOff (?robot: robot, fann:
Farameters: (Probot:robot. ?fan:
Conditions at start: [FanOff (?fan:
Conéitions overall: []
Conditions at end: []
Ada Effects: |FanO
Delete Effects: [Fanoff (?fan:
Ignore Effects: 11
Log Strength: 1.0000
Delay Distribution: Discreteecaussianeeellay 02.0000, 0.1000)
Option Spec: SwitchOn prrobctrrbbot. ?fan: fan)
Additional predicates. (FanFacingSidd,, OppositeFan)
C ADDITIONAL EXPERIMENT DETAILS
C.I
LEARNED CAUSAL PROCESSES
We show example learned predicates and causal processes each domain.
C.I.I COFFEE
Learned predicates and processes.
{JugFi 1edd
31

---

Published as a conference paper at ICLR 2026
EnddogeroossPocess-oooo
Farameters: proobotrrozot
Conditions at start: []
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: []
Ignore Effects: [JugAboveCup, NetAboveCup]
Log Strength: -0.0113
Delay Distribution: ConstantDelay(-O.u 0115)
Option Spec: NoOp (?robot:
Farameters: [ ropot, ?jug: jug, ?machine: ctw.eeeeaeeeeeeeel
Consitiens at start: [HandEmpty (?rebot: robot)) JugInKachine jjuu:jugg
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (Probot:robot. fug)
Delete Effects: [HandEmpty (Probot robbotttttrrbt).... JugInMachine (?iug: jug, ?
Ignore Effects:
Log Strength: 4.8335
Delay Distribution: aiseretecaussianellayyy (13.8455, 55152)
Option Spec: PickJug (2robot :rabot, ?jug: jug)
Farameters: [Rrobot: ?jug: jugl
Conéitions start: [HandEmpty (?robot: robot), OnTable (?jug: jug)
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (?robct:rcbet. ?jug: jug)
Delete Effects: [HandEmpty (?robot: OnTable (?jug:
Ignore Effects: |1
Log Strength: 1.5300
Delay Distribution: piscreteGaussianbellyy (23.8392, 6. 6450)
Option Spec: PickJug (?robot robet, ?jug:jug)
Farameters: : Jug,
Conditions at start: [Holding (?robot robot, ?jug;jug), NotAboveCup (?
robot:roben ?jug:jug)
Conditions overall: []
Conditions at end: []
Ada Effects: [HandEmpty robb, JugInMachine (?jug: wwweeeecofee__mmhhheeeee
Delete Edfects: [Holding (Pw.bot: ?jug:jug)
Ignore Effects: []
log Strength: 6979
Delay Distribution: DiscreteeGaussiaabbelaay (20. 0003, 6. 5.5394) ?machine:
Option Spec: PlaceJJugIMMcchnee (?robot:
noffee_machine)
Parameters: [?robot: :oobottrobett robot, bjug:jug, ato_cup:curg Strom_cupp cup:
Conditions at start: (roooin (Probot:robot. ?jug: jug), JugAboveCup (?
jug:jug, ?from_cup:cup))
Conditions overall: []
Conditions at end; []
Add Effects: [JugAboveCup (?jug: jug, ?to [to_ecppcupp]]
Delete Rffects: [JugAboveCup (? j?jug:juu robot: ?jug:jug)]
NotAboveCup (?
32

---

Published as a conference paper at ICLR 2026
Ignore Effects: [JugAboveCup, NotAboveCup)
Log Strength: 0.0012
Delay Distribution: Discretetuussaaneleey (1.0125, 1.0112)
Option Spec: Pour (?robot: ?jug: jug, ?to_cup:cup)
Parameters: robobot ?jug:jug, ?cup:cup]
Conditions at start: [Holding (?robot: robot, fjag:jug) NotAboveCup (?
robot:robot, ?iug:jug)
Consiticns overall: [J
Conaitions at end: IJ
Add Effects: [JugAboveCup (?jug: ?cup:cup)
Delete Effects: [NotAboveCup (?robot: roboo,, robot, ?jug:jug)
Ignore Effects: []
Log Strength: 1.7079
Delay Distribution: DiscreteGaussianDelayy (7.4837, 5.0596)
Option Spec: Pour (?robot rebott, ?jug: jug, Pouprcup)
Farametors: [?robot: robot, ?jug: jug,
Conditions at start: [HandEmpty (?robot robot), JugInKachine :
Conditions overall: []
Conditions at end: []
Ada Eftects: IMachineOn coffcheeeecofee_emmee
Delete Effects: ||
Ignore Effects: 11
Log Strength: 7298
Delay Distribution: DiscreteGaussiaanellay (18. (18. 3430, 6.4795)
Option Spec: TurnMachineon (?robet: : "machine:coofee_medee
CxogenousProcess-0011
Parameters: [2x0:coffee_machie] machhimmc ?x2: jug]
Conditions at start: (22 2x0:coffee_machhnee)
MachineOn co0
Conditions overall: [JugInMachine (?x2: 2x0:coffee_machine) Machineon (Px0:coffee_naccieee)
Conditions at end: []
Add Effects: [Jugrilled (2x2:jug)
Delete Effects: []
Log Strength: 7161
Delay Distribution: Disreteeaausiaanaaayyy...0000 6.4991)
CxogenousProcess0055:
Farameters: [2x1:cup, ?x2:jug, rx3:robot]
Conditions at start: [Holding robot, ?x2: jug) JugAboveCup (?x2: jug, ?xl:cup), [ig
Conditions overall: [Holding (2o3ding (xx3:robot, ?x2:jug), JugAboveCup (?x2 jug ?x1:cup), (ugFilleed[xx2:jug))
Conditions at end: [] Add Effects: ('upilleed2x1:cuu
Delete Effects: I]
Log Strength: 1.52
Delay Distribution Di biscreteeauussiiamllllay (4.5577, 1.8173)
C.1.2 GROW
Learned predicates and processes.
[ColorMatches]
SaslogenousPrrcess--oooo
Parameters: [?robot: robot] Conéitions start:
33

---

Published as a conference paper at ICLR 2026
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: []
Ignore Effects: []
Log Strength: -0.0113
Delay Distribution: Di aascreteGasssiinnelllayya (25. 6750, 6. 9284)
Option Spec: NoOp (2ropot:robct
Parameters: [?robot: robot, Pjug:jugl
Conditions at start: [HandRmpty (?robot: robot), (2 Conditions overall: []
Conaitions at end:
Aca Effects: [Holding (?robot: :iug:jug)
Delete Effects: [HandEmpty (Probot:robot)), JugOnTable (?jug:
Ignore Effects: []
Log Strength: 2.3222
Delay Distribution: DiscreteGaussianbell... (32.9836, 9427)
Option Spec: PickJug (?robot (?robot:robot, :rabot, ?jug: jug)
Farameters: [Probot: ?jug: ?cup:cup]
Conditions at start: [Holding : ?jug: JugAboveCup (?
jug:jug, ?cup:cup)]
Conditions overall: []
Conditions end: []
Add Effects: (HandEmpty (Probet:r :robot), JugonTable (Rjugg:
NotAboveCup (Probot (2robot: ?jug:
Delete Effects: [Holding ierebottrobot. ?jug: jug), JugAboveCup
jug, ]cup:cup)]
Ignore Effects: [Handkmpty, Holding, JugAboveCup, Jugöniablle NotAboveCup]
log Strength: 1.9316
Delay Distribution: DiscreteGausianDellyy (24.999,, 6. 6815)
Option Spec: Place (?robot srbbct, ?uug:jug)
Parameters: [Probot: ?jug: jug, ?from_cuprcup, ?to_cup: cupi
Conéitions at start: [Holding (?robot robot, ?jug: jug). JugAboveCup (? jug:jug, ?from strom_cupicup
Conditions overall: []
Conditions at end: []
Add Effects: (JugAboveCup (?jug: jug, ?to_cup:cup)]
Delete Effects: [JugAboveCup (? (?jug: jjug:jug, jug, ?fron_cup:cup))
Ignore Effects: (JugAboveCup, NotAboveCup]
Log Strength: -0.0126
Delay Distribution: DiscreteGaussianDDelle (1.0035 1.0031)
Option Spec: Pour (?robot: robot, Pjug:jugs (to_cup:cup)
Farameters: rooob, ?jug: ?cup:cup]
Concitions at start: [Holding (?robot robot, ?jug: NotAboveCup (?
robot:rabet. ?jug:jug)
Conditions overall:
Conditions at end: []
Add Effects: [JugAboveCup (?jug:
?cup:cup)
Delete Effects: [NotAboveCup (?robot: robot, ?jug:jug)
Ignore Effects: [JugAboveCup, NotAboveCup)
Log Strength: 2.2282
Delay iistribution: Dlecretecaussiaanell. (28.0008 9585, 6.9970)
Option Spec: Pour (Probot: robot, ?jug: jug, ?oup:cup)
34

---

Published as a conference paper at ICLR 2026
Exogenousrrceess-Opp:
Farameters: c?xl:cup, 2x3:jug; ?x4:rabot]
Conditions at start:
?xl:cup) Cuponirable (2x1:
cup), Holding (?x4: 2x3:jug), JugAboveCup (?x3: jug, ?x1: cup) ] Conditions overall: [colorMatches (?x3:jug, ?xl:cup), CupOnTable (7x1: cup), (2x4:roo, 2x3:jug), JugAboveCup (?x3: jug, ?xl: cupp) ]
Conditions at end: []
Add Effects: [Grown (?x1
Delete Effects: []
Log Strength: 1.2238
Delay Distribution: Dlecretecaupsilandllayy..1.. 6220, 6. 6.09)
C.1.3 BOIL
Learned predicates and processes.
(JugTsHot, JugTsFul1, NotSpilling)
EndogenousProcess Noo0:
Farameters: :
Conditicns at start: []
Conaitions overall: []
Conéitions end: []
Add kffects: []
Delete Effects: []
Ignore Effects: []
Log Strength: -0.0113
Delay Distribution: ConstantDelay (-0. 0115)
Option Spec: NoOp (Trobot:
Parameters: [?robot: robet, ?jug: jug, ?burner:burner/
Conditions at start: [HandEmpty (Probot: robot), JugAtBurner jugu jug, ?burnez:burner)]
Conaitions overall: []
Conditions at end: []
Add kffects: [Holding (?robot:robet, ?jug: jug), NoJugAtHurner (?burner: burner)]
Delete Effects: GEandEnptyyProeeen robbot) JugAtBurner (?iug:
burner:burner)]
Ignore Effects: I]
Log Strength: -0.0043
Delay Distribution: Diseretotuussianelllyy (1.0085, 1.0069)
Option spec: PickJug (?robot: roboct, jug)
Farameters: [Probot: robot, ?jug: jug, ?faucet: faucet]
Conditions at start: [HandEmpty :wobottrobbot.. JugAtFaucet (?jug: fug,
?faucet: faucet)
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (?robet:rebet ?jug: jug), NoJugAt (? faucet: faucet)
Delete Effects: (HandEmpty (Probat:rooobt) JugAtFaucet (?jug: jug,
faucet:faucet]]
Ignore Effects: []
Log Strength: 1.9823
Delay Distribution: Dieerttctaaessianelllyy222 (23. 523666 6476)
Option Spec: PickJug (?robot :rabat, Pjug:jug
Farameters: | ?Probot: robot, ?jug:jume
Condit ons at start: [HandHmpty (?robot: robot), JighectAtHurneeOrraauee (?jug:jug)]
35

---

Published as a conference paper at ICLR 2026
Conditions overall: []
Conditions at end: []
Add Effects: [Holding (2robot: :jug:jug)
Delete Effects: [HandEmpty : JiggoocAtearrreerOPaaccc (ug
1
Ignore Effects: []
Log Strength: 1.1899
Delay Distribution: Discreteaausiianeelay (43.4278, 6.8760)
Option Spec: PickJug (?rebot :robet, ?jug: jug)
Parameters: |?robot:rosot, Bjug: 3burner:burner!
Conditiens at start: [Holding
(eciing(rrbbbee (?robot rebot, ?jag: jug), NoJugAtBurner
(opurner:burer]]
Conditions overall: []
Conditions at end: []
Add Effects: (HandEmpty (Probat:robot) (Mgjttuurnerr?jjj:uuug ?burner: burner)]
Delete Effects: [Holding : :robot, Pjug:jugh NoJugAtBurner (?
burner:burner]]
Ignore Effects: 1]
Log Strength: 2.1507
Delay Distribution: Ly 6. 6070))
Option Spec: PlaceOnBurner (Proatt: Sopureer:urnne
Parameters: (Probot:robes ?jug:jug]
Conditicns at start: [Holding (?robot: robot, ?jug:jug)]
Conditions overall: []
Conditions at end: []
Add Effects: (HandEmpty (Probet:robett IngglotAtBarrnerrrFaaacet (?jug:
jug)
Delete Effects: [Holding prwbot:robos ?jug: jug)
Ignore Effects: []
Log Strength: -0.0025
Delay Distribution: Di scretteeauussiameelaayy 9866, 0. 0.9832)
Option Spec: PlaceOutsi iereruttttdeeurmeeennnaaaaaaa (? :obottrrbat)
Parameters: : ?jug:jug, ?faucet: faucet] Conditions at start: [Holding ( robot, (jug:jug)) NocugAtFaucet (laaueetffucct)):
Conditions overall: []
Conditions at end: []
Add Effects: [HandEmpty prrbbct:rbbot... JugAt (?jug:
?faucet:
faucet)
Delete Effects: [Holding (?rebot robot, fugg: NoJugAtFaucet (?
faucet: :faucet]
Ignore Effects: []
log Strength; 1.9426
Delay Distribution: Di siscretecaussianneel.. (41.1660, 6.8798)
Option Spec: PlaceUnderfaucet (?robot robot, :faucet:faucet)
Farameters: [?robot: ?burner burner]
Conditions at start: [Burneron ( ?burner: (burner:burrerr) HandEmpty (?robot:
robot)
Conditions overall: []
Conditions at end: []
Add Effects: [Burneroff (bburner: :burner)
Delete Effects: (Burneron (?burner :burner)
Ignore Effects: []
log Strength: 520000
36

---

Published as a conference paper at ICLR 2026
Delay Distribution: DiscreteGauusiannDlaayyy (9.8894, 4.0791)
Option Spec: Switshhurneroff (Probtt:tott Fburner:burner)
Parameters: [Probot:robot) (burner:burner]
Conditions start: [BurnerOff (burrner:b))) HandEmpty (?robot:
robot)]
Conditions overall: []
Conditions at end: []
Add Effects: [Rurnerón (Bburmer:burner))
Delete Rffects: [Rurnerōff (eburner:burner)
Ignore Rffects: []
Log Strength: 1.9554
Delay Distribution: LascreteGausiannellyy (32.0574, 6505)
Opticn Spec: SwitchBurnerdn (Prchot: (burner:burner)
Parameters: irrobot:robot.
Conditions at start: [Fauceton (?faucet: faucet), HandErpty (?robot:
robot)
Conditions overall: []
Conditions at end: []
Add Effects: [Faucetoff (?faucet: faucct) ]
Delete Effects: [Fauceton ( faucee))):: faucet)
Ignore Effects: []
Log Strength: 1.4501
Delay Distribution: Di sccrttttaussss (27.5714 7949)
Optien Spec: SwitchFaucetOff wtt.rrttrooooooooo.......ooaaate ?faucet: faucet)
Parameters: [?robot: robot, ?faucet: faucet]
Conditions at start: [FaucetOff (?faucet: faucet), Handkmpty (?robot: robot)
Conditions overall: []
Conditions at end: []
Add Effects: [Fauceton (ffauce::fucee:
Delete Effects: [Faucetoff (Pfauct:: faucet)
Ignore Effects: []
Log Strength: 7156
Delay Distribution: Discreteccuussiambellayy (35.2949 6.57)7
Option Spec: Swit.chauceton (?robot: robot, ?faucet: faucet))
ExogenousProces-Op0)
Farameters: f?xlifaucet, ?x2: jugl
Conaitions at start: FaucetOn(2x11 faucet), JugAtFaucet (?x2: jug, ?x1: ]aucet)
Conditions overall: [Fauceton (?x1: faucet), JugAt (?x2: jug, 2x1:
faucet)
Conditions at end: I1
Add Effects: [JugIsFull (2x2:jug)
Delete Effects: []
Log Strength: 1.2791
Delay Distribution: Diseretetaasssiaoolly(....1111 6.7873)
ExcgenoossProcess-Ogl
Parameters: [?x0:burner, ?x2:jug]
Conditions start: [Burneron (2x0:burner), JugAtBurner (?x2: jug, 2x0: burner), (P92:
Conditions overall: (BurnerOn (?x0:burner), JugätBurner (?x2: jug, 2x0: burner), JugIsFull (?x2:
Conditions at end: [] Add iffects: [JugisHot (2x2:jug)
37

---

Published as a conference paper at ICLR 2026
Delete Effects: [1
Log Strength: 1.9391
Delay Distribution: DBeccttCGuusleenelllyyyy.... 6.4452)
Exogenous@Prceess-pp..
Parameters: [?x0:burner, ?xl:faucet, ?x2 human, ?x3:jug, rxboro Conditicns at start: (2x: FaucetOff (?x1: faucet), (andEmpttyPPx4:robba JugIsFull (?x3: JugIsHot (ux3:jug),
(Fx1:
Conaitiens overall: [Burneroff (2x0:burner) Faucetoff (?x1: faucet), (ands JuglsPul1 (2x3:jug), Juot jxg))
Conditions at end: []
Add Effects: [HumanHappy (2x2:human, ?x3: jug, 2x0 :burner))
Delete Effects: I1
Log Strength: 1.9474
Delay Distribution: Saarrttccaassslnnodolyy......1 4.1486)
ExogenousProces--pp3.
Parameters: [?xl:faucet]
Conditions at start: [FaucetOn (?x1: faucet), NoJagAtFaucet (?x1: faucet)
Conditicns overall: [Fauccton (?x1: faucet), NoJugAtFaucet (?x1: faucet),
Notspilliig (2x1:faucet)
Conditions at end: []
Add Effects: []
Delete Effects: INotSpilling(? (?x1: (auucct
log Strength: -0.0029
Delay Distribution: Discretecaussianeells...ooo 1.0052)
C.1.4 DOMINO
Learned predicates and processes.
[NCT-IsImmovable]
EndogenoousProces-Nooog
Farameters: (Probot:rooot
Conciticns at start: I]
Conditions overall: []
Conéitions end: []
Add effects: []
Delete Effects: I]
Ignore Effects: [AdjacentTo, DemincAtPos, DominoAtRot, PosClear)
Log Strength: 1.0000
Delay Distribution: ConstantDelay (1. (1.0000) 0000)
Option Spec: NoOp setrobottrbbbct
Parameters: [?robot: robet, ?demino: domino, ?pos:loc, Prot: angle]
Conditions at start: [DomincAtPos (?domino:doming) (pos:loc)
DomincAtRot. 12domino:dominoo Prot:angle) HandEmpty (?robot robot), MovableBlock (rdomino:dooiio)) Upright (7domino: domiin)) Conditions overall: []
Concitions at end: []
Add ifffect:: [Holding (?robot: robot, ?domi no: no), PosC1 ear (?pos:
loc)
Delete Effects: [DominoAtPos (?deminos :omiinoo:ooo,, ?pos: DominoAtRot (?
domino:domino, ?rot :angle),, HandEmpty (?robot :robot)
Ignore Effects: [DominoAtPos, DeminoAtRot, PosClear, Tilting, Toppled Upright]
Log Strength: 0.0000
Delay Distributions DiscretetaussLaeellyy (14. 00000, 0.1000)
Option Spec: Pick (?robot robot, 2domino:domino)
38

---

Published as a conference paper at ICLR 2026
Parameters: !?robot: rooot,, ?dcminol domino, ?domino2 domino, ?posl: loc, anglee
Conditions at start: [Adjacentic (?posl: loc, 7domino2 domino), Holding
Prrobot:robot ?dominol :domino):domin)) PosClear (?posl:loc) Upright (?
:
Conditions overall: []
Conditions at end: []
Add Effects: [DominoAtPos (?deminol "ddminoo::dminoo. domino, ?posl :loc), DominoAtRot (?
moninol:demino: Froticngle), HandEmpty :
Delete Effects: [Holding (?robct: robbot, ?dominol :omino), PosClear posl:lec)
Ignore Effeect: [AdjacentTo, DeminoAt RoAtRot, PosClear,
Tilting]
Log Strength: 0.0000
Delay Distribution: DiscreteGaussianDelay 8000, 0.1000)
Optien Spec: Place (?robet :rebct, ddeminol:dominng sommino@:doming posl:lec, ?rot:angle)
Parameters: (Probot:robet. ?domino: domino]
Conditions at start: [Handdmpty (? (?robot: robot), InitialBlock (?donino: domino), Upright (7domino:domino)
Conditions overall: []
Conditions at end: []
Add Effects: [Tilting (?dominc: : domina)
Delete Effects: [Upright (?demino: domino)
Ignore Effects: [AdjacentTo, DeminoAtPos, DominoAtRot, PosClear]
Log Strength: 0.0000
Delay Distribution: Disrretcaussianeeeeyy (8, 0000, 0.1000)
Option Spec: Push (?robot: robet, 2domino:domino)
Cxorenousrroces=O00::
Parameters: ? :ominno ?x2 deminn,, rxll:directionl
Conditions at start: [InFrontDirection (?x1:domino; ?x2:domino, 7x11: direction), NCT-Is (2x1: :ominno, Tilting
(?x2 domino),
Upright (?x2:domino)]
Conditicns overall: [InFrontDirectionn (?x1:domino, 2x2idomino: ?xl1: direction), IIIIIIImoovblle (?x1 :2x1:domino), I (?x2 :omino))
Tilting (dmm:domino), Upright (?x2:domino))
Conditions at end: []
Add Effects: [Tilting
Delete Effects: []
loog Strength: 0. 0000
helay Distribution: Di seseeteeausssiaaeellyy (2.0000,, 0.1000)
Exogenousfroces=-qq11
Parameters: [Px]:domino] no,, ?x2:demino, Pxll:direction
Conditions at start: [InFrontDi : :omino, ?x2:domino, ?xl1: direction), NCT-Is (2x1 :dminno)i voT-IsImmovend :ommin))))
) Upright (2x2:domiro) Conditicns overall: [InFrentDirection (2x1: :ommnoo, domino, ?xl1: direction), NCT-Is Immovablee (2x1: :omindomino),
(?x2 domino))
Tilting (2x1: :ominoo) :ommoiinoo,, Upright (?x2:domino) Conditions at end: []
Add Effects: []
Delete Effects: [Upright (2x2:demino)
Log Strength: 0. 0000
Delay Distribution: Di sssretetaausssinlellllaa (2.0000, 0. 1000)
PxogenousProcess-0p0
Parameters: [?x] domi no]
39

---

Published as a conference paper at ICLR 2026
Conditions start: [Tilting (2x1 :omino))
Conditions overall: [Tilting (?x1 :oxiinnono)]
Conditions at end: []
Add Effects: []
Delete Effects: [Tilting (?xl (exl:demino)
Log Strength: 0.0000
Delay Distribution: ssscrteeGuussiambellayy..0..00.3 o. 0.1000)
Exogenous@rocess=0031
Parameters: [?x1
Conditicns at start: [Tilting domino))
Conditions overall: [Tilting (?x1: domino))
Conditions at end: []
Ada Effects: IToppled (?x1 :dxindemine)
Delete effects: []
log Strength; 0.0000
Delay Distribution: biscreteeauussiinnelllly (5.000000155000)) o. 0000)
C.1.5 FAN
Learned predicates and processes.
(FanFaces}
EndogenousProcees-toop
Farameters: robobtt:rooot]
Conditions at start:
Conditions overall: []
Conditions at end: []
Add Effects: []
Delete Effects: I]
Ignore Effects: IJ
Log Strength: 0.0000
Delay Distribution: Constantuelay 0000000)
Option Spec: NoOp :eoobottrbbct.
Parameters: (Probot:robot 2fan:fan] Conéitions at start: [Fanon (afa
Conditions overall: []
Concitions at end: []
Add Effects: [FanOff (
Delete Effects: [FanOn (?fan:fan)
Ignore Effects: []
Log Strength: 0.0000
Delay Distribution: Diseretccaussianeellly (11. 0. 0.1000)
Option Spec: Switchoff (?robet: ?fan:
Farameters: [Probot:robos ?fan:fan]
Conditions start: [FanOff fana
Conditions overall: []
Conditions at end: []
Add Effects: (?fan:
Delete Effects: [FanOff (?fan:
Ignore Effects: []
Log Strength: 0.0000
Delay Distributions Di aoreeteGaussiianeellayyy (13.66667, 2.0817)
Option Spec: SwitchOn (?robot: rebbt,, ?fan: fan)
ExogenousProcess-eee
Pa varamterr:: [?x0:bal1, 2x2: fan, ?x3: fan, 2x14:1oc, 2x15:1oc. 2x 6: de]
40

---

Published as a conference paper at ICLR 2026
Conditicns start: [BallAtIoc (?x0:ball, 3x14:loc), ClearLoc (?x15: loc), FanFaces (?x2: ?x16:side), Pan3ff(2x3:fan)) Fanôn : Side0f (?x15:1oc, 7x14:loc, 2x16:side) Conditions overall: [BallAtlec (axacces(222:
?x14:loc), ClearLoc (3x15:
2x16:side), FanOff (3x3:fan), FanOn (?x2 fan),
SideOf (2x15:loc, ?x14:1oe, ?x16:aide)
Conditions at end: []
Ada Effects: [BALAAtio
?x15:1oc]
Delete Effects: [BallAtIoc (2x0:ball, ?x14:1oc]]
Log Strength: 0.0000
Delay Distribution: biscretteaausssilmelllayyyy 5000, 8.2407)
C.2 FURTHER LEARNING AND PLANNING STATISTICS
Each online learning iteration of ExoPredicator takes approximately 30-360 seconds wall-clock time depending on the domain, using 32 CPU cores and no GPU. In comparison, the HRL baseline requires on average about 600 seconds online iteration, and its runtime increases it accumu- lates more data (taking longer to converge), reaching up to 3200 seconds in some cases. The VLM planning baseline does not perform online learning, but can incur substantial test-time cost because it issues computationally expensive VLM calls every time generates a plan.
Monetaryly, assuming Gemini 2.5 Pro with standard pricing, representative online iteration con- suming combined 10,000 input tokens and 1,000 output tokens would cost approximately $0.0225 in total: $0.0125 for inputs (10,000/ 1,000,000 1.25) and $0.01 for outputs (1,000 / 1,000,000 x 10).
The following table lists the success rate and planning time statistics.
Manual
Ours
No invent
Environment
Succ
Time
Suce
Time
Suce
Time
Coffee
99.3
0.612
99.3
0.851
0.0
Grow
92.0
0.608
93.3
0.922
0.0
Boil
100.0
15.467
92.7
12.204
0.0
Domino
97.3
31.710
98.7
21.299
62.0
0.000
Fan
97.3
16.143
97.3
58.244
0.0
C.3 PRIORS AND DISTRIBUTIONS
In all experiments, we model process delays with a truncated discrete Gaussian distribution over positive integers , 300}. The distribution is parameterized by a log-mean and log-standard- deviation.
The log- mean, wo--standard-devviation and log processs are initialized from normal distri- bution with mean and standard deviation 0.01.
41


Reviews:
[{"review_id": "zxHYye6LVf", "reviewer": "Reviewer_w4kc", "summary": "This paper proposes to explicitly model state and temporal abstractions of *exogenous* natural processes, those not controlled by the agent directly, separately from the *endogenous* processes that are result of the agent actions. They propose an approach that leverages a VLM to process the perceptual input  and LLM to propose and filter potential predicates. They evaluate their method in simulated robotic manipulation experiments where this exogenous dynamics are part of the task.", "questions": "See above", "limitations": "", "rating": 8, "confidence": 2, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "- The paper is generally well-written and motivated\n- The proposes a full approach that leverages LLMs and VLMs to improve sample efficiency in robotics planning.\n- The evaluation is done in varied robotic manipulation environment and includes baselines that cover diverse approaches to solve these problems such as VLM planning, HRL and ablations to their own method. \n- Their method effectively outperforms the baselines in both sample efficiency and performance\nOverall this paper introduces an effective way to use modern LLMs and VLMs to create abstractions for planning that handles the processes that are not fully controlled, include natural dynamics and that have delayed effects.", "weaknesses": "- It is clear that searching in the space of predicates is extremely costly and intractable via brute-force. It seems that LLMs provide a way to amortize the cost of it. However, it still seems a very large search problem. How computationally expensive is the method in comparison to some of the baselines? \n- The notation is quite cluttered and it's a bit hard to parse, though it can be understood. Perhaps some rework on simplifying notation could help the reader and I'd encourage the authors to do it.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "w70IBF7PDn", "reviewer": "Reviewer_p9tB", "summary": "This paper tackles long-horizon planning in dynamic environments where changes arise both from an agent’s actions and from independent external processes. It proposes a framework for learning abstract world models that capture symbolic state representations and causal processes with delayed effects.", "questions": "See Weaknesses", "limitations": "", "rating": 2, "confidence": 2, "soundness": 3, "presentation": 1, "contribution": 2, "strengths": "The paper addresses a timely and important problem in robotics: learning abstract world models that can reason over both agent-driven and environment-driven dynamics. The motivation is clear and well-grounded, and the overall direction aligns with the community’s growing interest in long-horizon planning.  Experiments on simulated tabletop tasks show improved generalization compared to several baselines. However, the framework’s current complexity and heavy mathematical formulation limit its accessibility. A major revision to simplify the presentation or improve clarity would make the contribution more broadly useful.", "weaknesses": "- Overly complex framework and poor readability. The methodology is overloaded with notation and nested definitions that make it extremely difficult to follow. Many variables and terms are introduced without clear motivation, explanation, or citation. It is unclear which components are novel and which are borrowed or adapted from prior works. While the motivation in the abstract and introduction is sound, the formalism feels unnecessarily complicated for the problem being addressed.\n\n- Insufficient experimental validation. The experiments are minimal and do not justify the complexity of the proposed framework. The evaluation focuses mainly on overall success rate, without ablations or detailed analyses that could demonstrate the contribution of each component. More fine-grained experiments are needed to show why the proposed system must be this complex and how each module contributes to its performance.\n\n- Conceptual confusion around endogenous vs. exogenous processes. The paper defines exogenous processes as those that occur independently of the agent’s actions, yet uses “filling water” as an example, which is directly caused by the agent turning on the faucet. This blurs the distinction between endogenous and exogenous mechanisms. In practice, the framework seems to capture delayed consequences of the agent’s own actions rather than truly external processes. The paper would benefit from a clearer conceptual definition and concrete examples that distinguish these cases.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "OxmTxxddPb", "reviewer": "Reviewer_Epsw", "summary": "The paper introduces ExoPredicator, a framework for learning abstract world models that capture both endogenous skills and exogenous causal processes with stochastic and possibly delayed effects. The model jointly learns a symbolic state abstraction via predicate invention and a library of causal processes whose conditions, effects, and delay distributions are inferred from limited trajectory data using variational Bayesian inference guided by language model proposals. Planning operates in big steps with an A star search over high level actions, including a NoOp action that allows the agent to wait for exogenous dynamics to unfold. Across five PyBullet tabletop domains Coffee, Grow, Boil, Domino, and Fan the method achieves high solve rates and generalizes to harder held out tasks with more objects and more complex goals. It outperforms vision language planning, hierarchical RL, and STRIPS style operator learning baselines and includes ablations that highlight the roles of Bayesian model selection and LLM guidance.", "questions": "- Clarify the assumed family for delay distributions. Are they discrete on timesteps or continuous then discretized. What priors are used for these distributions and for process weights.\n- Provide more details on the segmentation and clustering used before process discovery. How sensitive is learning to the clip length and the clustering hyperparameters.\n- Report wall clock times per online iteration and per plan for each environment. Include counts of LLM calls and average cost to understand practicality.\n- How does the planner choose the duration to wait with NoOp. Is the wait until first abstract change always optimal or could waiting through an intermediate change be beneficial.\n- How does the framework prevent spurious processes from being added when predicates are noisy. Is there any calibration of VLM predicate accuracy or robustness to false positives and false negatives.", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- Novel problem framing that explicitly models exogenous processes with stochastic and delayed effects within an abstract world model. This goes beyond standard STRIPS or option based abstractions that assume instantaneous effects and agent centric dynamics.\n- Integrated learning and planning system. The method couples predicate invention, Bayesian structure and parameter learning for causal processes, and a big step planner that reasons over concurrent exogenous dynamics via a NoOp wait action.\n- Principled inference. The paper derives a variational objective using arrival time latent variables to avoid fine grained simulation and learns both process weights and delay distributions. The planning semantics are precise and the big step transition is specified with care.\n- Empirical breadth and generalization. Strong results across five simulated domains with generalization to harder held out tasks. Convergence in at most three online iterations with only one or two demonstration seeded training tasks per seed shows good sample efficiency.\n- Comparisons and ablations. Consistent improvements over ViLA, MAPLE, and VisPred. Ablations show that both LLM guidance and Bayesian model selection matter. Manual delay parameters underperform learned ones which supports the value of the inference component.\n- Clarity of problem setup. The paper carefully distinguishes endogenous skills from exogenous processes and motivates why temporal abstraction for world dynamics is needed for long horizon planning.", "weaknesses": "- Evaluation is limited to simulated tabletop worlds with built in closed loop skills. There is no validation on real robots or with noisy perception which leaves open questions about robustness and deployment.\n- Only three random seeds and a modest number of training tasks are used. While this highlights sample efficiency it makes statistical confidence harder to assess. Confidence intervals and significance tests are not reported.\n- The approach relies on a fixed library of low level skills and on a proprietary LLM for proposals. This raises reproducibility concerns and limits analysis of end to end learning without pre specified skills.\n- The failure case in Boil indicates that learned conditions can miss important disjunctive structure. More stress tests on overlapping or interacting exogenous processes would strengthen the case.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "hTzHzbZZHJ", "reviewer": "Reviewer_Fikj", "summary": "This paper introduces ExoPredicator, a framework for learning abstract world models that capture both endogenous (agent-controlled) and exogenous (environment-driven) causal processes. Unlike standard world models or symbolic planners that assume all changes stem from the agent’s actions, ExoPredicator explicitly models external processes that unfold concurrently over time (e.g., water boiling after switching on a kettle).\n\nThe framework represents states as collections of predicates grounded by vision-language models (VLMs) and describes temporal dynamics via causal processes—structured tuples encoding conditions, effects, and probabilistic delay distributions. The system jointly learns (i) state abstractions (via LLM-guided predicate invention) and (ii) causal process models (via Bayesian structure and parameter learning with variational inference).\n\nExperiments across five simulated tabletop robotics environments (Coffee, Grow, Boil, Domino, and Fan) show that ExoPredicator learns accurate symbolic models from limited data, enabling efficient A* planning over “big-step” transitions and outperforming hierarchical RL, VLM-planning, and STRIPS-style baselines. Ablations indicate that both Bayesian model selection and LLM guidance are crucial for performance.", "questions": "1. What is the practical motivation of the frame axiom potential for enforcing state persistence over time? \n2. Variational Representation: How are the variational distributions in sec. 5.1 represented and parameterized in practice?\n3. When prompting the LLM to propose symbolic forms for exogenous processes, what kinds of templates or grammatical constraints are imposed?\n4. Minimum Description Length: How is the MDL prior or description length of a causal process computed? Is it based on symbolic length, number of predicates, or something else?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. Strong motivation and relevance. The paper tackles the important problem of integrating state and temporal abstraction in world modeling, particularly addressing exogenous processes that evolve independently of agent actions.\n2. Elegant conceptual framing. The formulation of causal processes as structured tuples with probabilistic delays provides a clean and general formalism for modeling both endogenous and exogenous dynamics.\n3. Expressive yet practical abstraction. Defining abstract states through predicates queried via VLMs strikes a balance between symbolic expressivity and perceptual grounding.\n4. Clear mechanistic interpretation. The notion of a big-step transition function is intuitive and well-motivated, allowing the planner to reason at a temporally coarse level.\n5. The use of a variational lower bound for parameter estimation and Bayesian model selection for structure learning supports data-efficient model discovery.\n6. Innovative use of LLMs. The integration of LLMs for proposing new symbolic forms of causal processes (Sec. 5.2) and predicates (Sec. 5.3) is a creative and well-executed design choice.\n7. Well-designed experiments. The set of five environments captures a diverse range of exogenous phenomena, and the ablation studies provide useful insight into which components matter most.\n8. Empirical results are convincing. ExoPredicator achieves strong generalization to unseen tasks, often outperforming baselines despite limited training data.", "weaknesses": "1. Questionable novelty claim. The paper argues that prior models (e.g., Dreamer, world models) “do not consider exogenous processes.” This is somewhat overstated. Model-based RL frameworks routinely model all sources of state transition—including environment-driven stochasticity. \n2.  Overstatement regarding options/skills. The claim that options or skills cannot capture the temporal evolution of exogenous dynamics may be too strong. In principle, semi-MDP formulations with temporally extended actions can incorporate control-exogenous effects into the transition model, although this is not their main focus.\n3. Assumption of known skill set. The framework assumes the availability of predefined high-level skills (Pick, Place, etc.), which limits autonomy and may constrain generalization to new embodiments.\n4. Limited empirical diversity. While the environments are well-constructed, they are all tabletop simulation tasks with relatively low-dimensional perceptual spaces. It remains unclear how well the method scales to real-world or visually richer domains.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)