Modeling Others' Minds as Code
Authors: Kunal Jha
Aydan Yuenan Huang
Eric Ye
Natasha Jaques
Max Kleiman-Weiner
Venue: ICLR 2026 Poster (2026)
Keywords: Multi-agent
theory of mind
program synthesis
action understanding
goal inference
Primary area: applications to neuroscience & cognitive science

Abstract: Accurate prediction of human behavior is essential for robust and safe human-AI collaboration. However, existing approaches for modeling people are often data-hungry and brittle because they either make unrealistic assumptions about rationality or are too computationally demanding to adapt rapidly. Our key insight is that many everyday social interactions may follow predictable patterns; efficient "scripts" that minimize cognitive load for actors and observers, e.g., "wait for the green light, then go." We propose modeling these routines as behavioral programs instantiated in computer code rather than policies conditioned on beliefs and desires. We introduce ROTE, a novel algorithm that leverages both large language models (LLMs) for synthesizing a hypothesis space of behavioral programs, and probabilistic inference for reasoning about uncertainty over that space. We test ROTE in a suite of gridworld tasks and a large-scale embodied household simulator. ROTE predicts human and AI behaviors from sparse observations, outperforming competitive baselines---including behavior cloning and LLM-based methods---by as much as 50% in terms of in-sample accuracy and out-of-sample generalization. By treating action understanding as a program synthesis problem, ROTE opens a path for AI systems to efficiently and effectively predict human behavior in the real-world.

Published as a conference paper at ICLR 2026
MODELING OTHERS' MINDS AS CODE
Kunal Jha', Aydan Yuenan Huang,, Eric Ye Natasha Jaques' & Max Aheiman-Weinert
ABSTRACT
Accurate prediction human behavior essential for robust and safe human-Al collaboration. However, existing approaches for modeling peo- ple are often data-hungry and brittle because they either make unrealistic assumptions about rationality are too computationally demanding to adapt rapidly. Our key insight is that many everyday social interactions may follow predictable patterns; efficient "scripts" that minimize cognitive load for actors and observers, e.g., "wait for the green light, then go." We propose modeling these routines behavioral programs instantiated in computer code rather than policies conditioned on beliefs and desires. We introduce ROTE, a novel algorithm that leverages both large language models (LLMs) for synt hesizing hypothesis space of behavioral programs, and probabilistio ic inference for reasoning about uncertainty over that space, We test ROTE in suite of gridworld tasks and large-scale embodied household simu- lator. ROTE predicts human and AI behaviors from sparse observations, outperforming competitive baselines-inchudingg including bchavior cloning and LLM- based methods by as much as 50% in terms of in-sample accuracy and program
oul-of-sample generalization. By treating action understanding synthesis problem, ROTE opens a path for AI systems to efficiently and effectively predict human behavior in the real-world.
INTRODUCTION
Predicting the behavior of others (Theory of Mind) is a core challenge for building intelligent social agents. Whether anticipating pedestrian's 's movements, coordinating with tcammates, or interacting safely in public spaces, machines must infer what others are likely to do next. Existing approaches such behavior cloning (BC) and inverse reinforcement. learning (IRL) rely on learning models to predict low-level actions or infer latent reward functions (Abbeel & Ng 2004 Ng et al., 2200 Torabi al.) 2018 Wulfmeier
al., 2016). However, these methods are often data-hungry and brittle because they try to learn what an agent might do in every possible state, frequently overfitting to specific environments or overcomplicating behaviors that are surprisingly routine for humans (Skalse & Abato 2024 Yildirim et al. 2024). Alternatively, probabilistic methods for goal inference (Fuchs al. 2023 ZhiiXuan ct al.
2020 2024) are more sample efficient but demand compulationally intensive online reasoning about potential intentions and beliefs, alongside human-specified priors and hypothesis spaces. Thus, conventional methods for modeling others present trade-off illustrated in Figure [ new domain.
data-intensive and brittle, or cmmpute-intensivg and manually constructed for each
Recent work in cognitive seience shows that when humans interact with one another, we do not always imbuc others with deeply held mental states such as goals or beliefs. Instead often perceive others as following a script or mindlessly applying a set of rules (Ullman & Bass 2024 Bass et al., 2024).. For example, when someone steps into crosswalk, we do not need lo inler their ul ultimate destination, their complex mental states, or their opinion on pineapple on pizza. is enough apply commonly understood "crosswalk script" shaped by social convention. While there are perspectives on how people adopt roles in societies or prescribe agency to others (Dennett] 1972 Field 1978 Dennett Gorey 1981 Dennett
"Equal contribution. Department of Computer Science, University of Washington, Seattle, WA Department of Computer Science, Johns Hopkins University, Baltimore, MD

---

Published as a conference paper at ICLR 2026
Behavior Cloning
Inverse Planning
ROTE (Ours)
def act(obs): + int if valid(obs):
Belint Planner Action
Goals
Generalizability
Generaliiaabllity
Generr GerereLizenil eiizeilitt
Train Efficiency
Test efficinncy
Train Efficiency
Test efficiency
Train efficiency
Test erficiency
Interpret@el
Interpretaoilityy
Interpretaoility
Figure 1: Comparison of action prediction methods: Behavior cloning requires large datasets and has limited generalization, while inverse planning is computationally expensive at test time. Our approach, ROTE, uses LLMs to generate efficient and interpretable code representations of observed behavior, providing superior balance of efficiency and accuracy.
1987 2017
Jara-Ettinger & Dunham 2024), to the best of our knowledge, there are currently no computational models that adequately describe how machines can represent and reason about other agents acting in a script-like manner.
The notion of representing decision-making processes is a foundational idea in computer science (Newell & Simon 1956
intelligent agent through logical rules and predetermined
Schank & Abelson 2013 Newell & Simon 1976), influencing fields from planning (Campbell
eet al. 2002] Zhu et al. 2025) to game theory (Axelrod) 1980). Finite State Machines (FSMs), for instance, are still used in vidco games to efficiently simulate large numbers of agents. By defining sequence of states and transitions (e.g., patrol border - find agents - chase agents), code can flexibly model the causal behaviors underpinning social norms and routines.
Here we develop ROTE Representing Others' Trajectories as Executables - novel algorithm that leverages LLMs as code synthesis tools predict others' actions. We prompt LLMs to generate computer programs explaining observed behavioral traces, then perform Bayesian inference to reason about which programs are most likely. This gives us a dynamic reprosentation that can be analyzed, modified, and composed across agents and environments.
ROTE significantly improves generalization and efficiency predicting complex agent behavior, showing up to 50% increase in accuracy across multiple challenging embodied domains. Our results in gridworlds and the scaled-up Parter household robotics simulator demonstrate that code is highly effective representation for modeling and predicting behavior. To validate its applicability to real-world complexity, we collected human gameplay data and found that our method achieves human-level accuracy in predicting human actions, outperforming all baselines. This offers a promising new path for creating scalable, adaptable, and interpretable socially intelligent AI systems. Concretely, our contributions arc:
1. Modeling Agentic Behavior via Program Synthesis: We develop ROTE, a novel algorithm that combines LLMs with Sequential Monte Carlo to model other agents' bchavior as programs from sparse observations.
2. Superior, Scalable Action Prediction: Across two embodied domains, we show that ROTE offers superior generalization for predicting others' behaviors, outperforming alternative methods by as much as 50%. Our method generates executable code that reusable across environments, bypassing costly reasoning over goals and beliefs. Those code-based representations scale more efficiently than behavior cloning or inverse planning alternatives, even when the ground truth behavior does not come from known program.
3. Human Studies Validation: We recruit real human participants to generate behavior and predict others' actions. We find that ROTE outperforms baselines and achieves human- level performance in predicting human behaviors, even for noisy and sparse trajectorics.
2

---

Published as a conference paper at ICLR 2026
2 RELATED WORK
Action Prediction. Prior work developing AI for action prediction follows two dominant categories: symbolic methods and neural networks. Symbolic methods, such as Bayesian Inverse Planning (BIP), infer an agent's ' goals and beliefs by calculating their probabilities
based on observed actions (Ullman et al.)
2009;
Baker et al.) 2017] Shum et al. 2019 et al.,
Netanyahu al. [222]] Kleiman- Weiner et al. [2016] Wang a..] [2200] Kleiman-
2020 Serrino et al. 2019 Kleiman- Weiner ct al.,
2025). While robust, these methods are not multi-agent environment (Rathnasabapathyy
scalable due to the exponential complexity
et al. 2006 Doshi & Gmytrasiewicz 2009; Seaman et al., 2018). In contrast, neural
approaches like behavioral cloning (BC) and inverse reinlorcement learning (IRL) train
models to directly mimic actions Torabi et al. 2018 Ng et al. 2000: Abbeel & Ng 2004
Wulfmeier et al. 2016; Wang et al. 2021 Christiano et al. 2023). but are often data-intensive,
fragile, and prone to overfitting. Recent work has tried modeling reward functions as finite-
state automatons, a concept known as "reward machines" " (Icarte et al. 2018 Toro Icarte ct al. 2022 Li ct al. 2025). This method, which does not use LLMs, allows for structured reprosentation of reward and can provide non-Markovian feodback to agents. While primarily used for training agents to solve compositional (asks, there has been work on inferring reward machines from expert demonstration (Zhou & Li| 2022) or learning safety constraints (Malik et al.) 2021 Lindner et al.) 2024 Liu et al.) 2025). Despite these advances, neural models still struggle with generalization, particularly in social reasoning, as they often fail to capture the causal structure of behavior
de Haan et al., 2019 Codevilla al.] 2019 Bain & Sammut 1995). This brittleness persists even with ad vanced techniques that learn contextual
representations (Rabinowitz et al., 2018 Chuang et al., 2020 Jha et al., 2024) and does not disappear at scale under an assumption of imperfect rationality (Poddar et al. 2024). In contrast, our approach, which uses an LLM to generate open-ended code describing observed behavior, makes fewer assumptions about the nature of the agents being modeled. This allows it to capture everyday decision-making processes that may not be reward maximiizng.
Large Language Models (LLMs) for Behavior Modeling. LLMs may be more effective bridge between the neural and symbolic paradigms. They enable enumerative
inference for social reasoning (Wilf et al.
2023
Jung et al. 2024 Huang al.) 2024 Jin Zhang et al. 20250, while neuro-symbolic
et al. 2024 Cross et al. 2024 Kim et al.
2025
Trameworks (e.g.. BIP + LLMs) improve robustness in embodied cooperation (Ying et al.
2024 Ding et al. 2024 Y ing et al. 2025 Wan et al. 2025 Castro et al. 2025 Zhou et al.
2024 Qiu et al. 2024 Yang al.] 2024 Cao al.) 2024). However, existing implementations
remain computationaly intensive, often generating thousands of tokens for each prediction.
In realistic settings, we need methods capable of rapid inference that stiill capture the
structure of culturally shaped conventions and behaviors performed without deep cognitive processing (Bargh 1994 Wood 2024). By learning a code- based agent representation, ROTE avoids the high computational cost that BIP must incur to enumerate every possible goal.
Program Induction. Program synthesis has proven effective for world modeling (Guan et al.
Wong et al. 2025). action selection (Verma et al.) 2021 Wang et al. 2023] Yao et al.] 2023 and has even achieved near-expert
2023 Wong et al. 2023b a Zhu & Simmons 2024
performance on nathematical reasoning tasks such as International Math Olympiad problems
Trinh et al., 2024) while assisting researchers with science (Binz et al. 2025 Rmus et al.
2025p. Neurosymbolic approaches, which combine LLMss domain-speefii neural networks
with probabilistic program inference, have enabled agents to learn environment dynamics
DDa et al.) 2023) and master complex games like Sokoban and Frostbite with impressive
sample efficiency (Tang et al. 2024 Tsividis et al. 2021 Tomov et al.) 2023). Code-like representations have been used to infer reward functions from state-action transitions Yuu
el. a.l. 2023 Davidson et al. 2025), and LLMs have been harnessed to synthesize polic policies
or planning stategisss in domain-specific contexts (Liang et. al., 2023 Sun et al. 2023 Trivedi et al. 2022). However, these prior approaches typically rely on well-defined rewards, domain-specific constraints, or focus on partial aspects of agent behavior, such as reward inference or demonstration summarization. In contrast, ROTE aims to infer an agent's causal docision-making process directly from observed behavior and assumes no access to reward signals or domain-specific structure.
3

---

Published as a conference paper at ICLR 2026
Representing Others' Trajectories as Executables (ROTE)
What will the Agent do next?
1) Generate Candidate Agent Programs with LLMs given History
2) Refline Program Likelihood via Bayesian Inference
Ground Truth State
class ToyChair:
class ToyBedr oom: det actiself, ebst:
def act(self, obs): if found_toyleen toylebs); nove, to, chot riobs] else: rind_ toylobs)
if found_ soyd tot_ttyysssss loss nove to roonlobs) clse: rind_ tobs)
Toys to Chairs
Toys to Bedroom
t=1
t=3
t=5
class Cleankitchen: def act(self, cos): in lobsh scrub distubddsshesiie (obs) else: (o_kitchhn(obs]
clsss Nanderllouse: def actiself, obs): obs. timestop rI0 I roons) visitReon(rI0) obs)
Plprogran)
1.4
6. Clean dishes
d. Wander Between Rooms
Tays Tays
Figure 2: Overview of ROTE. ROTE predicts an agent's next action by generating and weighting Python programs that explain its observed behavior. From t = to t 7, ROTE observes a blue robot's trajectory. Initially, at = 1, programs related to moving to the dining room are up-weighted. However, remains uncertain if the goal is to clean up toys in the bedroom or place them on chairs in the living room. After the robot places the toy on a chair at 5, ROTE confidently updates its program weights to reffect the "bringing toys to chairs" script. By t = 7, ROTE can use this inferred script rapidly and accurately predict future actions.
& == 3, the robot picks up toy, and ROTE
REPRESENTING OTHERS' TRAJECTORIES AS EXECUTABLES
Drawing upon recent conceptualizations of " "agents" in reinforcement learning and thcoretical computer science (Abel et al.] 2023a Dong et al.. 2021: Lu et al. 2023 Leike 2016
Lattimore et al. 2013 Majeed & Hutter 2018 Majeed 2021 Cohen et al. 2019 we
represent compulationalyy bounded agents as programs with internal states, which be conceptualized as Finite State Machines. This is formally represented using the notation (S so, n, u) from Abel et al.) (2023b), where finite internal states 8t E S used for decision- making in the policy : - AA evolve via transition function u(s:-1, d; 0z) 8t, which maps the observations from the external world the agent's 's next internal dccision- will demonstrate how
making state. In the following section, program in the space of agents A E A that best explains observed history of (observation E O, action E A) pairs, h E H. For the rest of this section, we use the notation hy:t to indicate the history of pairs from time to t.
search for the minimal
3.1 AGENT PROGRAM SYNTHESIS WITH LARGE LANGUAGE MODELS
Given a finite length history ho--1 E H. from time 0 agent Å A that both (1) takes the same action de as the ground truth agent X when presented with observation ot, and (2) minimizes its program size [³]. Encouraging concise program synthesis is not just matter of engineering preference but is theoretically grounded in the foundations of algorithmic probability and inductive inference. Solomonoff's theory of inductive inference formalizes Occam's razor, demonstrating that the best scientific model for a given set of observations is the shortest algorithm (in terms of description length) that generates the data in question (Solomonoti) 1964 1978 1996). Under this framework, shorter programs are assigned higher prior probability, providing a universal solution to the problem of induction with strong convergence guarantees: the expected cumulative prediction error is bounded by the Kolmogorov complexity of the true data-generating process [Solomonof]] 1978 1996). Thus, searching for minimal agent representations is not only computationally desirable but also theoretically optimal for generalization, bias also observed in human programmatic reasoning (Bigelow & Ullman 2025).
our objective is to find an
We operationalize our search through the space of agents A with two-stage approach: First, we optionally prompt an LLM to transform raw perceptual imputs into a natural language description of an agent's path. These percepts can be low-level observations like object coordinates in gridworlds, or even natural language scene-graphs from datasets like Partnr (Chang et al. 2025). Next, have the LLM generate many possible Python programs
4

---

Published as a conference paper at ICLR 2026
to obtain distribution over possible code-based agent models which explain the observed behavior, (A). Python is chosen for its readability, widespread use in Al research, and its power a completee language, enabling the representation of arbitrarily complex decision-making logic in the worst case where |S| = |O] for the ground-truth agent X². Our prompting strategy makes two key assumptions: (1) the observed agent follows deterministic transitions between finite internal states S contingent on environmenta/ h/ cues rather than executing complex adaptive policies, and (2) generated code should produce deterministic actions a E A. Importantly, we ask the LLM to assumc these properties of the observed trajectories even if the ground truth agent generating the behavior probabilistic and following sophislicated, goal-direcled plans. While this assuines deterministic agent, we account for polential stochasticily in behavior with a noise model, allowing our approach to best approximate the underlying deterministic policy. We instruct the LLM to generate code that is efficient (low runtime complexity) and concise (minimize [AD.
3.2 REFINING GENERATIONS THRROGHI BAYESIAN INFERENCE
To form a more robust estimate of the true underlying agent program X", we refine the distribution over candidate programs (A) obtained from the language model using Sequential Monte Carlo. Specifically, we estimate the posterior probability of candidate agent program given the observed history hot-1 1 using the relationship:
p(A/oa-11) x p(ho:-11\))p())
(1)
This approach is related to inverse planning-based methods that infer latent goals given
observed behavior (Ullman et al. 2009 Baker et al., 2017 Shum el al. 2019 Netanyahu
et al. 2021). However, instead of assuming fixed, often complex, planner (like MCTS or brute-force search) and performing inference over a space of goals, our method condenses all behavioral conventions and scripts an agent might follow into a single programmatic representation X. Since À is deterministic program, we give the action de it predicts the
ground-truth agent will take at observation or a probability of (1 - c) and all other actions a= E A- {d probability of .লं This effectively allows À to predict distribution
over actions ((A) it might take at each step. Then, we can perform inference directly over the space of likely decision-making processes encoded as Python programs by calculating p()(ftot-1) x eoo. lo, A) . (A), With this refined posterior distribution, we select the k most likely agent programs, and execute the corresponding Python code for each from the current observation O₁. Then, ROTE performs a weighted combination of agent programs to form our approximation X s Å EXEAAA))) p(A(ho=-1) A(-lo.).
The combination of LLM-based program synthesis with Bayesian Inference results in our method for inferring others' behaviors, ROTE. Pseudocode for our approach can be found in Algorithm D and in Figure [ we provide an overview of ROTE on an intuitive example in the Partur environment, an embodied robotics simulator where an agent tries to help human complete a variety of household chores (Chang et al., 2025). We additionally include examples of agent code inferred by ROTE in Construction and Partnr in Appendix A.11.2
4 EXPERIMENTS
Environments. We evaluate ROTE across two distinct environments. First, we use Construction (shown in Figure 7) fully-observable 2D grid-world where agents actively navigate obstacles like walls and other agents, and can transport colored blocks to different locations on the map (Jha et al. 2024). Then, we explore the elficacy of our method on Partnr (shown in Figure 5 a large-scale embodied robotics simulator where an Al-assistant perceives realistic home office space natural language scene-graple (Chang et al. 2025). Built on the Habitat benchmark, this environment requires the agent to utilize tools to help a human complete tasks in a partially observable world (Puig et al. 2023
Baselines. We compare ROTE against three baselines: Behavior Cloning (BC). In the Construction environment, the BC model is neural network with an LSTM trained on pixel-based observations of agent trajectories (Rabinowitz et al. 2018); for Partar, we fine-tuned I.ama-3.1 3.1--b to imitate ground-truth LLM agent''s behaviors using training
5

---

Published as a conference paper at ICLR 2026
set of (scene-graphe action) pairs Chang et al. 2025 Automated Theory of Mind (AutoToM) (Zhang et al. 2025 AutoTToM is a neuro-symbolic approach which uses LLMs to generate open-ended hypotheses about an agent's beliefs, goals, and desires, then applies Bayesian Inverse Planning to find the most. likely action. Naive LLM (NLLM). NLLM simply prompts LLM with observed states and environment dynamics to predict the next action directly. Our evaluation for all methods except for BC uses suite of LLMs: Llama-3.1- 8b Instruct, DeepSeek- V2-Lite (16b), DeepSeek- Seepseee--Codr---ee V2-Lite-Instruee (16b), and we report the highest accuracy achieved for each bascline to ensure the most competitive comparison. All results for ROTE were obtained using DeepSeck-Codee Sinder-V--LAAe V2-Lite-Instruct, while other baselines show the highestt-perforiing model for each environment. Appendix A.. provides a detailed breakdown of per-task and per-LLM accuracy for all methods, demonst rating our approach's 's consistent success across different LLM model types.
Dataset Generation. For the fully observable Construction environment, we hand- designed 10 distinct Finite State Machines to generate 50, 000 state-action pairs across 100 trajectories/agent x10 agents = 1000 trajectories. Behaviors ranged from simple tasks, such as patrolling, where agents rely planning heuristics, to complex goal-directed tasks using A search, like finding all green blocks. We have included some for illustration in Figure 7 and the full list of behaviors in Appendix A. For the partially observable Parlnr environment, we used the LLM agents defined in (Chang et al. 2025 to generate state-action pairs for robot assistant completing diverse tasks (1.e. "clean all toys in the bedroom ") from their "train" and "validation" datasets. In these datasets, states are represented as natural language scene graphs, and actions are high-level tools.
Evaluation Protocol. We evaluate using two protocols: (1) single-step prediction, where given observations from timesteps 0 to the task is to predict the action a;: and (2) multi-step prediction, where we iteratively predict actions fe....,044100 conditioned on the ground-truth observed stales op,.... Oz. For the BC model in Construction, we hold out 100 trajectories for evaluation, training on the remaining data. All baselines are evaluated on these 100 held-out trajectories. For Partnr, we evaluate single-step prediction with t = |7| - 2, since varying trajectory lengths make multi-step evaluation inconsistent, and the final timestep is always the terminal action. We evaluate all models on the entire "validation" dataset, using the "train" dataset to finctune the BC model. We only predict high-level tools used by agents in Partar, since AutoToM requires static-sized action spaces (Zhang et al. 2025).
Human Studies. We conducted human studies in the single-agent Construction environment to evaluate ROTE's ability to predict human behavior and to benchmark its performance against human predictions. For the first study, 10 participants were recruited to perform their interpretation of each of the 10 handcrafted FSMs without observing the ground-truth code, generating 30 acttin
In a separate study, we recruited 25
0.66
0.66
Accuracy
Single-Step Multi-Step
Accuracy
Single-Step Multi-Step
0.44
0.44
0.22
0.22
0.00
0.00
BC AutoToM NLLM ROTE Human
BC AutoToM NLLM ROTE Human
(a) Single-step vs. multi-step prediction accuracy for Construction with scripted agents
(b) Single-step multi-step prediction accuracy for Construction with human agents
Figure 3: ROTE outperforms all baselines in both single-step and multi-step action prediction for scripted (a) and human agents (b). ROTE's codo-based representations, which treat human actions as efficient scripts, enable it to generalize effectively from limited observations. For single-step predictions, ROTE was siguificantly more accurate than all baselines for both scripted (p < 0.05 for NLLM, < 0.001 for BC and Auto AuloToMM and human agents (p < 0.05 for BC, p= < 0.01 for NLLM, p < 0.001 for ToM) This superior performance was maintained in multi-step predictions for both agent types (scripted: p < 0.001 for BC, AutoToo, and NLLM; hurnan: p < 0.01 for BC, < 0.001 for NLLM and AutoToM), ROTE achieved humon-level predictive accuracy of human behavior.
6

---

Published as a conference paper at ICLR 2026
Figure 4: ROTE demonstrates superior zero- shot generalization to novel environments in Construction. Without any additional condi- tioning agent's behavior, the programs ROTE infers from one environment transfer to novel settings more effectively than all other baselines (p < 0.001 a two-sided t-test).
Generalization Accuracy
0.66
Accuracy
0.44
0.22
0.00
BC
AutoToM
NLLM
ROTE
humans to act predictors. They were shown human's Irajectory from / = 0 to L= 19 and the state at = 20, and asked to predict its next five actions, from = 20 to 24. We use the same setup for third study to explore how well people predict the behavior of the ground-truth FSM's next actions instead. We compared peoples' prediction accuracy to ROTE and the other baselines to benchmark different behavior modeling algorithms. All studics were approved by our university's s Institutional Review Board (TRB) and were designed using Nice WebRL (Carvalho al. 2025). We used Prolific for crowdsourcing data. We plan to open-source the code for our baselines, datasets, and human evaluations.
RESULTS
How well does ROTE model and predict scripted agent behavior? To evaluate the effectiveness of ROTE, we first examined its predictive accuracy in a controlled setting where agents in the Construction environment followed one 10 handcrafted programs. These programs were not provided to ROTE at any point during evaluation. Our results in Figure 3a demonstrate that. ROTE consistently surpasses all baselines in both single-step and multi-step prediction accuracy in this evaluation setting and does not statistically signéficantly underperform human performance (p=0.3087 for single-step and p=0.1679 for multi-step in two-sided t-test). While these initial results were promising, a potential concern was that ROTE might simply be exploiting repetitive patterns, rather than learning the underlying policy. We investigated this by mcasuring how often an agent revisited state or repeated action. We found an extremely low correlation between ROTE's accuracy and either of these metrics (0.303 for matching states, 0.064 for matching actions), confirms that ROTE not exploiting simple data regularities. This finding, paired with ROTE's strong multi-step performance, suggests that code-based representations can effective for learning the underlying policies that enable robust, long-term term predictions.
How well does ROTE model and predict human behavior? Having established that ROTE's code-based representations effective in controlled, scripted environments, next wanted to test its ability to model more complex, nuanced behaviors. We began by evaluating ROTE against human agents performing 10 tasks in the Construction environment. As illustrated in Figure 35 ROTE oulperforms all baseline algorithms and achieves human-
Robot Observation in Partnr
Inferred Agent Code from ROTE
Partnr Accuracy
0.66
attfiatate and SITIeATE, eeh
SEaCION'' Pasuiqate", Tex06"), 1000807 "30E")
0.22
alext actice "Navigate"
sntt tramsssianlatt..ao
0.00
BC
AutoTaM NLLM
ROTE
Ground-Truth Task: "Put the fire truck on the chest"
(a) Action prediction accuracy Partur
(b) Example Partur task with ROTE's inferred program
Figure 5: (a) Prediction accuracy in the large-scale, partially observable Parlur environment. ROTE demonstrated a superior ability to anticipate the behavior of goal-directed, L.I.-bbased agents, with two-sided t-test showing ROTE significantly outperformed all other models (p < 0.001). (b) The pseudocode example illustrates how ROTE's inferred programs capture complex task logic using conditionals and statc-tracking.
7

---

Published as a conference paper at ICLR 2026
Figure 6: Total multi-step prediction time in Construction. Despite being slower than BC and Naive LLM prompting the single-stop prediction case, ROTE's programmatic rep- resentations enable its multi-step compute cost to scale orders of magnilude more ef- ficiently than other approaches, making better suited for morghorizon settings than other approaches for predicting individual behavior.
Total Prediction
16a
Time (
100-
10
10a
20
25
# of Predictions
BC
AutoTaM
NLLM
ROTE
level predictive accuracy of next-step human actions. deeper per-task accuracy analysis, shown in Figure reveals that ROTE has greater accuracy than humans some tasks with repetitive patterns, such as "move up if possible, otherwise down" or "move in an I-shape." However, humans are still much better at anticipating scripts for tasks such as "patrol the grid clockwise" and goal-directed lasks such as "move all pink blocks to the corner of the grid." This gap highlights that while the code produced by ROTE expressive enough to capture many behaviors, more powerful LLMs with enhanced reasoning may be needed to achieve human-level prediction in all sottings.
Generalizing to Novel Environments: A key advantage of modeling behavior with scripts the potential for rapid generalization to new, but similar, environments. We wanted to know if ROTE's inferred programs could transfer without needing to be relearned. To lest this, we first observed scripled agent following a pattern like "patrol counterclockwise" for 20 timesteps, and then showed the same agent in distinct environment. We then asked ROTE and the baselines to predict the next 10 actions of the same agent. For ROTE, this was done by using the same set of programs inferred in the first environment for prediction without updating their likelihoods. Figure 4 shows that ROTE can still predict the agent's behavior accurately in the new sctting, outperforming all basclines without needing to re-incur the cost of text generation, necessary step for NLLM and Auto'ToM. Although ROTE's performance decreases compared predicting behavior in the original environment in Figure 3a its ability to generalize makes it more accurate and efficient alternative to traditional Inverse Planning or purely neural methods.
Can ROTE's code- approach scale to model behavior in complex, realistic environments? To further push the boundaries ROTE's capabilitics, we tested on the embodied robotics benchmark Parter, where the task is to predict the next tool utilized by LLM-agents simulating a human or robot completing chorcs. This environment particularly challenging due to partial observability and horizoori compositional tasks such as "find plate and clean it in the kitchen" or "look for toys and organize them neatly in the bedroom." Despite this complexity, Figure 5 shows our approach significantly outperformed all baselines, including inverse planning and behavior cloning methods, and those incorporating LLMs. To better understand the types of problems ROTE excels at, used Llama-3. Instrrtt to cluster the ground-truth tasks from our test set into three categories, as shown in Figure 10 While baselines like AutoToM and Behavior Cloning showed success with tasks involving simple navigation, ROTE demonstrated a superior ability to handle more intricate problems, such as turning items on/off and cleaning objects. This demonstrates its generalizability in creating code for agents that face uncertainty and possess beliefs about their environment.
How does the computational efficiency of ROTE compare other approaches? Forming
plans in the presence of other agents requires predicting their bebaviors over time quickly and not just accurately. To understand whether ROTE scales effectively, we plot the time in seconds required for different basclines to make predictions about agents' behaviors multiple times into the future Construction. As shown in Figure & while ROTE is initially slower for single-step predictions compared to BC and NLLM baselines due to the need to generate and prune candidate programs, its test-time compute costs scale orders of magnitude more efficiently with the number of predictions. This is because once ROTE's code- based representations are inferred, it can execute these programs rapidly for all future steps. In contrast, other L.IM-based methods must re-generate response for every new
8

---

Published as a conference paper at ICLR 2026
time step. We analyze additional factors contributing to this efficiency in Appendix A.5 and Figure [4 Taken together with the results from Figures 3 and [ this illustrates that code-bases representations
balance predictive power with prediction efficiency.
What is the relationship between ROTE's core components and its predictive performance? To understand how ROTE achieves its superior generalization and human- level accuracy, we conducted a scries of ablation studies on its core components. We found that ROTE's two-stage observation parsing, which converts observations into a natural language description before generating code, had a minimal effect on accuracy for the FSM and human gameplay datasets in Construction (Figure I1p. However, this process significantly hurt performance in Partnr. This is likely because Partar's observations are already rich scene graphs (Chang et al., 2025), and the abstraction step removes crucial details needed for effective program generation. Additionally, we investigated the use of Sequential Monte Carlo (SMC) with rejuvenation versus standard Importance Sampling. SMC, which replacos low-likelihood programs with new ones, improved early-stage accuracy when the number of sampled hypotheses was small (Figure 12]. This benefit, however, diminished as the initial set of candidate hypotheses increased, suggesting that the initial diversity provided by the LLM is often sufficient.
Lastly, we analyzed the impact of imposing different degrees of structural constraints ROTE's program generation, inspired by methods for inferring reward functions (Yu et al. We evaluated three variants: "Light" (assuming agents are FSMs without providing examples), "Moderate" (defining FSM states explicitly but allowing open-ended code), and "Severe" (a two-stage process converting natural language predictions of FSMss into code). Our previous results were based on the "Light" condition. The optimal level of structure, however, varied by environment, as shown in Figure I3 In the Construction environment, where agents followed predictable FSMs, the Severe approach performed as well as others. This suggests that for predictable, rote behaviors, an explicitly structured representation ion can be just as effective while also being computationally efficient (Callaway et al.] 2018 Lieder
2023)-
& Griffiths 2020: Callaway et al. 2022 Icard 2023). Conversely, modeling human behavior proved less suited for strict FSMs. The Moderate condition was superior for human gameplay, highlighting the need for representational flexibility when agents are following a general script but exhibiting inherent variability. In the partially observable Partar environment, forcing agents into a strict FSM representation performed significantly worse than open-ended code generation, suggesting these scenarios might be better suited for traditional Inverse Planning methods that can handle a wider range of states and tasks. These findings reveal a gradient of agentic representations, from automatic to goal-directed, which allows for flexible prediction across different scenarios. Future work could use meta-reinforeemett learning to dynamically solect the appropriate level of representational structure based on the task.
6 DISCUSSION
In this work, we framed behavior inference as program synthesis problem, showing that our approach, ROTE, can accurately and efficiently predict the actions of machines and real people in complex environments. ROTE offers a scalable alternative to traditional methods that require extensive datasets or significant computational resources. This has immediate implications for domains where real-time adaptabiltyy and interpretability are crucial, such as with caregiver robots that could use ROTE's representations to anticipate daily routines.
Limitations: While our results highlight the effectiveness of program synthesis for text- based observations, we note the limitations of the applicability of our findings in Partar since we only predicted high-level tools used by agents, which was done to accommodate basclines which required static action spaces. While our evaluation in Partnr still involved more tools than our other experiments (19 actions in Partnr compared to in the Construction). future research should explore ROTE in high-dimensional, continuous control settings. In those cases, ROTE might need to be integrated with vision-language models (VLMs) to parse pixel-based inputs (e.g., raw video feeds for assistive robots) and neural control mechanisms to execute plans, effectively operating at the level of option prediction (Sutton
et. al. 1999). Another interesting direction would be to explore how the size of L.LSs used
9

---

Published as a conference paper at ICLR 2026
for behavioral program inference impacts prediction quality in more sophisticated scenarios, such as modeling team coordination in workplaces or norm enforcement on social platforms.
Lastly, unlike traditional Theory of Mind approaches that predict beliefs and goals, our work focuses solely on action prediction. If we view beliefs as dispositions to act (Ramsey & Moore 1927 Ryle 1949). prodicting distribution over an agent's internal decision-making states and logic for transitioning between them is functionally equivalent to belief inference. ROTE is designed to excel in scenarios dominated by predictable, routine, or script-like behaviors, such as daily routines in warehouses and stores, relatively stable social conventions like driving, or routine household settings. This is because ROTE exploits the efficiency of executing simple code for long- horizon prediction in these routine settings. For ROTE to gain true generality and address the rigidity concern, future work is explicitly focused on extending it to generate Probabilistic Programming Languages (PPLs), such as memo, which specialized for social reasoning in JAX (Chandra et al.) 2025 This extension would allow ROTE to infer the distribution over actions or latent mental states, directly addressing the stochastic nature of humaan actions without abandoning the executable code format. In terms of failure modes, domains requiring high-fidelity continuous control over raw sensor data (e.g.. video feeds) require ROTE's inferred high-level programs to be integrated into a Task and Motion Planning architecture, where ROTE provides the symbolic lask plan to a low-level neural control mechanism. Finally, for deeply complex, goal-directed behaviors involving "unknown unknowns" in partially observable environments, the very notion of a fixed FSM-liie programmatic model may be fundamentally unsuitable, indicating that in these cases, the representation itself is too rigid to capture the agent's full intentionality. Thus, we view ROTE as generating and reasoning over one of many possible representations that are suitable for bohavior prediction rather than a catch-all.
ACKNOWLEEDGEMENTT
We would like to thank the Cooperative AI Foundation, the Forcsight Institute, the UW- Amazon Science Gift. Hub, the Sony Research Award Program, UW-Tsukuba Amazon NVIDIA Cross Pacific AT Initiative (XPAT), the Microsoft Accelerate Foundation Models Research Program, Character.Al DoorDash, and the Schmidt A12050 Fellows program for their generous support of our research. This material is based upon work supported by the Defense Advanced Research Projects Agency and the Air Force Research Laboratory, contract number(s): FAS650-23-C-731
Any opinions, findings and conclusions, or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of AFRL or DARPA. Lastly, we would like to express our gratitude to our colleagues at the Social Reinforcement Lab and the Computational Minds and Machines Lab, as well as Guy Davidson, Tan Muan, and Tomer Ullman for inspiring conversations and insights during the course of this project.
IMPACT STATEMENT
This paper presents& a framework for modeling agentic behavior through program synthesis, offering a scalable and interpretable alternative to traditional neural and symbolic methods for action prediction. The primary societal benefit of this work lies in improving the safety and efficiency of human-Al collaboration in real-world settings, such as assistive robotics, where anticipating human routines is essential for effective support. By representing behavior as exocutable Python code, ROTE provides a layer of transparency that allows users to inspect and verify the Al's underlying assumptions about human logic, which is essential for building trust in autonomous systems. However, we acknowledge that the ability to infer high-fidelity behavioral "scripts" from sparse data carries potential risks regarding privacy and the unauthorized profiling of individuals. Furthermore, developers must be cautious of "script rigidity," " where a system might fail to account for stochastic human variability in safety-critical edge cases. We believe that by transitioning toward interpretabl ble and uvllt probabilistic programmatic representations, our work advances the field of Machine Learning toward social intelligence that is both technically robust and ethically accountable.
10

---

Published as a conference paper at ICLR 2026
REFERENCES
Pieter Abbeel and Andrew Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-fitt first international conference Machine learning, pp. 2004.
David Abel, André Barreto, Benjamin Van Roy, Doina Precup, Hado van Hasselt, and Salinder Singh. A definition of continual reinforcement learning, 2023a. URL https
//arxiv. www...rggabb...... ab3/ 11046
David Abel, André Barreto, Hado van Hasselt, Benjamin Van Roy, Doina Precup, and Satinder Singh. On the convergence of bounded agents, 2023b. URL https://arxiy
org/abs/2307.1100
Robert Axelrod. Effectivve Choice in the Prisoner's Dilemma. Journal of Conflict Resolution, 24(1) 3 25, 1980. doi: 10.1177 0117770022002550244000001 URL https://doi org/10. 1177/ 0022002780024000011
eprint:
Michael Bain and Claude Sammut. A framework for behavioural cloning. In Machine intelligence 15, pp. 109, 1995.
Chris Baker, Julian Jara-ettinger, Rebecca Saxc, and Joshua Tenenbaum. Rational quantitative attribution of belicfs, desires and percepts in human mentalizing. Nature Human Behaviour, (4))00064 2017.
John A. Bargh. The four horsemen of automaticity: Awareness, intention, efficiency, and control in social cognition. In Handbook of social cogmition: Basic processes; Applications, Vols. 1-2, 2nd ed., pp. 1-40. Lawrence Erlbaum Associates, Inc, Hillsdale, NJ, US, 1994. ISBN 1.8058-1056-0 (Hardcover); 0-8058-1057-9 (Hardcover).
Πoma Bass, Cristian Espinoza, Elizabeth Bonawitz, and Tomer D Ullman. Teaching without thinking: Negative evaluations of rote pedagogy- Cognilive science, 48(6)=e13470 2024.
Eric Bigelow and Tomer Ullman. People evaluate agents based on the algorithms that drive their behavior. Open Mind, 9:1411-1430, 08 2025. ISSN 2470-2986. doi: 10. 20.1162/opmi.a.20 URL https://doi. hwe.dii.oggggeooo org 10. 101112//mmiii 2.
Marcel Binz, Akshay K. Jagadish, Milena Rmus, and Eric Schulz. Automated scientific minimization of regret, 2025. URL https://arxiv.. org/ //tgg//b//5......///// 2505. 17661
Frederick Callaway, Falk Lieder, Priyam Das, Sayan Gul, and Paul M Krueger. A resource- rational analysis of human planning. In Proceedings of the Annuol Meeting of the Cognitive Science Society, volume 40, 2018.
Frederick Callaway, Bas Opheusden, Sayan Gul, Priyam Das, Paul M Krucger, Thomas L Griffiths, and Falk Lieder. Rational use of cognitive resources in human planning. Nature Human Behaviour, 6(8):1112 1125, 2022.
Murray Campbell, A.Joseph Hoane, and Feng- hssung Hsu. Deep Blue. Artificial Intelligence, (34(1-2) 83, January 2002. ISSN 00043702. doi: 10:0000/500044-77000000000222220 URL https://1takiighu..eee.. www.wier..e.....o........oe....e httpa//aa.......oor...e.///////.
Chengzhi Cao, Chao Yang, and Shuang Li. Discovering intrinsic sparialleeaaaaaaaaapppaa logic rules to explain human actions, 2024. URL httpps://aariv..rr//a//////
12244
Wilka Carvalho, Vikram Goddla, Ishaan Sinha, Hoon Shin, and Kunal Jha. Nicewebrl: python library for human subject experiments with reinforcement learning environments, 2025. URL https: wwwaaiiiwo////eeeeeeeeeeee wwwp//gg//////eeeeeeeeeeeeeeeeee abtp///a//222815555 15693
Pablo Samuel Castro, Nenad Tomasev, Ankit Anand, Navodita Sharma, Rishika Mohanta, Aparna Dev, Kuba Perlin, Siddhant Jain, Kyle Levin, Noémi Éltetö, Will Dabney, Alexander Novikov, Glenn C Turner, Maria K Eckstein, Nathanicl D Daw, Kevin Miller, and Kimberly L Stachenfeld. Discovering symbolic cognitive models from hu- 00..2/.....5.667733.3 man and animal behavior. bioRwiv, 2025. doi: 10.1001/2025.00.05.687777
URL
https: h/www. biorxiv. bttp://wwwr//ccaaa/aaa////////// 02 636732
11

---

Published as a conference paper at ICLR 2026
Kartik Chandra, Tony Chen, Joshua B. Tenenbaum, and Jonathan Ragan-Kelley. A domain- specific probabilistic programming language for reasoning about reasoning (or: A memo on memo). Proc. ACM Program. Lang., 9(OOP)L),), October 2025. doi: 10. 10.1145/3763072 0114/33663377
URL htttps:///oi....o/
Matthew Chang, Gunjan Chhablani, Alexander Clegg, Mikael Dallaire Cote, Ruta Desai, Michal Hlavac, Vladimir Karashchuk, Jacob Krantz, Roozbeh Mottaghi, Priyam Parashar, Siddharth Patki, Ishita Prasad, Xavier Puig, Akshara Rai, Ram Ramrakhya, Daniel Tran, Joanne Truong, John M. Turner, Eric Undersander, and Tsung- Yang. Partnr: A benchmark for planning and reasoning in embodicd multi-agent tasks. In International Conference on Learning Representations (ICLR), 2025. alphabetical author order.
Paul Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences, 2023. URL https: org/ abs/1706.03741
Yun-Shiuan Chuang, Hsin-Yi Hung, Edwinn Gamborino, Joshua Oon Soo Goh, Tsung- Ren Huang, Yu-Ling Chang, Su-Ling Ych, and Li-Chen Fu. Using machine theory of mind to learn agent social network structures from observed interactive bohaviors with targets. In 2020 29th IEEE International Conference on Robot and Human Interactive Commmuiication (RO-MAN), pp. 1013 1019. IEEE, 2020.
Felipe Codevilla, Eder Santana, Antonio M. López, and Adrien Gaidon. Exploring the limitations of behavior cloning for autonomous driving, 2019. URL https://arxiv org/
Michael K. Cohen, Elliot Catt, and Marcus Hutter. A strongly asymptotically optimal agent in general environments, 2019. URL https://arxiii wwt.aawwwwv...v.a.a../rre http///as//1/..../// 01021
Logan Cross, Violet Xiang, Agam Bhatia, Daniel LK Yamins, and Nick Haber. Hypothetical minds: Scaffolding theory of mind for multi-agent tasks with large language models, 2024.
URL hattps://aat //axiv. org/ abs/ 07086.
Ria Das, Joshua B. Tenenbaum, Armando Solar-Lezama, and Zenna Tavares. Combining functional and automata synthesis to discover causal reactive programs. Proc. ACM Program. Lang., 7(POPL), January 2023. doi: 10.1145/3571249, URL https://doi...... org/ 10. 1145/3571249
Guy Davidson, Graham Todd, Julian Togelius, Todd M. Gureckis, and Brenden M. Lake. Goals as reward-producing programs. Nature Machine Intelligence, 7(2):205 220, February 2025. ISSN 2522-5839. doi: (1.009//12225600550080881 URL https://doi.org: 1038/4422560025-20
Pim de Haan, Dinesh Jayaraman, and Sergey Levine. Causal confusion in imitation learning, 2019. URL
11979
D. C. Dennett. Content and consciousness. International library of philosophy and scientific method. Routledge Kegan Paul [u.a.], London, reprinted edition, 1972. ISBN 978-0- 7100-6512-4.
D. C. Dennett. From bacteria Bach and back: the evolution of minds. W.W. Norton & Company, New York, first edition edition, 2017. ISBN 078-0-393-24207-2.
D. C. Dennetl and Edward Gorey. Broinstorms: philosophical essays on mind and psychology. The MIT Press, Cambridge, Massachusetts London, England, 1981. ISBN 978-0-262- 54037-7.
Daniel C. Dennett. The Intentional Slance. The MIT Press, Cambridge, MA, 1987.
Wei Ding, Fanhong Li, Ziteng Ji, Zhengrong Xue, and Jia Liu. Atom-bot: Embodied fulfillment of unspoken human needs with affective theory mind. arXiv preprint ar Xix::4466008844 08455, 2024.
12

---

Published as a conference paper at ICLR 2026
Shi Dong, Benjamin Van Roy, and Zhengyuan Zhou. Simple agent, complex environment: Efficient reinforcement learning with agent states, 2021. URL https: htwii.xvvvv... org/ abs/
Prashant Doshi and Piotr J Gmytrasiewicz. Monte Carlo sampling methods for approximating interactive POMDPs. Journal of Artificial Intelligncce Research, -4:297-3377, 2009.
Hartry H. Field. Mental representation. Erkenntnis, 13(1):9 61, January 1978. ISSN 0165-0106, 1572-8420.
doi: 10.1007/BF001600 URL http://link: http:://iiinnsssiinnneeeeee sww.nkerr.in.g..... com/10
1007/BF00160888
Andrew Fuchs, Andrea Passarella, and Marco Conti. Modeling, replicating, and predicting human behavior: A survey. ACM Transactions on Autonomous and Adaptive Systems, 18 (2):1-47, 2023.
Lin Guan, Karthik Valmeekam, Sarath Sreedharan, and Subbarao Kambhampati. Leveraging pre-trained large language models to construct and utilize world models for model-based task planning, 2023. URL htttp::/arxxvv.rrgg wwwg/aa///aaa 2305 14909
X. Angelo Huang, Emanuele La Malfa, Samuele Marro, Andrea Asperti, Anthony Cohn, and Michael Wooldridge. A notion of complexity for theory of mind via discrete world models, 2024. URL https://aaxxi: attp::///axxvvorr/aabbb///////// 200.
Thomas leard. Resource rationality. Book manuscript, 434, 2023.
Rodrigo Toro Icarte, Toryn Klassen, Richard Valenzano, and Sheila Mellraith. Using reward machines for high-level task specification and decompasition in reinforcement learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceediiggs of Machine Learning Research, pp. 2107 2116. PMLR, 10 15 Jul 2018. URL https:://tocceeeeeeee
mlr wal...pees//v// https//vv//iiarteee htte:/iiareee...... html
Julian Jara- EattnErtinger and Yarrow Dunham. The institutional stance, Apr 2024. URL osf. httppppprrittt//syyrrrr//////ee
Kunal Jha, Tuan Anh Le, Chuanyang Jin, Yen-Ling Kuo, Joshua B Tenenbaum, and Tianmin Shu. Neural amortized inference for nested multi-agent reasoning. In Proceedings of the
AAAI Conference on Artificial Intelligence, volume 38, pp. 530-537, 2024.
Chuanyang Jin, Yutong Wu, Jing Cao, Jiannan Xiang, Yen-Ling Kuo, Zhiting Hu, Tomer Ull- man, Antonio Torralba, Joshua B. Tenenbaum, and Tianmin Shu. Mmtom-qa: Multimodal theory of mind question answering. 2024. URL
Chani Jung, Dongkwan Kim, Jiho Jin, Jiseon Kim, Yeon Seonwoo, Yejin Choi, Alice Oh, and Hyunwoo Kim. Perceptions to beliefs: Exploring precursory inferences for theory of mind in large language modcls, 2024. URL fattps://arxiv http:///awxwv..gg/a/////sa//
abwpa////.22// 06004
Hyunwoo Kim, Melanie Sclar, Tan Xuan, Lance Ying, Sydney Levine, Yang Liu, Joshua B. Tenenbaum, and Yejin Choi. Hypothesis-driven theory-of-mind reasoning for large language models, 2025. URL htttp:://arat httpaaawwww...r///////.....2 11881
Max Kleiman- -eeine,-WWiiee, Mark K Ho, Joseph L Austerweil, Michael L. Liltman, and Joshua B Tenenbaum. Coordinate to cooperate compete: abstract goals and joint intentions in social interaction. In Proceedings of the anneaal meeting of the cognilive science sociely, volume 38, 2016.
Max Kleiman-Weiin Weiner, Felix Sosa, Bill Thompson, Bas van Opheusden, Thomas L Griffiths, Samuel Gershman, and Fiery Cushman. Downloading culture, zip: Social learning by program induction. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 42, 2020.
Max Kleiman- Weiner, Alejandro Vientós, David G. Rand, and Joshua B. Tenenbaum. Evolving general cooperation with a bayesian theory of mind. Proceedings of the National Academy of Sciences, 122(25), June 2025. ISSN 1091-6490. doi: 10.1073 /.a00///..../ 2400993122. 1073/ 2400993122
URL http:://pss doi prt.//....////aaa...ee.e
13

---

Published as a conference paper at ICLR 2026
Tor Lattimore, Marcus Hutter, and Peter Sunchag. The sample-complexity of general reinforcement learning, 2013. URL http:///aaxxii..ogaaab///sse//// 4828
Jan Leike. Nouparametric general reinforcement learning, 2016. URL abs/1611.0894
Andrew C. Li, Zizhao Chen, Toryn Q. Klassen, Pashootan Vaezipoor, Rodrigo Toro learte, and Sheila A. Mcllraith. Reward machines for deep rl in noisy and uncertain environments, 2025. URL https://arxiv org.abs/////oooooooorog..otaaa aa///bb////200/ 2etp//0000000000000 00120
Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code policies: Language model programs for embodied control, 2023.
URL htt.:httss//// //axpi arxiv. wwtpaattwwwaaaa.////rrrraaataaae 2700//0509907773
Falk Lieder and Thomas L Griffiths. Resource-rational analysis: Understanding human cognition as the optimal use of limited computational resources. Behavioral and brain sciences, 43:e1, 2020.
David Lindner, Xin Chen, Sebastian Tschiatschek, Kalja Hofmann, and Andreas Krause. Learning safety constraints from demonstrations with unknown rewards, 2024. URL https://arxiv.orrs org. wwwporg/////b/eeeeeeeeeeeeeee ab3//305....... 16147
Guiliang Liu, Sheng Xu, Shicheng Liu, Ashish Gaurav, Sriram Ganapathi Subramanian, and Pascal Poupart. A comprehensive survey on inverse constrained reinforcement learning: Definitions, progress and challenges, 2025. URL https://arxiv
2409 20w.///99.00009999
Xiuyuan Lu, Benjamin Van Roy, Vikranth Dwaracherla, Morteza Ibrahimi, Ian Osband, and Zheng Wen. Reinforcement learning, bit by bit, 2023. URL https://arxiv.org/ orgbbbs//gg//////////////.
04047
Sultan J. Majeed. Abstractions of general reinforcement learning, 2021. URL https
//arxiv org/ abs/ 13404
Sultan Javed Majeed and Marcus Hutter. On q-learning convergence for non-markov decision processes, In Proceedings of the Twenty- Seventh International Joint Conference
Artificial Intelligence, 1JCAI-18, pp. 2546 2552. International Joint Conferences Artificial Intelligence Organization, 2018. doi: 10.24963/ijon 2rrai.20183311 3533. URL https
//àoi.org/Bi 10. 24963/ httt://jaaaaaa/// 2018/353
Shehryar Malik, Usman Anwar, Alireza Aghasi, and Ali Ahmed. Inverse constrained reinforcement learning. In Marina Mcila and Tong Zhang (ods.), Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 7390 7399. PMLR, Jul 2021. URL https://proceedingg..u mlr press/ ctess//139/malik222 html
Aviv Netanyahu, Tianmin Shu, Boris Katz, Andrei Barbu, and Joshua B Tenenbaum. Phase: Physically-groundded abstract social events for machine social perception. In Proceedings of the aaai conference on artificial intelligence, volume 35, pp. 845 853, 2021.
Allen Newell and Herbert Simon. The logic theory machine a complex information processing system. IRE Transactions on information theory, 2(3):61 77, 1956.
Allen Newell and Herbert A. Simon. Computer science as empirical inquiry: symbols and search. Comman. ACM, 19(3):113 126, March 1976. ISSN 0001-0782. doi: 10. 10.1145/360018. 360022. URL lhttps://doi http:///oo.orr///////////
Andrew Y Ng. Stuart Russell, et al. Algorithms for inverse reinforcement learning. In Ieml, volume 1, pp. 2, 2000.
Sriyash Poddar, Yanming Wan, Hamish Ivison, Abhishek Gupta, and Natasha Jaques. Personalizing reinforcement learning from human feedback with variational preference learning, 2024. URL http:///wxwv....../ta 10075
14

---

Published as a conference paper at ICLR 2026
Xavi Puig, Eric Undersander, Andrew Szot, Mikael Dallaire Cote, Ruslan Partsey, Jimmy Yang, Ruta Desai, Alexander William Clegg, Michal Hlavac, Tiffany Min, Theo Gervet, Vladimír Vondruš, Vincent-Pierre Berges, John Turner, Oleksandr Maksymets, Zsolt Kira, Mrinal Kalakrishnan, Jitendra Malik, Devendra Singh Chaplot, Unnat. Jain, Dhruv Batra, Akshara Rai, and Roozbeh Mottaghi. Habitat 3.0: A co-habitat for humans, avatars and robots, 2023.
Linlu Qin, Liwei Jiang, Ximing Lu, Melanie Sclar, Valentina Pyatkin, Chandra Bhagavatula, Bailin Wang, Yoon Kim, Yejin Choi, Nouha Dziri, and Xiang Ren. Phenomenal yet puzzling: Testing inductive reasoning capabilities of language models with hypothesis refinement, 2024. URL https:///arxi...gab////////
08559
Neil Rabinowitz, Frank Perbet, Francis Song, Chiyuan Zhang, SM Ali Eslami, and Matthew Botvinick. Machine theory of mind. In International conference on machine learning, pp- 4218 4227. PMLR, 2018.
F. P. Ramsey and G. E. Moore. Vi. symposium: Pfcts and propositions.? Aristotelian Society Supplementary Volume, 7(1):153-2000) 206, 1927. doi: 10.1093/ L...0///rristoeliassupp/LLLL/
Bharance Rathnasabapathy, Prashant Doshi, and Piotr Gmytrasiowicz. Exact solutions of interactive pomdps using behavioral equivalence. In Proceedings of the fifth international joint conference Autonomous agents and multiagent systems, pp. 1025-1032, 2006.
Milena Rmus, Akshay K. Jagadish, Marvin Mathony, Tobias Ludwig, and Eric Schulz. Generating computational cognitive models using large language models, 2025. URL
https://arxiv. org/ http:/bbb2220...e2 00879
Gilbert Ryle. The concept of mind. British Journal for the Philosophy of Science, 1(4): 328 332, 1949.
Roger C. Schank and Robert P. Abelson. Scripts, Plans, Goals, and Understanding. Psy- chology Press, 0 edition, May 2013. ISBN 978-1-134-91966-6 URL. http:://ww..a.bbbrraccc...... http::/www.....aac........oooaaa
doi: 10.4524//99002007810666
Iris Rubi Seaman, Jan- Willem van de Meent, and David Wingate. Nested reasoning about autonomous agents using probabilistic programs. arXiv preprinl urxiv:1812.01556 2018.
Jack Serrino, Max -leiman-Weiner, David Parkes, and Josh Tenenbaum. Finding friend and foe in multi-agent games. Advances in Neural Information Processing Systems, 32, 2019.
Michael Shum, Max Kleiman-Weiin Weiner, Michael Littman, and Joshua Tenenbaum. Theory of minds: Understanding behavior in groups through inverse planning. In Proceedings of the AAAI conference on artificial intelligence, volume 33, pp. 6163 6170, 2019.
Joar Skalse and Alessandro Abate. Quantifying the sensitivity of inverse reinforcement
learning misspecification. arXie preprint arXiw:2403. 00.644........ 2024.
Ray Solomonoff. Complexity-based induction systems: comparisons and convergence theo-
rems. IEEE transactions on Information Theory, 24(4):422 1978.
Ray Solomonoff. Docs algorithmic probability solve the problem of induction. Orbridge Research, POB, 391887, 1996.
Ray J Solomonoff. formal theory of inductive inference. part Information and control, (1):1 22, 1964.
Haotian Sun, Yuchen Zhuang, Lingkai Kong, Bo Dai, and Chao Zhang. Adaplanner: Adeptive planning from feedback with language models, 2023. URL httph:ttt///aiiii wttpaaaiiii.rraa////0/00000 16653
Richard S Sutton, Doina Precup, and Satinder Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artif. Intell., 112(1-2)) 181-211, August 1999.
15

---

Published as a conference paper at ICLR 2026
Hao Tang, Darren Key, and Kevin Ellis. Worldcoder, model-based Ihm agent: Building world models by writing code and interacting with the environment. Advances in Newral Information Processing Systems, 11770148-70211 2024.
Momchil S. Tomov, Pedro A. Tsividis, Thomas Pouncy, Joshua B. Tenenbaum, and Samuel J. Gershman. The neural architecture of thcory-based based reinforcement learning. Neuron, 111 (8):1331 1344.e8, April 2023. ISSN 0896-6273. doi: n..006//..eeuron22000 2023.01.02.... URL Publisher: Elsevier.
1016/j neuron. 2023.01.20.. 01.023
Faraz Torabi, Garrett Warnell, and Peter Stone. Behavioral cloning from observation, 2018.
URL https://arxiv.. org/ www.aa05. 01954
Rodrigo Toro Icarte, Toryn Q. Klassen, Richard Valenzano, and Sheila A. McIlraith. Reward machines: Exploiting reward function structure in reinforcement learning. Journal of Artificial Intelligence Research, 73:173 208, January 2022, ISSN 1076-9757. doi: 10.1613/ URL http://dx doi...doii... www.ooooo.o.....11o1 1ttp://...11////a....1.4.... 12440
Trieu H. Trinh, Yuhuai Wu, Quoe V. Le, He He, and Thang Luong. Solving olympiad geometry without human demonstrations. Nature, 625(7995) 482, January 2024. ISSN 1476-4687. doi: 10.1038/s41558 10.1033//441586-02-0004444
URL https: org//0..038/
841586-023-06747-5
Dweep Trivedi, Jesse Zhang, Shao-Hua Sun, and Joseph J. Lim. Learning to synthesize programs as interpretable and generalizable policies, 2022. URL https://arxiv org/
abs 2ts/2108.13644
Pedro A. Tsividis, Joao Loula, Jake Burga, Nathan Foss, Andres Campero, Thomas Pouncy, Samuel J. Gershman, and Joshua B. Tenenbaum. Human-level reinforcement learning through theory-based modeling, exploration, and planning, 2021. URL https://arxiv
htggabs/2107.. 12544
Tomer Ullman, Chris Baker, Owen Macindoe, Owain Evans, Noah Goodman, and Joshua Tenenbaum. Help or hinder: Bayesian models of social goal inference. Advances in neural information processing systems, 22, 2009.
Tomer D Ullman and Πooaa Bass. The detection of automatic behavior in other people, May 2024. URL oaf http://ppp..iiss//ssrrr/////////
Abhinav Verma, Hoang M. Le, Yisong Yue, and Swarat Chaudhuri. Imitation-projected http:///aaxxv..o.aa/////saaa///a
programmatic reinforcement learning, 2021. URL
Yanming Wan, Yue Wu, Yiping Wang, Jiayuan Mao, and Natasha Jaques. Infer human's ''s intentions before following natural language instructions. In Proceedings of the AAAT Conference Artificial Intelligence, volume 39, pp.
2025.
Huaxiaoyue Wang, Gonzalo Gonzalez- Yash Sharma, and Sanjiban Choudhury. Demo2code: From summarizing demonstrations to synthesizing code via exlended chain- of-thought, 2023. URL
16744
Pin Wang, Hanhan Li, and Ching- Yao Chan. Meta-advereariaal inverse reinforcement learning for decision-making tasks, 2021. URL httpp/////axxiioo//abba///////// /t10///////11111199.111
Rose F. Wang, Sarah A. Wu, James A. Evans, Joshua B. Tenenbaum, David C. Parkes, and Kleinan--Wiiner Too many cooks: Bayesian inference for coordinating multi-agent collaboration, 2020. URL htttss://axx//
Max Kleiman- Weiner.
btggaabs/0003.11///
Alex Wilf, Sihyun Shawn Lee, Paul Pu Liang, and Louis- Phils-P Morency. Think twice: Perspective-taking improves large language models' theory-of-mint capabilities, 2023. URL
https://arxiv..rgg /211s//311...m 10227
Lionel Wong, Gabriel Grand, Alexander K. Lew, Noah D. Goodman, Vikash K. Mansinghka, Jacob Andreas, and Joshua B. Tenenbaum. From word models world models: Translating from natural language to the probabilistic language of thought, 2023a. URL https
7/arxiv. //arxiv.org/ab//2223 12672
16

---

Published as a conference paper at ICLR 2026
Lionel Wong, Jiayuan Mao, Pratyusha Sharma, Zachary S. Siegel, Jiahai Feng, Noa Korneev, Joshua B. Tenenbaum, and Jacob Andreas. Learning adaptive planning representations with natural language guidance, 2023b. URL https://aaxiv.com org/ abs 2312 08566
Lionel Wong, Katherine M. Collins, Lance Ying, Cedegao E. Zhang, Adrian Weller, Tobias Gerstenberg, Timothy O'Donnell, Alexander K. Lew, Jacob D. Andreas, Joshua B. Tenen- baum, and Tyler Brooke- Wilson. Modeling world cognition as on-demand synthesis of probabilistic models, 2025. URL httth: wtwg/aa////aeeeeeee 12547
Wendy Wood. Habits, goals, and effective behavior change. Current Directions in doi: 10.1177/0066372144412222
Pssychological Science, 33(4):226 232, 2024.
URL
Markus Wulfmeier, Peter Ondruska, and Ingmar Posner. Maximum entropy deep inverse reinforcement learning, 2016. URL fttt:://aazivv.orgabbb///// 04888.
Yang Yang, Chao Yang, Boyang Li, Yinghao Fu, and Shuang Li. Neuro-symbolic temporal point processes, 2024. URL
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models, 2023. URL
http://axxii.oorraa/222222
Mustafa Yildirim, Barkin Dagda, Vinal Asodia, and Saber Fallah. Behavioral cloning models reality check for autonomous driving, 2024, URL https://arxiv. wwtp:/r.//..b/....e/e
Lance Ying, Jason Xinyu Liu, Shivam Aarya, Yizirui Fang, Stefanie Tellex, Joshua B Tenenbaum, and Tianmin Shu. Siftom: Robust spoken instruction following through theory of mind. arXiv preprint arXiv:2409.1085 10849, 2024.
Lance Ying, Kunal Jha, Shivam Aarya, Joshua B. Tenenbaum, Antonio Torralba, and Tianmin Shu. Goma: Proactive embodied cooperative communication via goal-oriented mental alignment, 2025. URL httphhttts//aaat wwwpxivvorrgaaaee httgg//b//403.11111 11075
Wenhao Yu, Nimrod Gileadi, Chuyuan Fu, Sean Kirmani, Kuang- Lee, Montse Gonzalez Arenas, Hao-Tien Lewis Chiang, Tom Erez, Lconard Hascnclever, Jan Humplik, Brian Ichter, Ted Xiao, Peng Xu, Andy Zeng, Tingnan Zhang, Nicolas Heess, Dorsa Sadigh, Jie Tan, Yuval Tassa, and Fei Xia. Language to rewards for robotic skill synthesis, 2023. URL attps://arxivv org/ /20// 08647
Zhining Zhang, Chuanyang Jin, Mung Yao Jía, and Tianmin Shu. Autotom: Automated bayesian inverse planning and model discovery for open-ended theory of mind, 2025. URL https://arxiv.om wwwpeiivvorrr/baae Ptrrg/bss/255 ab5// 15676
Tan Zhi- Zhi-Xuan, Jordyn L. Mann, Tom Silver, Joshua B. Tenenbaum, and Vikash K. Mans- inghka. Online bayesian goal inference for boundedly-rational planning agents, 2020. URL
htapss://axxiv.orrg aasp//bs////00 /006..2200...0 07532
Tan Zhi-Xuan, Lance Ying, Vikash Mansinghka, and Joshua Tenenbaum. Pragmatic instruction following and goal assistance via cooperative languago-guided inverse planning. arXiv preprint arxiv:2402. 17930000..71,,,. 2024.
Weichao Zhou and Wenchao Li. A hierarchical bayesian approach to inverse reinforcement learning with symbolic reward machines, 2022. URL. https://arxiv..or wttgg/abs//00./ 09772
Yanggiaoyu Zhou, Haokun Liu, Tejes Srivastava, Hongyuan Mei, and Chenhao Tan. Hypoth- esis generation with large language models. In Proceedings of the 1st Workshop on NLP for Science (NLP4Science), pp. 117-139. Association for Computational Linguistics, 2024. doi: 10.18653/v1 (0..863e// nlp4science-11100
URL bttp://dxx doi org/10. 18653/11224
17

---

Published as a conference paper at ICLR 2026
Chuning Zhu, Raymond Yu, Siyuan Feng, Benjamin Burchfiel, Paarth Shah, and Abhishek Gupta. Unified world models: Coupling video and action diffusion for pretraining on large robotic datasets, 2025. URL https://arxxv..rggg org httg/bbs/5504 027922.
Feiyu Zhu and Reid Simmons. Bootstrapping cognitive agents with large language model, 2024. URL
A
APPENDIX
A.1
GROUND TRUTH AGENT BEHAVIOSS FOR CONSTRUCTION
For research question in Section 5 hand designed 10 agents, represented Finite State Machines, to engage in diverse behaviors. The agents variod in complexity, with some using sophisticated A-star search to achieve a goal, and others using faster, less resource-intensive planning heuristics, namely the Manhattan distance as an approximation of how valuable an action is for an agent looking to move to target location. While there is a large body of literature and debate surrounding what it means to be goal-directed, in this work we say any agents conducting forward plans, denoted by explicit rollouts within the environment, are considered to be goal-directed. Tn the Construction gridworld task, this means the agents using A-star to complete tasks such as "pickup green blocks and move them to the corner" and "pair all blue blocks together" are goal-directed, whereas "patrol the grid in clockwise direction," " which uses the Manhattan distance and FSM states as planning heuristics, are considered scripted. In Partar, all of the LLM agents are goal-directed since they use the ReAct framework to plan how to complete household tasks. When collecting human data, we do not know if the participants are conducting detailed planning. We note that while we motivate our work from prior literature in cognitive science about predicting the behavior of scripted agents, our empirical results demonst that our approach is robust to predicting goal-directed behavior in the sense that we define it here, We summarize the behaviors and internal decision making states for all ground-truth agents below:
1. Block Cycle:
Using the manhattan distance the planning heuristic, move from the green block to the blue block to the purple block to the green block and so on. If the agent ever has a block in its inventory, it will immediately drop it and resume its cycling behavior.
2. Clockwise Patrol: If an agent is not along the outermost wall of the grid, it will repeatedly alternate between moving left and moving up until it hits wall. Then, it will follow the wall clockwise: there is a wall above it, the agent will move right repeatedly until it hits a wall, then repeats this process for going down, left, up and right again. the agent ever has a block in its inventory, it will immediately drop it and resume its eycling behavior.
3. Counter-clockwiss Patrol:
This agent is the same Clockwise Patrol, except it it will patrol the border wall in a cloctir-clokkwie manner, moving left repeatedly until it hits a wall, then doing the same for moving down, right, up and left again.
4. Left-Right Patrol:
The agent will move left until it hits wall, then will move right until it hits a wall, and repeat this process. If the agent ever has a block in its inventory, it will immediately drop it and resume its patrolling behavior.
5. Pair Blue Blocks: This agent uses A-star search for planning. If it does not have blue block in its inventory, it finds and executes the shortest path to a blue block. Then, it uses the "intcract" action to add the block to its inventory, and uses A-star find the shortest path to different blue block.
6. Patrol with A-Star: Here, the agent's goal is to repeatedly cycle between the top left, top right, bottom right, and bottom left corners of the grid. While Clockwise Patrol has a behavior which the surface may seem similar, for Patrol with A-star we introduced addition complexity by having the agent believe it incurs a penalty for touching any of the colored blocks. As such, it uses A-star with negative edge values given to any action which leads an agent to landing on a colored block, thus resulting in behavior which tries to patrol but frequently leaves and returns to the border to
18

---

Published as a conference paper at ICLR 2026
E
Figure 7: Example scripts from Construction. We designed suite of goal-directed (planner- based) and automatic (heuristic- based) agentic behaviors, from patrolling transporting spe- cific blocks to a location.
Cycle Betveen Purple + Green * Blue
Move in "L'-shape
Snake through the onviromeent
avoid colored blocks. Again, if it ever picks up a colored block, it immediately drops it.
7. L-shaped Patrol: This agent, initially at a coordinate (z, y), will move down until it collides with wall, then will move right until it collides with wall. Then, it will return to its original location, first moving left. until its x-coordinate is &, and up until its final coordinate is (æ, y)- Tt repeatedly does this process. The agent immediately drops any blocks in its inventory.
8. Transport Green:
Here, the agent uses A-star search to move towards a green block and pick it up. Then, it uses A-star search to move the green block close to an empty corner grid cell.
9. Snake Patrol:
This agent has four internal decision-making states: 1) Moving down/right, where the agent moves right until it cannot any more, then moves down one step; 2) Moving down/left, where the agent moves left until cannot any more, then moves down one step; 3) Moving up/right, where the agent moves right until it cannot any morc, then moves up one step; 4) Moving up/left, where the agent moves left until it cannot any more, then moves up step. The resulting pattern appears like a snake moving throughout the grid.
10. Up/Down Patrol: The agent will move up until hits a wall, then will move down until it hits wall, and repeat. this process. If the agent ever has block in ils inventory, it will immediately drop it and resume its patrolling behavior.
A.2 HUMAN RESULTS BREAKDOWN
In Figure 8 show the accuracy for ROTE compared to humans when predicting FSM behavior in Construction. An example some of the task are shown in Figure In Figure g show the accuracy for ROTE compared to humans when predicting Human behavior in Construction. We find that humans excel at predicting goal-directed tasks while our method performs better with repetitive tasks, although all of the variance in predictive accuracy cannot be captured by this distinction. In subsequent followups, we plan to do a greater exploration of the different error modes of humans and other models, as well as scale ROTE to larger language models, to see whether ROTE is an accurate computational model of human behavior.
A.3 CLUSTERED TASK BREAKDOWN PARTNR
To understand the types of tasks ROTE excels at compared to baselines in the Partar simulator, we used 1aaama-..--B-Insteee set into three categorics. As shown in Figure 10, we report the mcan prediction accuracy and standard error for each algorithm on per-cluster basis. While AutoToM and Behavior Cloning show some success on lasks involving simple actions like moving and rearranging objects, they struggle significantly with more complex interactions, such as turning items on/ off or cleaning. ROTE, in contrast, maintains a degree of accuracy in these more challenging settings.
cluster the ground-truth tasks from our test
A.4 MODEL COMPONENT ANALYSIS
We show the effect of different model components. While the choice of observation parsing did not have too much of an impact on the Construction evaluations, [ indicates it has significant. effect predictive performance in Partnr. This is likely because the
19

---

Published as a conference paper at ICLR 2026
Accuracy by FSM ID and Model
up_ down
snake
pickup pickup_green a star
pattern l
FSM ID
patrol_we wit th star
pair blue
left left_right
cuunter_patrol
fackwise__ptrrols
block_cycle
0.0
0.2
0.4
0.6
0.8
1.0
Accuracy
Human
ROTE
NLLM
AutoToM
BC
Figure 8: Per-task accuracy comparison between different methods predicting ground truth FSM gameplay.
20

---

Published as a conference paper at ICLR 2026
Accuracy by FSM Model
Up and down
Snake and down
Pink to corner
Green corner
FSM ID
L-spape
Pair blue blocks
Left to right
Patrol Counter-clockwise
Patrol Clockwise
Repeat green
0
0.
0.2
0.3
0.5 0.6 Accuracy
0.4
0.7
0.8
Human
ROTE
NLLM
AutoToM
BC
Figure 9: Per-task accuracy comparison between different methods predicting human gamee play. While ROTE succeeds at more routine tasks, humans excel in predicting more goal directed behaviors.
0.
Model
0.6
BC
Accuracy
0.5
AutoToM
NLLM
0.4
ROTE
0.3
0.2
0.1
0.0
Organizing Items
Moving Objects Across Rooms Interacting With Objects Cluster
Figure 10: Task-specific generalization in Parter. We used Llama-3, 1--BBB...11--BBB I-St--nrtrtt to cluster our prodiction tasks into three distinct categorics. We report the mean accuracy and standard error (SE bars) for cach algorithm. While basclincs like AutoToM and Bchavior Cloning perform adequately on tasks involving object manipulation, they struggle with more complex interactions. ROTE, however, maintains performance these more intricate problems.
21

---

Published as a conference paper at ICLR 2026
Construction Dataset
Human Dataset
Partnr Dataset
0.31
0.50
Accuracy
0.4
Accuracy
Accuracy
0.25
0.2
0
10
20
30
10
20
30
10
20
30
# of Hypotheses
# of Hypotheses
# of Hypotheses
ROTE w/ 2-stage
ROTE w/o 2-stage
Figure 11: Ablating Observation Parsing
Construction Dataset
Human Dataset
Partnr Dataset
0.3
Accuracy
0.4
Accuracy
Accuracy
0.3
0.2
0.2
0.2
10
20
30
10
20
30
0.1
10
20
30
of Hypotheses
of Hypotheses
# of Hypotheses
ROTE Rejuvenation
ROTE w/ Importance Sampling
Figure 12: Ablating Inference Algorithm
observations, which already in natural language, contain critical information on the data structures they are represented as that abstraction removes.
Figure 12 demonstrates the benefits of different inference algorithms in ROTE. While ROTE not very sensitive to the choice of probabilistic inference method used as it has more candicate agent programs, if agents are constrained by the number of hypotheses they can maintain, performing SMC with rejuvenation proves to be more effective strategy, since this effectively augments the number of programs considered.
reveals an interesting gradient along which different degrees of structure influence ROTE's ability to predict behaviors. In controlled settings where agents are Finite State Machines following deterministic transitions between behaviors, increasing the amount of structure used predict what they will do next does not significantly harm performance. This can be a useful inductive bias that reduces cognitive load for agents interacting with systems that require prediction order to effectively interact with, such as thermostat, but are nevertheless simple enough lo represent as series of rules. In the hunan-behavion setting, this does not hold as well. We find a moderate amount of structure, where providing more detailed examples about what the internal mechanisms of the observed agent look like without forcing ROTE to generate code following that structure, performs the best. These settings closest to realistic encounters with other people: when walking down the street or ordoring coffee, we may try to follow scripts or conventions for how to interact, but there is inherent variability in behaviors that more open-ended programs must account for. Lastly, when predicting the behavior of agents that are goal-directed in partially observable world, imposing FSM structure greatly diminishes performance. These scenarios where prediction might best be performed by more complex reasoning processes about an agent's intentions and beliefs. Here, constraining code to be structured as an FSM might fail to account for how agents react to the presence of unknown unknowns they encounter.
Figure 13
A.5 RELATIONSHIP BETWEEN PROGRAM SIZE ([Al) AND ACCURACY
As shown in Figure higher prediction accuracy in Construction and Parter corresponds to shorter programs (in characters). This occurs even though program length is not explicitly factored into the likelihood computation, suggesting that the approach naturally favors simple, efficient representation of the agent's behavior. This aligns with our hypothesis, inspired by Solomonoff (Solomonoff. 1964 1978 1996). that shorter programs will generalize more effectively due to Occam's
22

---

Published as a conference paper at ICLR 2026
Construction Dataset
Human Dataset
Partnr Dataset
Accuracy
0.4
Accuracy
0.3
Accuracy raurac
0.3
0.2
0.2
0.2
0.1
20
30
10
30
0
10
20
30
# of Hypotheses
# of Hypotheses
# of Hypotheses
ROTE w/ Light
w/ Moderate
ROTE w/ Severe
Figure 13: Ablating Structure Enforced in Generated Code
Construction Dataset
Progran Length
Human Da taset
Program Length
Partnr Dataset
Progre an Length
Accuracy
14400
Accuracy currayy
0.225
4400
Accuracy
0.20
0.30
4300
0.15
0.25
4200
0.175
0.10
3800
20
20
20
of Hypotheses
of Hypotheses
of Hypotheses
Accuracy
Progran Length
Figure 14:
Average program length (in characters) versus prediction accuracy a function of the number of generated hypotheses for Construction and Partnr. Shorter programs yield higher accuracy for scripted, human, and LLM agents.
A.6 TOP-K EFFECT
In Figure 15 we explore the impact of different k values for the top-k hypothesis pruning phase after genoration. We tried = 1, 10, and 30. We did not find any meaningful variation in performance
function of k. This suggest the choice of which hyperparamcter to may be left to the agent designer. Whereas smaller & values enable faster inference, larger values enable better uncertainly estimation. Moreover, because of the largely deterministie nature of the generated programs, there can be an implicit top-k effect at higher hypothesis numbers, wherein unlikely programs are assigned very low probabilities throughout trajectory, effectively leading to their pruning during policy selection for action prediction.
A.7 PER-LLM RESULTS
In Tables 2 and report the raw accuracy of different LLM models using different algorithms, as well as the standard error, on the Scripted, Human, and LLM-agent behavior datascts in Construction and Partnr. For the results reported in the paper, we had to tune the number of hypothesis and other hyperparameters, such as whether to use two-stage observation parsing,
dataset-by-dalaset basis. We did this by running sweep of
Construction Dataset
Human Dataset
Partnr Dataset
Accuracy
0.4
Accuracy
0.3
Accuracy
0.3
0.2
0.2
0.2
0
20 of Hypotheses
10
30
10
20
30
0
20 of Hypotheses
10
30
of Hypotheses
ROTE (K=1)
ROTE (K=10)
ROTE (K=30)
Figure 15: Top-k parameter analysis Construction. No appreciable difference in accuracy result of different parameters, suggesting the choice between uncertainty preservation (maintaining a larger set of hypotheses from a larger k) and prediction speed (by executing less programs with smaller k) is up to the agent and agent designer.
23

---

Published as a conference paper at ICLR 2026
hyperparameters and comparing their performance on 20% of the data, then utilizing the best performing hyperparameter from that subset, as the selected model configuration for the remaining 80% of the data. The hyperparameters used for each environment can be found in Section A.11
Algorithm
DeepSeek-Coder-Ve V2-
DeepSeek-V2-ID (16B)
Llama-3.1-8B- Instruct
Lite-Instruct (16B)
AoM
0.000 + 0.000
0.000 + 0.000
0.202 = 0.023
NLLM
0.310 + 0.032
0.266 + 0.018
0.340 0.033
Chain-of- Chaon-of-Thought
0.210 = 0.04
0.210 = 0.04
0.269 = .025
ROTE (light)
0.479 + 0.033
0.312 = 0.032
0.477 0.044
ROTE (moderate)
0.436 = 0.042
0.256 = 0.032
0.446 0.051
ROTE (severe)
0.457 = 0.037
0.298 + 0.033
0.390 = 0.049
ROTE (two-stage)
0.522 + 0.046
0.271 + 0.028
0.468 = 0.052
Table 1: Multi-stop LLM results (with standard error) for Ground-truth Scripted Gameplay Data Prediction in Construction.
Algorithm
DeepSeck-Coder-WV! V2-
V22-Lte (16B)
Llama-3.1-8B- Instruct
Lito-Instruct (16B)
AutoTTo
0.000 = 0.000
0.000 = 0.000
0.156 = 0.011
NLLM
0.151 + 0.012
0.176 + 0.013
0.171 = 0.016
Chain-of Thought
0.000 = 0.000
0.000 = 0.000
0.156 = 0.011
ROTE (light)
0.296 + 0.019
0.199 + 0.015
0.305 = 0.022
ROTE (moderate)
0.310 + 0.018
0.204 + 0.021
0.266 = 0.024
ROTE (severe) 0.304 + 0.022
0.230 + 0.018
0.245 = 0.026
ROTE (two-stage)
0.329 + 0.031
0.209 + 0.014
0.327 0.026
Table 2: Multi-step LLM results (with standard error) for Human Gameplay Data. Prediction in Construction.
Algorithm
DecpSeek-Coder-W V2-
Dee-Seck-V2-Lite (16B)
Llama-3.1-8B- Instruct
Interunstruct (16B)
Auto'ToM
0.000 + 0.000
0.000 + 0.000
0.050 = 0.015
NLLM
0.113 = 0.018
0.333 = 0.027
0.170 0.022
Chain-of Thought
0.000 + 0.000
0.000 + 0.000
0.050 = 0.015
ROTE (light)
0.537 + 0.029
0.439 = 0.066
ROTE (modcrate)
0.472 + 0.029
0.026 + 0.026
0.426 0.051
ROTE (severe)
0.440 + 0.029
0.510 0.072
ROTE (two-stage)
0.160 + 0.021
0.114 + 0.055
0.112 = 0.034
Table 3: Single-step LLM results (with standard error) for LLM Agent Gameplay Data Prediction in Parter.
In Table 4 we explored how well ROTE scales when paired with a powerful foundation model, GPT-4o. Due to cost constraints, only compared ROTE to the most successful baseline from our prior results, NLLM. We find that across the board, ROTE outperforms NLLM even with this more powerful model. However, we observe this benefit degrades slightly in the Partnr benchmark, indicating the advantages of predicting in code compared to natural language may diminish in certain goal-directed, embodied settings. In Table 5
24

---

Published as a conference paper at ICLR 2026
Algorithm Construction
Human
Partnr
NLLM
0.313 + 0.064
0.149 + 0.017
0.78 + 0.042
ROTE
0.566 + 0.028
0.402 + 0.017
0.857 + 0.142
Table 4: Accuracy results (with standard error) across 3 datasets with models using GPT-4o as the underlying LLM.
ran a similar analysis on the Qwen models, and found that while all baselines improve with greater model size, ROTE offers a substantial boost in performance in almost all domains except for Partnr.
Table 5: Qwen Model Accuracy (%) and Std. Error on All Tasks and Baselines
Model
Construction
Human
Partnr
ROTE Baseline
14B Instruct
63.78% 4.55%
+
50.00% + 13.87%
7B Instruct
48.89% + 9.14%
31.46% + 2.27%
22.58% + 7.63%
3B
Instruct
45.62% 5.97%
32.50% + 2.50%
26.32% + 10.38%
NLLM Bascline
14B Instruct
33.48% + 4.89%
17.00%
71.00% = 4.56%
7B Instrucl
32.21% + 4.42%
12.00% + 1.18%
26.00% + 4.41%
3B - Instruct
25.30% + 3.87%
8.00% + 0.91%
29.00% + 4.56%
Chain-of-Thought Baseline
14B Instruct
26.74% + 2.96%
11.50% + 0.69%
42.00% + 4.96%
7B Instruct
24.52% + 1.65%
8.60% = 0.90%
12.00% + 3.27%
3B Instruct
19.80% 3.21%
4.80% + 0.66%
11.00% + 3.14%
AutoToM Baseline
14B Instruct
0.00% + 0.00%
0.00% + 0.00%
0.00% + 0.00%
7B Instruct
0.00% + 0.00%
0.00% = 0.00%
0.00% + 0.00%
3B - Instruct
0.00% + 0.00%
0.00% = 0.00%
0.00% = 0.00%
Speed Analysis. We conducted a per-model speed analysis. All models ran on a single GPU-L40. We find that across model families and sizes there is consistent relationship between inference speed and model size on our hardware. seconds to generate a complete set of 30 hypotheses, whereas the 16b Deepseek V2 Lite took 33 seconds. Interestingly the Deepseek-Codes seconds to generate the of hypotheses and also performed the best. The Qwen family had inference time monotonically increase with model size: Qwen2.5-33b-nsst Awen2.5--b-Instaan took 43 seconds, and 10wen2.5-144-Tnsste the consistent scaling of the Qwen family evidence that variations in model architecture, which is beyond our control, is the primary contributing factor to the variations in speed, As such, use program length (in terms of nunber of characters) as proxy for model officiency. However, we note this an imperfoct assumption, since a large body of litcrature topics like speculative decoding and meta-RL look for ways to distill the capabilities of large, powerful LLMs into lightweight, real-time models, making the elficiency gain of our method more nuanced.
took 49
22-Lite-Instruce which is also 16b, took 16
took 25 seconds, took seconds. We use
A.8 ROTE IN THE CONTEXT OF EXISTING PROGRAM INDUCTION METHODS
We also draw parallels to concurrent work that leverages large language models (LLMs) for program synthesis in cognitive modeling, such as CogFunSearch (Castro et al. 2025 CogFunSearch focuses the mechanistic discovery of symbolic cognitive learning and
25

---

Published as a conference paper at ICLR 2026
deciston-making algorithms (such as Q-learning with forgetting terms) in dynamic multi- armed bandit tasks, operating on large datasets across multiple species. Its methodology employs high-cost, bilevel optimization, featuring time-intensive outer evolutionary loop to explore novel program structures (Ø) and an inner iable loop to fit continuous parameters (0). This high computational budget is justified by the complexity of simulta- neously discovering program structure and fitting continuous parameters to capture subtle learning dynamics. In contrast, ROTE is engineered for the real-time action prediction problem in non-Markovian embodied scttings, prioritizing scenarios where data is sparse and rapid inference is essential. ROTE eschews the evolutionary loop and continuous parameter optimization, instead relying on an efficient, single-step generalive process where the LLM synthesizes a constrained space of executable program hypotheses, often implicitly modeling a Finite State Machine, from sparse observations. This results in an executable representation that enables orders-of of faster long-horizon prediction by executing inferred code directly, bypassing repeated LLM calls. While CogFunSearch excels at high-fidelity mechanis- tic discovery with high computational costs, ROTE offers a complementary, computationally efficient framework for representing and rapidly inferring the sequential, script-like behavioral structures prevalent in robotics and social prediction. A potential synthesis lies in using ROTE's efficiency to rapidly converge on high-level program//cripp. which can then be refined using CogFunSearch's methods to tune continuous cognitive parameters within that specific structure.
Temporal Point Processes (TPPs), particularly those enhanced with logic rules, are a related research thread for modeling behavior by predicting both future action time and type based on constrained, human-readable logic (Cao et al. 2024). TPP methods like the Jeuro-Symbol TPP (NS-TPP) excel at utilizing continuous-tim models and diffcrentiable rule induction to maximize data likelihood, offering highly precise view of event dynamics (Yang et al. 2024).. ROTE, however, offers distinct advantages rooted in its executable representation. ROTE's core strength is inferring complete, explicit behavioral program (code), which directly serves as the agent's 's policy for Long-horizon prediction. This programmatic approach inherently provides causal model of the agent's maaisin logie, offering greater interpretability in understanding why an action sequence occurs. While TPPs are naturally constrained by predefined set of logical predicates, which limits their expressive range, ROTE uses Turing-complete language (Pythou). This design choice enables ROTE to capture arbitrarily complex, non-Markovian behavior, making it more expressive for open-ended, embodied domains like Partnr compared to predicate-basee
TPPs. This difference in representation highlights their complementary focuses: TPPs are effective at predicting when the next discrete event will occur, while ROTE focuses on inferring what the agent is doing (the behavioral script).
In Table 6 we bascline against a program induction method "Iterated Hypothesis Refinement," " which tries to extract rules underlying observed behavior and apply them to novel observations (Qiu et al. 2022)). While our results are still preliminary, we find that this method on its own is insulficient for making robust behavioral predictions.
A.9 HUMAN EXPERIMENT DETAILS
conducted three separate human experiments: the first was collecting human gameplay data, the second was having humans predict human behavioral data, and the third was having humans predict scripted FSM agent behavior. We will open-source all of the code and stimuli used for conducting all three human experiments. For the gameplay collection, we gave participants a tutorial stage learn the controls, and randomized the order of the tasks they played to control for ordering effects, For the behavior prediction experiments, the setup was virtually identical to that of the AT, albeit with two small modifications. The first is that we only had humans predict five timesteps into the future. This was done to make the experiment flow smoother and take less time so that participants did not fatigue for later scripts, resulting in lower prediction quality. The second change we made was we showed people 3 distinct trajectories generated by the observed agent before giving them huo = {1) (02.0)) 22) .... (019, (19), d2o} and having them predict an agent's 's behavior. This additional context was used to help participants familiarize themselves with the dynamics of the gridworld and the space of potential agent
As described in Scction
26

---

Published as a conference paper at ICLR 2026
Table 6: Model Accuracy (%) and Std. Error comparison between ROTE and Iterated
Hypothesis Refinement
Model
Construction
Human
ROTE Baseline
DeepSeek-Codee -i---VLL-----ttrreee (1613
52.2% + 4.6%
32.9% + 3.1%
DeepSeek- --a--eee-V-LLite V2-Lite (16B)
31.2% + 3.2%
23% + 1.8%
Llama3.1-8b-Instee --b-rInttuctt Qwen- Bean-BB-Inntere
47.7% 4.4%
32.7% + 2.6%
48.89% + 9.14%
31.46% + 2.27%
Iterated Hypothesis Refinement Baseline
DeepSeek-Code Coaiee--oerr---a Coder-V2-Lite- V2-Lite-Instruct (16B)
7%
4%
DeepSeek- Vi-Lite (16B)
19%
0.2%
Llama3. 1-8b-Instruct
8%
6.8%
Qwen-7B-Instruct
7.6%
2.8%
behaviors. In contrast, of our baselines only saw the current trajectory h22-- While this was done due to the limited context window of the models used, we feel that this is still a fair comparison between humans and our baselines, since the training corpora for LLMs is rich with gridworld implementations and agent programs, and the BC model had extended training period with the agent behavior is predicting. In future work, we plan on relaxing this constraint by exploring dynamically growing librarics of agent programs which persist across multiple context windows, similar to an approach used in (Tang et al. 2024
A.10 BEHAVIOR CLONING MODEL IMPLEMENTATION DETAILS
We use an architecture and training methadology similar to the one in RRaiinowitz et al. 2018) for training BC model with recurrence. The model
2-layer ResNet to extract leatures from the input observations. Each observation is an image of size 70x70 pixels. The ResNet consists of two ResNet blocks, each containing two convolutional layers with batch normalization and ReLU activation function. The first block uses a feature size of 64 while the second uses feature size of 32. All blocks use stride length of for all convolutional layersand kernel size of 3.
The features extracted by the ResNet are then passed through a recurrent neural network. The model uses an LSTM with hidden size of 128. The output of the LSTM is processed by several fully connected layers with ReLU activations. The final output is passed through softmax layer to produce probability distribution over the possible actions. This probability distribution represents the model's prodiction of the next action an agent will take. The action space has size of 6, corresponding to set of discrete actions. The entire network is designed to be fully differentiable, allowing for end-to-end training using cross-entropy as the fosnttinn We use the following hyperparameters for training:
Hyperparameter
Purpose
Value
# Agents to Sample
The number agent scripts to sample per epoch.
# Datapoints per Agent
The number of trajectorics per agent to sample from the dataset per epoch.
# Agents
The total number of agents in the dataset.
10
# Steps
The number of steps per trajec-
50
tory in the dataset.
Environment Size
The size of the environment.
10x10 10
Image Size
The size a single observation
70x70 pixels
in trajectory.
Num Epochs
The number training epochs.
5000
27

---

Published as a conference paper at ICLR 2026
Algorithm 1 ROTE (Representing Others' Trajectories as Executables)
a(-1),; current observation or Hnvironment E, Initial set of candidate programs Acandidates (can be empty), Initial set of program prions Pritess Ensure: Predicted action de, Predicted programs Acaudidates, Predicted program posterior posterions
Require: Ohserved history hoa-1 (())))))... (Dr
Ro).....
1: procedure PREDICTACTION
01, 0z, k, Aeandidatess Pptiors)
2:
for N [Acandidates gencrations do
> Number of programs to sample
3:
Prompt L.M with N1 0t, &, and synthesize an FSM-like Python program Acundidttos - Apandidates U {Y}
4:
Porior < II 1 ho:--1000 og, tokenn-1."" tokenj)
5:
priors Priorn (pprior
end
8:
Ppriors +- normalizee(Pprm
Renormalize priors to account new hypotheses
9:
Pposteriors =
10:
for A E Acandidatess do
11:
P(A) x a, PP A) PArtor(A) prrateriors + P proteeiions U {p(A)}
b Calculate likelihood p(H A)
12:
13:
end for
14:
Poosteciors + normalizo(top-ko posterions k))
Subsample and Renormalize
15:
Predicted action de < argmaN.eA AeAanaiaao Prosterions (A) M(elor) return d,, Acsndidatess P posteriors
16:
end procedure
A.11 ROTE IMPLEMENTATION DETAILS
We will fully open-source our code, including the prompts we used for generating programs with ROTE across the various levels of structure. In Algorithm [ we show the full algorithm for ROTE and subsequently discuss the implementation details. Our approach, ROTE, constructs the program space using LLMs to synthesize executable Python programs, which serve as agent representations. These programs are structured as class with required act(self, observation) -> int method, ensuring a standard and executable format for all candidates. We intentionally avoid rigid, manually defined syntactic constraints across all domains to maintain representational flexibility, which is particularly important when modeling noisy human behaviors, and we analyze how these representations impact performance in Figure 13. Instead, we impose a soft constraint based on Solomonoff's theory of inductive inference and Occam's razor, encouraging the LLM to generate concise and efficient. programs (minimizing [A]), which empirically correlates with higher prediction accuracy. For practical upper bound program complexity, limit the LLM's output to a maximum of 2000 tokens and restrict the number of generated hypotheses to N = 30, directly limiting the size of A and thus the potential complexity of any individual program. Regarding the state complexity for programs that do not strictly adhere to the Finite State Machine (FSM) structure-whht structural conditions to accommodate inherent behavioral variability the theoretical upper bound on the number of internal states, [S], is equivalent to the size of the observation space, [O]. This is because Python is Turing-complele language, meaning a synthesized program could, in theory, generate a unique action for every possible observation, resulting in a number of states equal to the number of unique observation-action mappings, |S] =OO]. However, as you noted, this empirical realization is highly unlikely, especially given our imposed constraint the maximum program size. Finally, we provide control over the complexity via three levels of structural enforcement: "Light" " (minimal constraint), "Moderate" (providing FSM examples), and "Severe" (enforeing two-stage FSM generation process), allowing researchers to explore the trade-off between structure and flexibility based on the domain.
we permit, espocially under the "Light" and "Modcrate"
A.11.1 ROTE HYPERPARAMETER FOR CONSTRUCTION AND PARINR
Across the prediction tasks for ground-truth scripted agents and humans in Construction, and LLM agents in Partur, we used the same set of hyperparameters, indicating the generality of our method with minimal environment-specci varied across environments was the use of two-stage observation parsing. We used two-stage observation parsing for predicting scripted agent behavior Construction and LLM-agent behavior in Partur. We did not it for predicting human behavior. As mentioned in
finetuning. The only hyperparameter which
28

---

Published as a conference paper at ICLR 2026
Section A.7 all hyperparameters were fit by comparing their performance on 20% of the data, then utilizing the best performing hyperparameter from that subset, as the selected model configuration for the remaining 80% of the data.
Hyperparameter
Purpose
Value Light
Structure Enforcement
How strictly we constrain gener- ated programs to adhere to FSM structure
Rejuvenation
Whether to rejuvenation for the FSM model.
True
Max rejuvenation attempts
Maximum number of times re- sample a program during rejuve- nation.
2
Rejuvenation threshold
The minimum number of cor- rect action predictions a program must make over 20 timesteps to avoid resampling.
Max number of retries
The number of times hypoth- esis can be revised if it fails to compile.
2
Number of hypotheses
The number of hypotheses to gen- erate for the thought trace.
30
Top K
The number of most likely hy- potheses to average over.
30
Minimum hypothesis probability
The minimum probability a hy- pothesis can have.
1e-6
Maximum number of tokens
The maximum number of tokens the large language model can gen- erale.
2000
Minimum action probability
The minimum probability an ac- 1e-8 tion can have.
For our exccution speed comparisons in Figure G all models ran on a single Nvidia GPU-L40.
generating programs from smaller LLMs trying to adhere to a consistent Agent API, and that the observation space can be challenging to operate on, there several cases where the LLMs generate semantically meaningful programs to describe observed behaviors that fail to compile or predict actions given an observation. As such, we explored two different methods for dealing with erroneous programs, The first was revision, where we prompted an LLM to fix the code it generated given the full crror trace for program's 'ss prediction. We also gave it the original prompt and obscrvations. The second method was completely resampling a program given the original prompt, discarding the erroncous program completely. From preliminary tests, we found completely resampling was the more ellective stralegy given the LLMs were using. Since we paired this error correction process with methods like rejuvenation, we limited the number of times could resample revise a program to be min min(Max rejuvenation attempts, Max number of retries), shared across the rejuvenation and error corrections steps. This increased the likelihood of a good program which is executable being generated, without significantly slowing our single-step inference speed.
Handling Errors in Program Generation. Given that
A.11.2 EXAMPLES OF PROGRAMS GENERATED By ROTE
In Listings [ and 2 we show sample agent programs inferred by ROTE for the Construction and Partnr tasks, respectively. Using the same prompts and hyperparameters for both settings, our approach can ficxibly model agents as Finite State Machines when the underlying agents are following scripts (Construction, Listing D or more open-ended decision makers trying to accomplish goals such as move an item from one room to another (Parber, Listing 2).
import numpy as np
29

---

if self state == "MOVE": self state "IDLE" Transition back to IDLE after Published as a conference paper at ICLR 2026
class FSMAgent:
def (seff, num_agents: int, num_blocks: int, num_actions: int-6):
self num_agents num aue_agents
self num_blocks = num sum_blocks
self num num_actions
actions
self actions [0, 1, 2, 3, 4, 5] stay, right, left, down,
up, interact
self action_ name ["stay", "right", "left", "doun", "up", "interact"]
self
"IDLE" Initial state
12
13
def acelf, observation) >> int:
agent_ id observation ['agent_id'] agent_location observation inaevvation'aagenn delagennt__ocaatiiii 'I [agent_id] inventory observation
16
[agent_idd
17
18
if stat. -. "IDLE":
Check if there is block at the agent's location and interact with it for block_locatin if up- mp. ap..rray_soo _arall_eeualla (block_location, agent .gent_location) if inventory == -1: self "INTERACT" break
20
in observation bllockklocationee
24
25
else:
26
No block at the agent's 's location, check for possible
movements
possible_actions actions []
28
for action in self actions [:-1]: Exclude interact new new_location = self apply_actionn
29
action)
if not self is_ (new_location, observation ( vall_locations ']) not self falf.is_othee oss_ettrrageent agent (new_location, observation agent oggent_locations'] agent_id).
cnssible_actions (acten((con)))))) (action) if possible_actions
self state "XOVE"
self targetaaatttttt up random choice
gossible_actions
moving return self target_action
38
if self state "INTERACT": stafe "IDLE" Transition back to IDLE after interacting return 5 Interact action
def apply_action asel, location, action):
45
if action 1: # right
46
return [location[0]. location [1] 1]
elif action == 2: # left
return [location[0]] [0]. location [1] 1]
49
elif action
3: down
50
return [location [0] + 1, location [1]]
elif action =- 4: # up
return [location [0] - 1, location [1]]
else:
54
return location stay
55
def is wa_wall (self, location, wall locations);
for wall wall locatinn:
30

---

Published as a conference paper at ICLR 2026
if up. a
equal (wall, location): return True
60
return False
def is_other_ @ether_agent(eee
(self, (self, location, agent_ sgent_locations, agent_id):
for i, agent_los in enumerate anpent_locations if return True
agent_id and np array equal eogent_loc, location):
65
return False
Listing 1: Sample Agent Codes Inferred by ROTE for Construction prediction task
import numpy np
class FSMAgent:
def __init__ (self, num_agents: int-1, num_blocks: int-1):
self num_agents num_agents
self num blocks nun_blocks irrelevant, ignore
9
def srrse_scene_graphieee
observation);
for keys in observation I' ssssene_graphhh if keys =- 'furniture';
for room_name, furniture_list observation['
scene_graphe " items())
13
for furniture_piece in furniture_ list: pass # each furniture_ is string if keys 'objects';
16
(obbserratioonnscceeee len (observation (acciionn'cceeii d'scene_graple ' [keys]) 0: pass # no objects seen
[keys]) list
else: for object, object_holded list observation scene_graph '] [keys] items():
20
for Dbject_holdes in object_holder _olddehllerr.._ list:
pass # each object is either on or in an
object holder
22
return do whatever is most helpful here
23
24
def act act (self, observation) -> int:
observation dictionary with the following keys: tool_list: List tools available to the agent tool_description Description of hov each tool is used scene_graph: Scene graph of the environment, dictionary with keys
27
28
"furniture" which maps to dictionary with the keys room description string (i.e. keys could be Doving_room_1" "bathroom_1", etc.) that maps to list of object_id _ic string (i.e. table_21, chair_33 32, etc.) "objects" which maps to dictionary of object_ string (i.e. keys could be
plate_contatneeee container_2 2", "vase_1" etc.) to list of if object_base string (i.e "table_14", "table_ ") ssseneeegannsseeeegrrrrr.a then you not observe any objects Dictionary mapping to string of agent id (i.e. "0") maps to string describing
35
== list
37
38
what agent is doing
40
agent_id list (observationn (bbserrattooml'ggtttssttttt a'aggnt_ssaaee keys ()) [0] ccent_state observation observation''agatt state [agent_id] id]
41
tool_list - observation "aarvationnntool_lleit tool_
if 'Explore' tool list:
31

---

Published as a conference paper at ICLR 2026
tool 'Explore' target (observvatiio scene_graph '] furniture keys
)) [o]
elif 'Pick' in tool_list and 'Standing'' in agent_state:
tool = 'Pick'
targets
50
for key in observation intervaatoon"scee_gget obbbjectaa
51
if "agent_ in observation (sceneee searsseeeeeraeeeeeeeeee ggraph 'I objeects
key]:
targets append
if targets:
54
target targets [0]
55
else:
target None
elif 'Place' tool list and 'Standing' in agent_state
tool 'Place'
59
target None
for key in observation if agent_id in observation cetervattoonn'scotti I'scene ' ')
keyl:
62
target key break
63
if not target:
for key in observation scene sccneeggrahh ["raph']['furitttt for furniture_piece in observation sicene_grapl "]aaph']1 []
'funniture' '] [key]:
67
if agent_id id in observation ( graneeegraphh
furniture '] [key]:
target key
69
break
70
if not target:
[ target list [ "
keys ()) [o] else:
73
tool 'Wait' target = None
74
## D CHANGE ANYTHING BELOW HERE
77
return (tool, target, None)
Listing 2: Sample Agent Codes Inferred by ROTE for Partnr prediction task
A.11.3 EXAMPLES HIGH LEVEL TRAJECTORY SUMMARIES GENERATED ROTE
In Listings 3 and we show sample high-level trajectory summarizations from the optional two-stage obscrvation parsing step. While in the model attributes the movements of the ground truth patrolling agent as "exploring randomly," it still is able to capture some aspects of its movement, such not interacting with blocks. In ROTE the behavior of agents in Parter, but without a clear guess as to which objects the agent is trying rearrange, it can be difficult to make program which concisely narrows down the hypothesis space.
better summarize
1.
The agent s overall goal or strategy: The agent appears to exploring its environment, possibly looking for a specific block or blocks.
It is not actively engaging with the environment in goal-directed way, it does blocks a strategic manner.
to be collecting, storing, moving
2. How the agent responds to different environzental features (blocks, walls): The agent moves around the environment, avoiding walls and seemingly indifferent blocks.
32

---

Published as a conference paper at ICLR 2026
It repeatedly
left and right and up and down, indicating lack of strategy or goal-directed behavior.
3. Any patterns in movement or interaction: The agent moves in pattern that suggests exploration but does not show any indication avoiding walls blocks, indicating a lack awareness of its environment or purpose in the grid world.
The agent's behavior essentially random exploration, with apparent strategy goal-directed behavior.
Listing 3: Sample Trajectory Summary Generated by ROTE for Construction prediction task
1. The agent's overall goal or strategy: The agent main goal seems to be to rearrange objects in the environment, specifically placing them on different surfaces according to its actions. The actions are organized into sequences, each sequence aiming to move object from its initial position 2. The agent reeponds to different environmental features: The agent interacts with specific furniture and objects within the environment, responding to their availability and positions. For example, it navigates to the kitchen to interact with chair and rearrange an object
target position.
3. Any patterns objects from one place to another, often tovards the garage or kitchen, and interacts with objects like chairs and benches. It also arranges objects benches and other surfaces when carrying them.
movement or interaction: The agent tends to move
The agent's behavior pattern emerges from a sequence of actions that involve picking up and moving objects rearrange them according its strategy.
Listing 4: Sample Trajectory Summary Generated by ROTE for Portur prediction task
A.11.4 EXAMPLES OF EXPLICIT FSMs GENERATED BY ROTE IN THE "SEVERE" STRUCTURE CONDITION
In Listings 6 and 5 we show sample FSMs predicted by ROTE which describe observed behaviors in the Construction and Parnlr environments, respectively. These are produced by LLM as an intermediate step during the "Severe" structure condition, where ROTE tries to generate agent programs implementing these high-level behavioral abstractions. As indicated by Listing 6 sometimes the models will hallucinate internal states and actions which are not within an agent's capabilities (i.c. introducing "charge" state). As result, the "Severe" condition is not always beneficial for model performance, espocially when predicting the behaviors of goal-directed agents in partially observable settings (Figure 13
<< "'yyhhon class AgentFSM:
def (ieit__sself)...
5
self state 'explore'
def transition (self, state, action, info):
if state 'explore':
action 'up':
10
return "move_up's info elif action == 'dwnn' return 'move_down' info
elif action 'left':
33

---

Published as a conference paper at ICLR 2026
'move left', info elif action 'right':
16
return 'move_right" info elif action =- 'interact'; return 'interact', info else:
20
return 'stay', info elif state == mmove_up":
21
return 'stay', info elif state 'move down
return 'stay', info elif state move _eftt
25
return 'stay', info elif state == "move__ee right
return 'stay', info elif state 'interact'; return 'stay', info
29
30
def get get_action info):
if self state 'explore':
34
Randomly choose an action from the available options import random actions = ['up', 'down', 'left', 'right', 'interact '] action random choice
35
self
self transition ('explore', action, info)
39
return action
else:
action = self
self state, self transition(sell) state, action, info)
43
return action
44
Let write the code the agent's behavior, taking into account experiences provided:
48
1. The agent's overall goal strategy: The agent appears to be exploring its environment, possibly looking for specific block or blocks.
50
It is not actively engaging with the environment in a goal way, it does not seen to be collecting, storing, moving blocks in strategic manner.
52
2. How the agent responds to different environmental features (blocks, walls): The agent moves around the environment, avoiding walls and seemingly indifferent to blocks.
It repeatedly lack of
left and right and up and down, indicating
Listing Sample FSM Transition Logic Generated by ROTE for Construction prediction task ("Severe" Structure Condition)
To model the behavior of the agent in this environment, we can def infine finite state machine (FSM) with the following states and transitions:
** Statea:**
1. ** I The agent is waiting resting, poasibly exploring its identify potential taaks resources. surroundings agent is actively searching for specific objects or
2. SEARCH**. locations of interest, such as a target object to collect or a specific location to navigate to.
3. **COLLECT*:: The agent is moving tovards and collecting the target object
34

---

Published as a conference paper at ICLR 2026
4. **TRANSIT**: The agent is its way to designated drop off storage location after collecting an object.
**DROP _DROP_OFF**: * The agent is depositing the collected object at its destination.
6. **CHARGE**: If the agent is robot uses battery, it may need recharge. This state triggered when the battery level becomes critical.
10
** Transitions:**
** IDLE -> * When the agent identifies task resource collect, transitions from idle
search state. SEARCH -> COLLECT*:: When the agent locates the target object, transitions from a search state to a collect state.
13
COLLECT -> TRANSIT**: After collecting the object, the agent towards the drop-off
transitions
transit state
location
15 TRANSIT -> DROP DROP_OFF**: *FF**:
Upon reaching the drop-off location, the agent transitions to a drop-off state to deposit the object.
DROPP OFF -> IDLE**: After depositing the object, the agent returns task resource.
an idle state, possibly searching for 17 COLLECT -> CHARGE**: If the agent battery-operated and the battery level becomes too low during collection, it transitions to charge state to recharge.
TRANSIT -> CHARGE**: Similarly, if the agent needs recharge while moving the drop-off location, it transitions to the charge state.
19
*RDOP_ -> CHARGE**: If the agent needs to recharge after depositing object, it transitions to the charge state.
This FSM design allows the agent efficiently manage its activities, transitioning smoothly between states based on its observations and needs, such as searching for resources, collecting them, moving drop-off location, and recharging when necessary.
Listing 6: Sample FSM Transition Logic Generated by ROTE for Partar prediction task ("Severe" Structure Condition)
35


Reviews:
[{"review_id": "QT8vHr8uBy", "reviewer": "Reviewer_5dXd", "summary": "This paper engages with the problem of social interaction modeling, proposing to model agents' predictable patterns as behavioral programs. The authors introduce ROTE, an algorithm that uses LLMs to synthesize behavioral programs and probabilistic inference for reasoning about uncertainty. By evaluating on gridworld tasks and embodied simulators, ROTE predicts human and AI behaviors well and outperforms baselines.", "questions": "See \"Weaknesses\".", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- This paper represents an interesting and novel idea. Using program synthesis with SMC inference for modeling agentic behavior is worth studying.\n- This paper shows good empirical results: ROTE outperforms baseline conditions. It also demonstrates superior generalization accuracy.\n- This paper has a reasonable selection of environment. It goes beyond simple 2D gridworld (Construction) with the inclusion of an embodied environment (Partnr).\n- This paper also condutcs human studies, allowing the reader to have a clearer sense of the performance of ROTE. That fact that ROTE achieves human-level performance while the baselines do not here is noteworthy.\n- The paper is generally well written.", "weaknesses": "- The paper has Naive LLM (NLLM) as a baseline, which seems to be the strongest baseline. But why not also use Chain-of-Thought (few or zero shot) as a baseline? How would that compare to ROTE? (Or could you argue that CoT is not appropriate here?) I consider this to be a major weakness of the paper, and would raise my score if this issue is addressed.\n- Using programs to represent behavioral patterns can be a good idea, but it might be too rigid or inflexible in many cases. I would appreciate that the authors discuss this aspect more. For example, the first limitation at the end is related to this. But I think more discussions would be helpful. For example, as things currently stand, what kinds of real-world domains or settings do the authors expect ROTE to mostly work? For domains where ROTE may not work, would it be because the programs are not expressive enough (e.g., wrt high-dimentional inputs) or programs as a presentation is not suitable?", "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": "j5sUnjZG7S", "reviewer": "Reviewer_vNqa", "summary": "This paper introduces a novel approach to modeling others’ minds as code. It addresses the challenge of predicting agents’ actions in scenarios where behavior is not guided by explicit goals or beliefs, inspired by cognitive science studies on mindless behavior. The proposed ROTE algorithm integrates LLM-generated code with Bayesian inference to identify programs that best explain an agent’s observed behavior and to predict future actions. Experiments in two environments show substantial improvements over strong baselines.", "questions": "- How are different candidate programs generated, and how do you ensure their diversity? Is this achieved through a multi-pass or single-pass generation process?\n- Could you evaluate stronger LLMs to better illustrate the necessity of these action prediction tasks and how current models fall short?\n- How do the baselines (NLLM and AutoToM) with GPT-4o as their backend perform on the action prediction tasks compared to ROTE?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "- Motivated by findings in cognitive science, this work addresses a gap in machine mind modeling with potentially broad implications. \n\n- Experiments in two distinct environments show that ROTE consistently outperforms BC, AutoToM, and a naive LLM baseline in both single-step and multi-step prediction tasks. The method also demonstrates strong computational efficiency, particularly in long-horizon tasks.", "weaknesses": "- The baselines and ROTE are evaluated with 8B and 16B, instruct and coder models. I wonder if more capable LLMs (such as GPT-4o) could directly solve the action prediction tasks as NLLM, without additional modeling approaches. This would provide a more realistic assessment of the practical need for such a modeling approach.\n\n- The proposed algorithm would be more significant if the generated programs could also handle action prediction tasks that require modeling agents’ beliefs, such as the Forward Action task in BigToM.\n\n- The description of the generalization experiments lacks some details. It would improve reproducibility to specify the environments used before and after the change. How are the textual descriptions different between the two environments?", "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": "OhCvUPSu0H", "reviewer": "Reviewer_P8y6", "summary": "The paper presents ROTE, a novel method that models others' minds as code. It leverages LLMs to synthesize behavioral programs from sparse observations and uses probabilistic inference to predict actions. Experiments show ROTE outperforms baselines and achieves human-level accuracy in predicting both human and AI behavior.", "questions": "See Weakness.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1. The paper is generally well-written and structured. \n\n2. The method shows performance gains over the selected baselines, and in one task, it is reported to perform at a level comparable to human predictors.", "weaknesses": "1. There is a lack of discussion regarding [1], which is a representative work that also utilizes LLMs to generate open-ended code for observed behaviors. While I can appreciate the potential differences, the complete absence of any discussion of this work is surprising.\n\n2. The claimed contribution of a \"novel algorithm\" does not seem to hold, in my opinion (at least pending further clarification). I find the architecture to be strikingly similar to that of [2], which might even be more sample-efficient. While some differences may exist in the format of the hypotheses or the use of weights, I consider these distinctions to be trivial. The complete omission of this highly relevant work is unacceptable.\n\n3. Given that the paper positions itself in the field of Program Induction, it should be compared with more related work from this area. My intuition is that some of these works, such as [3], could be directly applied to the proposed task (with prompt modifications, of course) and would likely achieve comparable results.\n\nOverall, I see too many shadows of prior work in this paper, along with potential baselines that should have been discussed but were omitted. While I appreciate the paper's motivation and writing, I believe it is not yet ready for acceptance.\n\n[1] Castro, Pablo Samuel, et al. \"Discovering symbolic cognitive models from human and animal behavior.\" bioRxiv (2025): 2025-02.\n\n[2] Zhou, Yangqiaoyu, et al. \"Hypothesis generation with large language models.\" arXiv preprint arXiv:2404.04326 (2024).\n\n[3] Qiu, Linlu, et al. \"Phenomenal yet puzzling: Testing inductive reasoning capabilities of language models with hypothesis refinement.\" arXiv preprint arXiv:2310.08559 (2023).", "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": "zuBhgb6RZq", "reviewer": "Reviewer_G1C7", "summary": "This paper proposes ROTE, which is an algorithm that leverage LLMs as code synthesis tools to predict others’ actions. It prompt LLMs to generate computer programs explaining observed behavioral traces, then perform Bayesian inference to reason about which programs are most likely. This gives a dynamic representation that can be analyzed, modified, and composed across agents and environments. The experiments show that ROTE can predicts human and AI behaviors from sparse observations. And ROTE outperform competitive baselines including behavior cloning and LLM-based methods.", "questions": "1. It lacks a clear operational definition of \"scripted\" behavior, leaving the boundary between scripted and non-scripted behaviors ambiguous. This conceptual vagueness—such as whether goal-directed planning qualifies as scripted—undermines the theoretical grounding of the proposed approach. Additionally, while ROTE demonstrates strong predictive accuracy, the semantic validity and interpretability of the generated programs remain underexplored. A more systematic analysis is needed to assess whether these programs meaningfully correspond to plausible behavioral logic or merely capture superficial statistical patterns.\n2. The construction of the program space $\\Lambda$ — including its syntactic constraints and upper bounds on state complexity — remains insufficiently specified. A more detailed description of these structural parameters would significantly enhance the reproducibility and rigorous evaluation of the proposed method. \n3. The core modeling assumption of combining deterministic programs with a noise model appears overly simplistic. Given the inherently stochastic and context-dependent nature of genuine human behavior, merely approximating behavioral uncertainty through a noise model may be insufficient to capture its full complexity, potentially limiting the model's realism and generalizability.\n4. What is the requirement for different levels of structural constraints?\n5. While multi-step prediction is efficient, the computational overhead during the initial program synthesis phase has not been compared against baseline methods. Could the authors provides more comparative measurements of this initial synthesis stage?\n6. The paper does not analyze how LLM scale affects performance. While multiple LLMs are used, their varying sizes' impact on program quality and inference speed remains unexplored.\n7. The TPP methods, such as [1, 2]，with the constraint of human-readable logic ruels, can be used to predict both future action time and type. Compared with these methods, what are the advantages of ROTE? Is it possible to add extra experiments to compare?\n\n[1] Neuro-Symbolic Temporal Point Processes. ICML 2024\n\n[2] Discovering Intrinsic Spatial-Temporal Logic Rules to Explain Human Actions. NeurIPS", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The Related Work section is comprehensive and well-organized. It effectively situates the current work within the broader research landscape by thoroughly reviewing and analyzing three key areas: action prediction, the use of LLMs for behavior modeling, and program induction. The discussion clearly outlines the developments and current state of these fields, providing a solid foundation for positioning the paper's contributions.\n2. The proposed ROTE algorithm presents a novel approach by synergistically combining LLMs with probabilistic inference to translate observed agent behaviors into executable code programs. This represents a meaningful intermediate path between two conventional paradigms: computationally intensive inverse planning over beliefs and goals, and data-inefficient behavior cloning. By conceptualizing routines as executable \"scripts\" or \"programs,\" ROTE offers a fresh perspective on modeling structured, yet flexible, agent behavior.\n3. A comprehensive empirical evaluation is provided, systematically assessing performance across diverse scenarios—from scripted agents in gridworlds to complex human behaviors in embodied settings. Notably, ROTE demonstrates compelling zero-shot generalization capabilities across unseen environments, a critical feature for real-world applicability and a key advantage over more brittle baselines.", "weaknesses": "1. The \"Related Work\" section omits discussion of one relevant research thread: the use of Temporal Point Processes (TPPs) for modeling human behavior with the application of first-order logic rules to constrain behavior prediction. These areas are closely related to the methodological context of this paper.\n2. The central claim of modeling behavior as \"programs\" lacks sufficient discussion of their connection to underlying cognitive processes. A key theoretical concern is whether finite-state machines can fully capture the richness of human behavior, particularly for goal-directed or socially complex scenarios. This fundamental limitation warrants deeper theoretical grounding, as it directly challenges the generalizability of the proposed approach.\n3. The experimental evaluation has several limitations. While the paper highlights ROTE's long-term prediction efficiency, it lacks comprehensive discussion of computational costs—particularly the potentially significant overhead during initial program synthesis, which could impact real-time applicability.", "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)