CubeBench: Diagnosing Interactive, Long-Horizon Physical Intelligence under Partial Observations
Authors: Huan-ang Gao
Zikang Zhang
Tianwei Luo
Kaisen Yang
Xinzhe Juan
Jiahao Qiu
Tianxing Chen
Bingxiang He
Hao Zhao
Hao Zhou
Shilong Liu
Mengdi Wang
Venue: ICLR 2026 Poster (2026)
Keywords: Agent
Benchmark
Spatial Reasoning
Long Horizon
Tool Calling
Primary area: datasets and benchmarks

Abstract: Large Language Model (LLM) agents, while proficient in the digital realm, face a significant gap in physical-world deployment due to the challenge of forming and maintaining a robust spatial mental model. We identify three core cognitive challenges hindering this transition: spatial reasoning, long-horizon state tracking via mental simulation, and active exploration under partial observation. To isolate and evaluate these faculties, we introduce \textbf{CubeBench}, a novel generative benchmark centered on the Rubik's Cube. CubeBench uses a three-tiered diagnostic framework that progressively assesses agent capabilities, from foundational state tracking with full symbolic information to active exploration with only partial visual data. Our experiments on leading LLMs reveal critical limitations, including a uniform 0.00\% pass rate on all long-horizon tasks, exposing a fundamental failure in long-term planning. We also propose a diagnostic framework to isolate these cognitive bottlenecks by providing external solver tools. By analyzing the failure modes, we provide key insights to guide the development of more physically-grounded intelligent agents.

Published as a conference paper at ICLR 2026
CUBEBENCH: DIAGNOSING INTERACTIVE, LONG-HORIZON SPATIAL REASONING UNDER PARTIAL OBSERVATIONS
Huan-ang Gao Zikang Zhang" Tianwei Luo' Kaisen Yang! Xinzhe Juan' Jiahao Qiu Tianxing Chen Bingxiang He' Hao Zhao'
Hao Zhou' Shilong Liu Mengdi Wang"
'THU 'Princeton SUTU & UMich *HKU
{gha24, mhang-zk21]ene 1s. ts sinnhuua..... edu.cr. 1918264, mengdiw/@princeetee
ABSTRACT
Large Language Model (LLM) agents, while proficient in the digital realm, face a significant gap in physical-wordd deployment due to the challenge of forming and maintaining robust spatial mental model. We identify three cognitive challenges hindering this transition: spatial reasoning, long-horizon state tracking via mental simulation, and active exploration under partial observation. To isolate and evaluate these faculties, we introduce CubeBench, novel generative bench- mark centered the Rubik's Cube. CubeBench uses three-tiered diagnostic framework that progressively assesses agent capabilities, from foundational state tracking with full symbolic information to active exploration with only partial vi- sual data. Our experiments on leading LLMs reveal critical limitations, including a uniform 0.00% pass rate on long-horizon tasks, exposing a fundamental failure in long-term planning. We also propose diagnostic framework to isolate these cognitive bottlenecks by providing external solver tools. By analyzing the failure modes, provide key insights to guide the development of more physically- grounded intelligent agents. Webpage: https:: cww.bencccbbbbccccccmmm c7w tech/
T
BiB B GG 00o
H
0
Sap lostoo
Kimin rlacebahh duating
Dead 720 72B--inttort
G77400
Incon (750)
desbaoneed 1-6-isia
Dospltek- V1.
Desphtok amis-tton
Class Sunset
V3.
Clumtin 2.5
Kimi 822 cecee c9ee
Gook-4
Oroet
Tier 2: Full Visual State
Tier 3: Partial Visual State
10%
KZZ
Clande Somer drotaauun stely waia Or BeooVV 20 Auaren
CRmmin IT
GEA- By
deubhan cod de Thion
Cloade Somet
disting tV
Chemas 4-7770 1-277I
Oumini commnn 1/500
Quend &-V Anarer
Gemini
Kines
An overview of the performance leading LLMs on the CubcBench benchmark, broken down by its three diagnostic tiers. Tier (Full Symbolic State) tests foundational state tracking using complete symbolic information, where the best average pass rate is only 37.5%. Tier 2 (Full Visual State) challenges visual and spatial reasoning by requiring agents to interpret 2D unfolded map, and Tier 3 (Partial Visual State) evaluates active exploration from partial views. Across all tiers, GPT-5 emerges the top-performing model, though the results highlight a significant performance gap between symbolic and visual reasoning tasks.
Figure 1:
"Equal contribution. Corresponning author.

---

Published as a conference paper at ICLR 2026
INTRODUCTION
Agents powered by Large Language Models (LLMs) have demonstrated remarkable potential within the digital realm (Gao et al. 2025 Fang et al.) 2025). Their proficiency in using tools to navigate websites or write code heralds the dawn of general-purpose Al assistants (Luo et al. 2025 Ma al,) 2025). However, far grander ambition is to deploy these agents into the physical world. This vision confronts a significant gap: an agent's success on one-dimensional, symbolic tasks does not readily translate to effective mecision-making in three-dimensional, dynamic environments. The physical world demands more than language comprehension; it requires the ability to form and maintain a robust spatial mental model (Johnson-Laird) 1980 1983).
This gap manifests as critical deficiencies in the core cognitive abilities of current agents, which show in Fig. 2
Hy Aid
Dariial Dbsurrate
We identify three such challenges. The first is
Fickel
Spatial Reasoning: physical tasks are inherently three- dimensional, requiring an agent to comprehend an ob- ject's geometry, the relative positions of its components, and the precise consequences of actions in 3D space. The second is Long-Horizon State Tracking through Mental Simulation. Unlike digital tasks where state is often ex- ternally visible, physical interaction requires an agent to internally maintain and update its world model over long action sequence planning. where even minor errors can accumulate and lead to catastrophic failure. Finally, and most crucially, is the ability for Exploration and Reason- ing under Partial Observation. The real world rarely provides complete information, so an agent must actively explore its environment to construct a complete mental model from limited views.
Like Hikp Toaking
Figure Visualization of the three core cognitive challenges required for spatial reasoning.
To rigorously measure and advance these core capabilities. isolated from the complexities of phys- ical perception, we introduce CubeBench, novel, generative benchmark centered on the Rubik's 's Cube. We posit that the cube serves as an ideal laboratory; its deterministic rules and vast state space allow us to conduct controlled experiments that isolate the three core cognitive faculties. To achieve this, CubeBench features a three-tiered diagnostic framework to progressively probe an agent's capabilities: Tier I tests foundational state tracking with complete symbolic information; Tier challenges visual and spatial reasoning by requiring the creation of a 3D model from a 2D unfolded map; and Tier 3 evaluates active exploration using only partial visual information.
Our comprehensive evaluation on CubeBench reveals a staggering performance gap current LLMs. The results are stark: across all models, the pass rate any long-horizon task is uniform 0.00, exposing a critical failure in long-term planning and state tracking. Even on short- horizon symbolic tasks, the pop-performing LLM,, GPT-5 [. achieves a success rate of just 0.75, merely matching the performance of a traditional Policy Gradient agent and highlighting the diffi- culty of even basic structured reasoning. Furthermore, that while external feedback can provide a local guide on simpler problems, it is insufficient to over- come these core planning deficits. By equipping agents with solver tools, our diagnostic framework successfully pinpoints these failures, isolating morizon planning as a primary bottleneck and the inability to reason from partial observations as more fundamental challenge.
experiments with dense rewards show
In summary, the primary contributions of this paper are:
We identify and formalize three core cognitive challenges that impede the deployment of LLM agents into the physical world: spatial reasoning, long-ho morgoooizon state tracking, and exploration under partial observation.
We propose CubeBench, novel, generative benchmark for the controlled evaluation of these cognitive challenges, decoupled from the complexities of visual perception.
Through extensive experiments on leading LLMs, we reveal their current limitations in forming and utilizing spatial mental models, offering key insights for future development.
Accessed via OpenRouter (II: opena //ptt with unspecified reasoning effort.
2

---

Published as a conference paper at ICLR 2026
A comparison of agentic benchmarks. Besides the three core cognitive challenges. we also evaluate key task characteristics: Verifiable Outcome Reward, which assesses if the environment operates on fixed, predictable principles rather than subjective or stochastic outcomes such as LLM- as-a-judge; Non-static environment, which measures if the state of the environment changes with different agent actions; and whether the task is Humanly Challenging, requiring deliberate explo- ration for acquiring problem-solving skills beyond simple perception or motor control.
Table 1:
Core Cognitive Challenges
Envtrommental & Tack Properties
Benehmark Type
3D Reasoning
Long-Hori. ST. Track
Partial Obs
Veriliable Outcume Rwd. Non-static Eiv. Humanly Challenging
Soarch
Code
GUT
Embodied Simmalators
Gyms
ARC-AGL-3
MINDCUBE
CubeHeneh (Ours)
baing explicilyy dosgned to the capabiliy.
being partialy tosel the bendimukk bendhnukk not pimutly focming this capubllity
We demonstrate through intervention suedies-seciffiallly solver integration and learning from experience-thar the identified limitations of hase LLMS can be significantly miti- gated. pointing toward promising avenues for building more capable agents.
2 RELATED WORKS
Self-evolving Agents. The paradigm of Al is shifting from static, pre-trained models to dynamic, self-evolving agents (Gao et al., 2025 Fang et al. (025) capable of continual learning and adap- tation from experience (Wang et al.] 2024a bj Luo et al.. 2025; /hhang et al. 2025b; Hu et al.] 2024a 2025: Liang et al.) [ Ma et al., 2025). Unlike foundational agents with fixed capa-
bilities, self-cvolving agents can autonomously modify their own components including memory
(hhng et al.]
2024a Zhou et al.
2024
Liang et al.] 2024bb Xu et al. 2025b Zhao al. 2024a
Chhikara et al. 2025 Guan et al.
2024
Yu et al. 2025). tools (Qiu et al. [025 Haque et al. 2025
Zheng al. |025|
Zhao et al. 2024b
Qu et al. 2025
Wang et. 2025) and architecture (Zhuang
et al. 2025 Zhang et al. [202c]] Sapkota et al.
2025
in response to environmental interaction.
As these agents evolve to tackle the physical world, a fundamental shift in their evaluation is re-
quired -moving beyond traditional static assessments to benchmarks that can rigorously measure the acquisition and application of spatial intelligence.
Benchmarks for Self-evolving Agents. Existing benchmarks (Chan et al. 2024 Chen et al. 2024b
Wei al., 2025 Levy et al. 2024, Wu et al. 2025 Mialon et al. 2023 Liu et al., 2023] Chen al,, 2024b). however, are not designed for these dynamics. As shown Table different categories of benchmarks test these cognitive skills to varying degrees, but none
2025a Zhu et al. 2025) Hu et al.
provides a focused, isolated evaluation. Digital environments for Search and GUI interaction (Xie)
ct al.
2024| Zhang et al., 2025a| Levy et al. 2024, Wu et al., 2025 Zhou et al. 2023 Deng et a Mialon al., 2023: Wei et al.] [2025] Phan et al. (2255) for instance, are primarily 2D and
2023
feature explicit states, thus not addressing 3D spatial reasoning. While Code and Gym environments
(Hu et al.
2024b Timenez et al. 2023 Chan al.
2024 Chen al. 2025b) Aleithan et al. 2024
Yang et al. 2024 Xu et al., 2024; Su et al. 2025 Tassa et al.) 2018 Yu et al. 2020 Rajeswaran
al.
2017] require long-horizon state tracking, they do not involve the complex 3D geometric
understanding that is crucial for physical-worle tasks. Embodied simulators (Gao et al. 2024 Yang
al. 20256
al. 2024 Savva et al. 2019b Shridhar et al.) 2022T] Kolve al. 2017) do engage
all three faculties but inherently couple them with complex visual perception, making it difficult to
isolate cognitive failures. While recent work like MindCube (Liu et al.) (002)) evaluates reasoning
on static 3D scenes, our work introduces the challenge of updating spatial model through long- horizon, state-altering interaction.
In this work, we develop CubeBench, which is specifically designed to fill this gap by decoupling perception from reasoning. Its deterministic, rule-based nature makes it an ideal suite for studying an agent's evolution; when agent fails, the cause can be precisely attributed to failure in its internal spatial model or its long-horizon planning, as shown in Sec. 4.3 Furthermore, CubeBench's 's generative nature allows for the creation of virtually infinite curriculum of tasks with fne-grained difficulty, enabling the rigorous evaluation of an agent's 's ability to learn and adapt over time- a cornerstone of assessing true self-evolution (Gao al. 2025
3

---

Published as a conference paper at ICLR 2026
Tier
Tier
Tier
Face View
Vertex
GEGOWOOD EHBERARRH EVYNNERY WWW.MMKK
State
Action Space
make
make
apply view
Pransformation
(up)
(4 (4Araa
DCTVRRO REW DELY DUT MEY
Transformed State
600000
Full Symbolic
Full Visual
Parsal Visual
Figure 3: Illustration on the three-tiered task of CubeBench. Tier (Full Symbolic State) pro- vides the agent with complete state information in string format, which makes the problem fully observable MDP. Tier 2 (Full Visual State) presents the full state as a 2D unfolded map, which chal- lenges the agent's visual thinking- Tier (Partial Visual State) provides only partial view of the cube (Face view or Vertex view), which requires the agent to explore the environment to gather the full state information.
THE CUBEBENCH BENCHMARK
3.1 TASK DEFINITION
We formalize the Rubik's Cube challenge as a Partially Observable Markov Decision Process (POMDP), providing structured framework analyze agent behavior. A POMDP defined by a tuple (S, A, T, Rt St O), where function, R is the reward function, 52 is a this context, the agent's 's goal is to learn policy I (alo) that selects an action E A given an obser- vation o to maximize the expected cumulative reward. We now define each of these components within the CubeBench environment.
a set of states, A is a set of actions, T is the state transition
observations, and O the observation function. In
3.1.1 STATE SPACE
The state space S encompasses all possible configurations of the 3x3x3 Rubik's Cube. The internal state of the cube, s e S. is deterministically represented by data structure that tracks the color of the 54 individual facelets (stickers). This symbolic representation is unambiguous and allows for perfect state tracking within the simulation. The Rubik's Cube is a classic example of a system governed by the principles of group theory. Each move corresponds to permutation of the cube's facelets, and the set of all possible move sequences forms mathematical group. This deterministic, non-stochastic nature makes it an ideal environment for isolating an agent's 's reasoning and planning capabilities from the complexities of physical uncertainty. The state space is vast, containing over 43 quintillion (4.3 x 19 unique configurations, yet it is finite and structured. This combination of immense scale and deterministic rules makes it compelling microcosm for studying autonomous problem-solving tasks that too large for naive search but perfectly predictable.
3.1.2 OBSERVATION SPACE
The observation space Ω is defined by the observation function O(s), which maps the true internal state s to an observation that is presented to the agent. As shown Fig. 3] CubeBench features three-tiered observation space, where each tier presents the state information in different modality, posing distinct perceptual challenges.
Tier 1: Full Symbolic State. The observation is 54-character string that symbolically represents the complete state of the cube. Each character corresponds to the color of a single facelet (e.g., 'W' for White, 'R' for Red, "B' for Blue, *0' for Orange, 'G' for Green, ' for Yellow). In this tier, the observation function provides the full state information as a 54-charrcter structed string, making the problem fully observable MDP.
4

---

Published as a conference paper at ICLR 2026
Tier 2: Full Visual State. The observation is single image depicting the cube's complete 2D unfolded map, which visually presents all 54 facelets in a planar layout. This tier specifically chal- lenges agent's visual reasoning capabilities, requiring it mentally fold the 2D layout into coherent 3D spatial model to understand the adjacency of faces that are not contiguous the planar representation.
Tier 3: Partial Visual State. The observation a single image partial view of the cube. This can be either an image of single face (face view) or image from corner's perspective showing three adjacent faces (vertex view). In this tier, the observation function provides incomplete state information, thus formulating the task true POMDP.
3.1.3 ACTION SPACE
The action space consists of the set of discrete, deterministic commands an agent can execute to interact with the environment.
The primary action for rotating the cube, which implements the environ- ment's transition function T(s, a). A make.move command accepts one of 12 standard Singmaster notation inputs corresponding to a 90-degree rotation of face: F (Front), B (Back), L (Left), (Right), U (Up), D (Down), and their counter-clockwine prime versions (F', B', etc.).
State Transition Actions:
IneevatiionAAterinn Actions: An action exclusive to Tier that allows the agent to change its observational viewpoint (i.e., up, down, left, right) without altering the cube's 's underlying state s. This is the primary mechanism for exploration the partially observable setting.
3.1.4 REWARD FUNCTION
The agent's objective is to reach the solved state. We define two types of reward signals within CubeBench to facilitate and evaluate this process.
Sparse Terminal Reward: The primary success metric is a sparse, binary reward. The agent re- ceives reward of R 1 upon entering the terminal solved state (i.e., all stickers on six faces are matched), and = 0 for all other state transitions. The agent's goal is to find policy that maximizes the probability of achieving this terminal reward within the given constraints.
Dense Progressive Reward: To potentially guide the agent's search process, we also implement an optional dense reward mechanism. Unlike value function, dense rewards calculated as the change in a given metric before and after a state transition action. Specifically, the reward R2 for taking state transition action a in state St to reach state 8141 metric function (s)):
defined as the difference in
R2 ((++)1) ((st)
We implemented and tested three different metric functions (d) explore how the conceptual gran- ularity of the feedback affects agent performance. (1) Sticker Metric (dsticker): This function quantifies the total number of individual facelets (stickers) that are in their correct home positions. The score @sticker (s) ranges from 9 for highly scrambled cube to 54 for the solved state. This provides a fine-grained, low-level signal of progress.
(2) Face Metric (&en))): This function counts the number of fully solved faces, where all 9 stickers on face are correct. It provides a high-level, more conceptually grounded signal that sparser than the sticker metric. (3) Heuristic Metric (Cheuristic): This function uses an algorithmic heuristic from common solving method to estimate the distance to the goal state. is designed to provide a more informed, albeit abstract, numerical signal, which we explain in detail in Sec. ! As default setting, also include no.reward condition where R, = O for all transitions.
3.2 TASK EVALUATION AND GENERATION
Agent Interaction Protocol. The agent's interaction with the environment follows the ReAct paradigm (ao et al.) 20022). structured into sequence of decision-making steps. As shown in Fig. we define a single step as a complete Thought-Code-Obseree each step, the agent first generates its reasoning (Thought), then writes and executes code to interact with the environment (Code), and finally receives the output of that code as feedback (Observation) for its next cycle. Each experimental run subject to maximum of 20 steps
block. Within
5

---

Published as a conference paper at ICLR 2026
and timeout of 30 minutes ensure fair comparison. Note that in each step, the agent could write
code to make more than one move.
Evaluation Metrics. Our primary metries designed to measure both success and effort. The Pass Rate is the fraction of test cases successfully solved within the execution constraints, serving as the primary measure of an agent's capability. To quantify search effort, we use the Number of make_move calls (#MM) as a proxy. We report this metric aggregated in three ways: the average over all normally terminated runs, the average over only successful runs, and the maximum count observed across all normally terminated runs.
Task Generation and Difficulty Scaling. We define task difficulty based on the optimal number of moves required to solve a given cube configuration, a metric we refer to as the state's depth. A state's depth serves as a robust proxy for its complexity; solving high-depth states is infeasible through random exploration and necessitates coherent strategy. To generate (see Appendix K). For target depth d, we generate scrambled states and confirm their optimality by verifying that a solution of length d exists, but solution of length d can be found. This guarantees the true depth is precisely d. The detail of this process is described in the appendix. To analyze agent performance across varying complexities, we group these cases into distinct categories: Short-Hlorizon tasks, comprising states with depths of 1, 2, 3, and 4, and Long-Horizon tasks, which include the more challenging depths of 8, 12, 16, and 20. The configuration of the generated test split is described in detail in Sec
Figure 4: Illustration on the interaction protocol.
test cases, employ provably optimal solver
DIAGNOSING LLM AGENT CAPABILITIES ON CUBEBENCH
In this section, we introduce our systematic framework for evaluating Large Language Model (LLM) agents on the CubeBench benchmark. As shown in Fig. 5 the evaluation process is designed as three-part diagnostic, structured around three central research questions that aim to progressively uncover the cognitive strengths and weaknesses of current agents:
Questions
Q1: What are the baseline capabilities and limitations of current LLM agents when trying to solve the typical cube problem in unaided setting?
Q2: Can the introduction of dense reward signals effectively guide an agent's 's context- based reasoning process and enhance its performance on these complex spatial tasks?
Q3: How can we design diagnostic evaluation isolate the impact of each core cognitive challenge, thereby identifying the primary bottlenecks for agent failure-is it high-level planning, state reconstruction from partial perception, or spatial reasoning?
4.1 EXPERIMENT 1: BASIC AGENT WITH NO AID
Experimental Setup. To answer our first research question, we establish the baseline capabilities of unaided LLMss For this experiment, we utilize the Basic Agent configuration. This agent is provided with only the fundamental interaction tools: make_move, get_observate ion, and, It must solve the task from first principles, relying entirely on its internal faculties for planning and reasoning. We evaluated this agent across all four observation modalities (Full Symbolic ic, Full Visual, Face view, and Partial Visual) on both short- and long-horizon tasks. The results are presented in Table
for Tier 3 tasks,
Key Observations. (1) All models exhibit 0.00 pass rate long- horizon tasks across all input modalities. (2) For symbolic string input; performance all visual inputs is near zero for most models. (3) A clear
tasks, non-zero pass rates are achieved almost exclusively with the

---

Published as a conference paper at ICLR 2026
Bunic Cubudgrat
sake
Solve the uskk princioles Rely eniraly on Internal facultiis
get obsecration
Experiment
sppky, view wwwp_/traeeoooaaiioooo tranefoomationn Hee hinn:
CuhsAgrai with Remarils
Fasz
reward
Clandy whecher and what sind of heurisnc Sinnals con ald ia is acuec proceas.
Experiment
Sticke
Hannetie
Bask Agent
Stundard
Idtak-Subeer
Cubckgent with Tools
Agenl
Agrni
Degrose whether failmrs stem Dee planning, stats Isanstracian. or date transfermatian
Expertment 3:
Experimtent
Figure 5: Visualization of our three- paree-part diagnostic framework for systematically evaluating LLM agents. To answer Q1, we test a basic agent with only fundamental interaction tools to establish its baseline capabilities from first principles. For Q2, we augment the agent with various dense reward signals to determine if external feedback can effectively guide its search process. Finally, to address Q3, we deploy agents with different levels of tool support to diagnose whether failures originate from high-level planning, state reconstruction, or procedural data transformation.
Baseline performance across modalities and horizons on CubeBench. Top row: metric groups (Pass rate, #MM, where #MM is the average number of make_move calls); second row: observation modalities; third row: task horizons (Short = S, depths 1-4; Long = I., depths 8, 12, 16, 20). Tier 3 denotes the hardest split, evaluated under two projections: Face View and Vertex View. Blue shading denotes open-source models, and pink denotes proprietary models. For each metric column, we shade the top-3 entries (red 1st, orange 2nd, yellow 3rd). We also train an MLP with policy gradient on the Full Symbo l setting; details are in Sec. H does not support visual inputs.
Table 2:
Model
Pass cale
AMM
Pull Symbolic
Full Visual
Face stew
Vente view
Pull Symbelic
Full Visual
Fuce view
Vanes view
Model
5
8
1.
8
GPPT3
0:75
0.00
00300
0.00
0:00
0.08 0.00)
85960166
N07.42
37GAT
161.55 189800
877509 5874JA5
MLP MLP (Polay Grddeen
0.75
0.00
5:17
400 D0
Aye oss 1200
0.20
0.00
B15585
197923.89
Grok
0.30
0.00
00.05
0.00
0.00
0.00
0.00
0.00
3.75
9.45
3.35
60.00
3.45
3.25
42.00
9.75
Kimi K2 12024 99 05)
0.15
0.00
27440 30
1297.00
Gemim 255 Pro
0.10
0.00
(8:05
0.00
0.08
0.00
0.00
0.00
150
114.45
36.15
36.22
7.60
8:25
27.35
25.08
DerpSentc- (1025 09-28)
0.th
0:00
28143355
37819.20
Claude
0.00
0.00
69.10
27.55
23.20
25.10
19.30
Qwea3
25.20
DeepSees:
33.80
doubbo seed vision
12:75
InterVVL: (788))
simi-st-abb- thinking
5276.15
0.18
0.00
0.00
0.00
0.05
0.00
08300
$3.90
50.40
59,00
115.35
GLM 4.5v
0,00
0.00
0.00
36.25
31.75
$1.70
58.31
101.70
Gemma
0,00
0.00 0.00
22.60
30.30
10
19.55
20.30
16.10
OSS- 168--
14.08
10.94
performance hierarchy is evident, with GPT-5's 0.75 pass rate on the symbolic task significantly ex- ceeding all other models. Policy Gradient agent matches GPT-5's performance, outperforming most LLMs in this setting. (4) On the Full Symbolie c task, a subset of models engage in com- putationally intensive search, indicated by average #MM counts several orders of magnitude higher than other models.
Insights. (1) The universal failure on long-horizon tasks is direct evidence of a fundamental deficit in Long- Horizon State Tracking through Mental Simulation. A related case study is presented in Sec. 2 (2) The sharp performance decline from symbolic to visual inputs indicates that Visual Thinking is a primary limiting factor for these agents. (3) While symbolic inputs enable search- based strategies, they are often computationally expensive. A notable phenomenon emerges in these tasks: agents exhibit a diversity of problem-solving strategies. Lower #MM values typically corre- spond to directly reasoning through the sequence of moves logically, whereas higher 4MM values are indicative of search-based strategies. The choice of searching algorithm substantially impacts pass rates. More capable agents, such as GPT-5, tend to systematically search using algorithms like beam search and iterative deepening depth-first search (IDDFS) with skills like backtracking, shown in
7

---

Published as a conference paper at ICLR 2026
Table 3: Pass rates of different agent types across modalities and horizons on CubeBench. Met- rics include Pass rate (higher is better). Modalities: Full Symbolic, Full Visual, Face View, Vertex View. Tier denotes the hardest split and is evaluated under two projections: Face View and Vertex View. Horizons: Short (S) and Long (L).
Full Symbolic
Full Visual
Face view
Vertex view
Model
Reward Type
S
I.
S
S
I.
I.
reward
0.75
0.00
0.20
0.00
0.40
0.00
0.05
0.00
face
0.85
0.00
0.55
0.00
0.50
0.00
0.40
0.00
GPT-5
sticker
0.65
0.55
0.00
0.50
heuristic
0.50
0.00
0.45
0.00
0.65
0.00
0.30
0.00
reward
0.10
0.00
0.05
0.00
0.05
0.00
0.00
0.00
face
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
Gemini 2.5 Pro
sticker
0.10
0,00
0.00
0.00
0.05
0.00
0,00
0.00
heuristic
0.05
0.00
0.10
0.00
0.00
0.00
reward
0.05
0.00
0.00
0.00
0.00
0.00
0.00
0.00
face
0.10
0.00
0.10
0.00
0.05
0.00
0.00
0.00
Claude Somnet
sticker
0,25
0.00
0.15
0.00
0.00
0.00
0.05
0.00
heuristic
0.20
0.05
0.00 0.10
Sec. L and L. In contrast, less capable agents often devolve into largely unguided enumeration (shown in 3). However, even models such as GPT-5 struggle to perform effective pruning; their capabilities remain insufficient to curb the rapid growth in computational complexity, leading to failures on long-horizon tasks (shown in 4).
4.2 EXPERIMENT 2: CUBEAGENT WITH REWARDS
Experimental Setup. Our second experiment was designed to measure the impact of different dense reward mechanisms on agent performance. We used the Basic Agent agent configuration as the testbed. Its performance was evaluated under four distinct conditions: a baseline with no progressive feedback (no reward), and three conditions providing different dense reward signals (face, st i cker, and heurist c), which are introduced in Sec. [.1.4] and used as the return value for the make_move function. This direct comparison aims to clarify whether, and what kind of dense rewardss can aid the agent. The results are presented in Table B
Key Observations. (1) On short-horizon tasks, dense rewards generally lead to an increase in pass rates. (2) The pass rate all long-horing horizon tasks remains at 0.00, regardless of the presence type (3) The impact of rewards is inconsistent; in some cases, such as for GPT-5 on the Full Symbol i task with heurist
of dense reward.
sti tkic rewards, performance is lower than the no-reward baseline. (4) The ability to leverage rewards varies notably across models.
Insights. (1) Dense rewards can guide agent's search on short-horizon tasks by providing local heuristic guide. (2) The failure of rewards on long-horizon tasks indicates that local feedback cannot compensate for fundamental deficit in long-horizon state tracking. (3) On visual inputs, agents may leverage reward signals through symbolic reasoning. bypassing genuine visual reasoning, as shown in Sec. 5. (4) For more capable agents like GPT-5, an external reward can potentially conflict with their emergent internal strategies, leading to suboptimal performance. For less capable agents that may lack a strong internal strategy, any form of guidance from dense reward is often helpful, as seen with Claude Sonnet 4. The case studies are presented in Sec. 6 and 7 respectively.
4.3 EXPERIMENT 3: CUBEAGENT WITH SOLVER TOOLS
Experimental Setup. To precisely identify the primary bottlenecks in agent performance, our fi- nal experiment removes the burden of long-horizon planning by equipping agents with an opti- mal solver. We introduce two distinct configurations to isolate different cognitive challenges: the Standard-Solver Agent and the Ideal-Solver Agent. The Standard- that requires a specific, strict symbolic input format. To succeed, this agent must first accurately per- ceive the cube's 's state, then perform the crucial step of translating that perception into the required format. This translation process is non-trivial, potential differences between the environment' state representation (e.g., one rype of 2D unfolded map) and the solver's expected input (e.g., different face order or vertex numbering scheme). Fi-
Agent is given a solver
it requires spatial understanding to reconcile
8

---

Published as a conference paper at ICLR 2026
Table 4: Comparison of pass rates for Basic, Standard-Solver, and Ideal-Solver agent configura- tions. Modalities: Full Symbolic, Full Visual, Face View, Vertex View. Tier 3 denotes the hardest split and is evaluated under two projections: Face View and Vertex View. Horizons: Short (S) and Long (L).
Full Symbolic
Full Visual
Face view
Vertex view
Model
Agent Type
S
1.
8
I.
8
L
8
I.
Basic
0.75
0.00
0.20
0.00
0.40
0.00
0.05
0.00
GPT-5
Standard-Solver
0.95
0.95
0.65
0.70
0.00
Ideal-Solver
1,00
1.00
0.95
0.80
0.85
1.00
0.00
0.00
Basic
0.10
0.00
0.05
0.00
0.05
0.00
0.00
0.00
Gemini 2.5 Pro
Stundard-Solver
0.70
0.65
0.25
0,00
0.20
0.00
0.00
0.00
Ideal-Solver
1,00
1.00
0.25
0.00
0.00
0.00
0.00
0.00
Basic
0.05
0.00
0.00
0.00
0.00
0.00
0.00
0.00
Claude Sonnet
Standard- Solver
0.35
0.85
0.00
0.00
0.00
0.00
0,00
0.00
Idcal-Solver
1,00
1.00
0.00
0.00
0.00
0.00
nally, the agent must execute the solver's plan. This setup tests the agent's ability to handle state reconstruction, spatial transformation, and procedural tool use.
In contrast, the Ideal-Solver Agent is provided with a more advanced tool that automates the trans- lation step. This agent can directly pass its perceived state to the solver, thus bypassing the data formatting challenge. By comparing the performance of these two agents, we can isolate whether failures stem from reconstructing state from perception from the challenge of spatial under- standing during translation. The results are presented in Table
The Diagnosing Framework. Our evaluation is structured as progressive, three-step diagnostic process designed to systematically isolate and assess the core cognitive faculties of an agent. (1) Diagnosing Long- Horgzoo State Tracking and Planning. We first diagnose long-horizon tracking by comparing the Basic Agent with the Standard-Solve Agent on long-horizon symbolic tasks. The Basic Agent relies on internal reasoning, while the HandarddSSlvve outsources the planning chal- lenge to an optimal tool. Their performance gap reveals the agent's intrinsic planning capability. (2) Diagnosing Spatial Reasoning and Procedural Tool Use. Next, we diagnose the spatial reason- ing required for tool use by comparing the Standard-Solver Agent to the Ideal-Solver Agent. Since both agents offload planning, the performance gap isolates the challenge of spatial thinking, which translates perceptual input into a usable format for the tool. (3) Diagnosing Active Exploration under Partial Observation. Finally, to isolate exploration, we evaluate the Ideal-Solver Agent in a partial observation setting. The ideal tool removes both planning and translation challenges, leaving only the task of reconstructing a complete world model from fragmented information. Success here depends entirely on the agent's ability to actively explore its environment.
Key Observations. (1) The addition of the tools generally leads to marked performance gains compared the basic agent. (2) There is still performance gap between the Handard-SSlvvr and Ideal-Solver agents. (3) On Full 1 Visual and Face view tasks, only GPT-5 maintains strong performance, while all models fail universally on the Vertex view task.
Insights. (1) High-level, multi-step planning, or Long-Horizon State Tracking, is a primary deficit that can be successfully offloaded to external solvers. (2) The procedural challenge of using tools is non-trivial, rendering Spatial Reasoning an important challenge to resolve for further develop- ment. (3) An unanticipated but noteworthy finding is the emergence of tool-learning strategies in the Standard-Solvee Agent. In some instances, we observed a remarkable capability for autonomous tool-learning, where agents learn to master the tool through trial-and-error experimentation for this spatial conversation, as shown in Sec. 8 (4) A significant performance gap exists between the Face view and Vertex view tasks. The reason is that the orderly, grid-like structure of the Face view allows agents to succeed by recasting the task as algorithmic parsing problem. This indicates that models will attempt to bypass direct spatial reasoning in favor of a caasing-based approach whenever possible, and their performance suffers when the input's 's complexity, Vertex view, makes this bypass strategy infeasible. The corresponding case study is presented in Sec. 9
in the

---

Published as a conference paper at ICLR 2026
5 CONCLUSION
In this work, we introduced CubeBench, a diagnostic benchmark designed to probe the cognitive faculties required for spatial reasoning. Our comprehensive experiments demonstrate critical fail- ure in current leading models, which uniformly achieve a zero pass rate on all long-horizon tasks and struggle to bridge the gap from visual perception to symbolic understanding. Our diagnostic framework successfully isolated these bottlenecks, confirming fundamental deficits in Spatial Rea- soning, Long-Horizen State Tracking through Mental Simulation, and Exploration and Reasoning under Partial Observation. Our findings underscore the need for future research to focus on develop- ing more robust spatial mental models and grounding agents in the principles of three-dimensional interaction to unlock their potential in the physical world.
REFERENCES
Optimal solutions for the rubik's cube kociemba's algorithm. https://en. org/wike wttp///wi///paaa.l.... Tallssollie solutions tte htt.kk222/_cubeeeoiiemeeaaaa s algorithm Accessed September 2025.
lean-Baptise Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, lain Barr, Yana Hasson, Karel Lene, Arthur Mensch, Katherine Millican, Malcolm Reynolds, et al. Flamingo: a visual language model for few-shot learning. Advances in neural information processing systems, 35:23716- 23736, 2022.
Reem Aleithan. Haoran Xue, Mohammad Mahdi Mohajer, Elijah Nnorom, Gias Uddin, and Song Wang. Swe-bench+: Enhanced coding benchmark for 1lms. arXiv preprint arXiv:2410.6699,, 2024.
Josep Aulinas, Yvan Petillot, Joaquim Salvi, and Xavier Lladó. The slam problem: a survey. Artifi- cial Intelligence Research and Development, pp. 363-371, 2008
Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, al. Qwen2. 5-vl technical report. arXiv preprint 139933, 2025.
Jun Shern Chan, Neil Chowdhury, Oliver Jaffe. James Aung, Dane Sherbum, Evan Mays, Giulio Starace, Kevin Liu, Leon Maksin, Tejal Patwardhan, al. Mle-bench: Evaluating machine learn- ing agents on machine learning engineering, arXiv preprint arXiv:2410.07093 2024.
Kai Chen, Xinfeng Li, Tianpei Yang, Hewei Wang, Wei Dong, and Yang Gao. Mdteamgpt: A self-evolving llm-based multi- agent framework for multi multi-disciplinary team medical consultation. arXiv preprint arXiv:2503. 2tte:2503.338355 13856, 2025a.
Kaiyuan Chen, Yixin Ren, Yang Liu, Xiaobo Hu, Haotong Tian, Tianbao Xie, Fangfu Liu, Haoye Zhang, Hongzhang Liu, Yuan Gong, et al. xbench: Tracking agents productivity scaling with profession-aligned real-world evaluations. arXiv preprint (rXiv:2506.13551 2025b.
Shiqi Chen, Tongyao Zhu, Ruochen Zhou, Jinghan Zhang, Siyang Gao, Juan Carlos Niebles, Mor Geva, Junxian He, Jiajun Wu, and Manling Li. Why is spatial reasoning hard for vims? an attention mechanism perspective on focus areas. arXiv preprint arXiv:2503.0172: 2025c.
Zhe Chen, Jiannan Wu, Wenhai Wang, Weijie Su, Guo Chen, Sen Xing, Muyan Zhong, Qinglong Zhang, Xizhou Zhu, Lewei Lu, et al. Internvl: Scaling up vision foundation models and aligning for generic iisual-linguiste tasks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 24185 22185-24199, 2024a.
Ziru Chen, Shijie Chen, Yuting Ning, Qianheng Zhang, Boshi Wang, Botao Yu, Yifei Li, Zeyi Liao, Chen Wei, Zitong Lu, et al. Scienceagenthench: Toward rigorous assessment of language agents for data-driven scientific discovery. arXiv preprint arXiv:2410.05080, 2024b.
Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. Mem0: Building production-reate ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413 2025.
10

---

Published as a conference paper at ICLR 2026
Xiang Deng, Yu Gu, Boyuan Zheng, Shijie Chen, Sam Stevens, Boshi Wang, Huan Sun, and Yu Su. Mind2web: Towards a generalist agent for the web. Advances in Neural Information Processing Systems, 36:28091-281 14, 2023.
Jinyuan Fang, Yanwen Peng. Xi Zhang, Yingxu Wang, Xinhao Yi, Guibin Zhang, Xu, Bin Wu, Siwei Liu, Zihao Li, et al. A comprehensive survey of self-evolving ai agents: A new paradigm bridging foundation models and lifelong agentic systems, arXiv preprint arXiv:2508.07445
2025.
ARC Prize Foundation. Arc-agi-3: Interactive reasoning benchmark, 2025.
URL
https:
Accessed: 2025-09-20.
Chen Gao, Baining Zhao, Weichen Zhang, Jinzhu Mao, Jun Zhang, Zhiheng Zheng, Fanhang Man, Jianjie Fang. Zile Zhou, Jinqiang Cui, al. Embodiedcity: A benchmark platform for embodied agent in real-world city environment, arXiv preprint arXiv:2410.0900 2024.
Huan-ang Gao, Jiayi Geng, Wenyue Hua, Mengkang Hu, Xinzhe Juan, Hongzhang Liu, Shilong Liu, Jiahao Qiu, Xuan Qi, Yiran Wu, et al. A survey of self-evolving agents: On path to artificial super intelligence. arXiv preprint arXiv:2507.21044 2025.
Zhenyu Guan, Xiangyu Kong, Fangwei Zhong, and Yizhou Wang. Richelieu: Self-evolving 1lm- based agents for ai diplomacy. Advances in Neural Information Processing Systems, 37:123471- 123497, 2024.
Mohd Ariful Haque, Justin Williams, Sunzida Siddique, Md. Hujaifa Islam, Hasmot Ali, Kishor Datta Gupta, and Roy George. Advanced tool learning and selection system (ATLASS): A closed-loop framework using LLM. CoRR, abs/2503.1007// 2025.
Mengkang Hu, Pu Zhao, Can Xu, Qingfeng Sun, Jianguang Lou, Qingwei Lin, Ping Luo, and Saravan Rajmohan. Agentgen: Enhancing planning abilities for large language model based agent via environment and task generation. arXiv preprint arXiv:2408. 00764, 2024a.
Mengkang Hu, Yuhang Zhou, Wendong Fan, Yuzhou Nie, Bowei Xia, Tao Sun, Ziyu Ye, Zhaoxuan Jin, Yingru Li, Qiguang Chen, et al. Owl: Optimized workforce learning for general multi-agent assistance in real-world task automation. arXiv preprint 25X.v:2505.23885, 2025.
Yue Hu, Yuzhu Cai, Yaxin Du, Xinyu Zhu, Xiangrui Liu, Zijie Yu, Yuchen Hou, Shuo Tang, and Siheng Chen. Self-evolving multi-agent collaboration networks for software development. arXiv preprint arXiv:2410. 16946, 2024b.
Aaron Hurst, Adam Lerer, Adam Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Os- trow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276. 2024.
Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023.
Philip N Johnson-Laird. Mental models in cognitive science. Cognitive science, 4(1):71-115, 1980.
Philip Nicholas Johnson-Laird.
Towards a cognitive science of language, inference, and consciousness. Number 6. Harvard University Press, 1983.
Mental models:
Herbert Kociemba. Cube explorer and kociemba's two-phase algorithm. https: Sittps//kocleemas org/cube. htm. Accessed September 2025.
Eric Kolve, Roozbeh Mottaghi, Winson Han, Eli VanderBilt, Luca Weihs, Alvaro Herrasti, Matt Deitke, Kiana Ehsani, Daniel Gordon, Yuke Zhu, et al. Ai2-thor: An interactive 3d environment for visual ai. arXiv preprint 1rX1v:1712.05544,, 2017.
Richard E. Korf. Depth-first iterative-deepening: An optimal admissible tree search. Artificial Intelligence, 27(1)977-109, 1985.
Richard E. Korf. Finding optimal solutions to rubik's cube using pattern databases. In AAAI, 1997.
11

---

Published as a conference paper at ICLR 2026
Ido Levy, Ben Wiesel, Sami Marreed, Alon Oved, Avi Yaeli, and Segev Shlomov. St- webagentbench: A benchmark for evaluating safety and trustworthiness in web agents. arXiv preprint ar arXiv:2410.067000 2024.
Bowen Li. Zhaoyu Li, Qiwei Du, Jinqi Luo. Wenshan Wang, Yagi Xie, Simon Stepputtis, Chen Wang, Katia P. Sycara, Pradcep Kumar Ravikumar, Alexander G. Gray, Xujie Si, and Sebastian Scherer. Logicity: Advancing neuro-symbolic ai with abstract urban simulation, 2025. URL
plctps://ariis
Junnan Li, Dongxu Li, Silvio Savarese, and Steven Hoi. Blip-2: Bootstrapping language-image pre-training with frozen image encoders and large language models. In International conference on machine learning. pp. 19730-19742. PMLR, 2023.
Manling Li, Shiyu Zhao, Qineng Wang, Kangrui Wang, Yu Zhou, Sanjana Srivastava, Cem Gokmen, Tony Lee, Erran Li Li, Ruohan Zhang, et al. Embodied agent interface: Benchmarking Ilms for embodied decision making. Advances in Neural Information Processing Systems, 37:100428- 100534, 2024.
Xuechen Liang, Yangfan He. Yinghui Xia, Xinyuan Song, Jianhui Wang. Meiling Tao, Li Sun, Xinhang Yuan, Jiayi Su, Keqin Li, Siyuan Chen, and Tianyu Shi. Self-evolving agents with reflective and memory-augmented abilities. arXiv preprint arXiv:2409.00887 2024a.
Xuechen Liang, Yangfan He, Yinghui Xia, Xinyuan Song, Jianhui Wang, Meiling Tao, Li Sun, Xin- hang Yuan, Jiayi Su, Keqin Li, et al. Self-evolving agents with reflective and memory-augmented abilities. arXiv preprint urXiv:2409.008:
2024b.
Fangzheng Liu, Don Derek Haddad, and Joe Paradiso. Mindcube: an interactive device for gauging emotions. Adjunct Proceedings of 37th Annual ACM Symposium on User Interface Software and Technology, pp. 1-2, 2024.
Xiao Liu, Hao Yu, Hanchen Zhang, Yifan Xu, Xuanyu Lei, Hanyu Lai, Yu Gu, Hangliang Ding, Kaiwen Men, Kejuan Yang, et al. Agentbench: Evaluating 1lms as agents. arXiv preprint arXiv:2308. 038.088308.,3888 2023.
Junyu Luo, Weizhi Zhang, Ye Yuan, Yusheng Zhao, Junwei Yang, Yiyang Gu, Bohan Wu, Binqi Chen, Ziyue Qiao, Qingqing Long, Rongcheng Tu, Xiao Luo, Wei Ju, Zhiping Xiao, Yifan Wang. Meng Xiao, Chenwu Liu, Jingyang Yuan, Shichang Zhang, Yiqiao Jin, Fan Zhang, Xian Wu, Hanqing Zhao, Dacheng Tao, Philip S. Yu, and Ming Zhang. Large language model agent: sur- vey on methodology, applications and challenges, 2025. URL htttttt/s//:iiiiii org abs/ 2503.214600
Xiaowen Ma, Chenyang Lin, Yao Zhang, Volker Tresp, and Yunpu Ma. Agentic neural networks: Self-evolving multi-agent systems via textual backpropagation. arXiv preprint arXiv:2506.0900 2025.
Grégoire Mialon, Clémentine Fourrier, Thomas Wolf, Yann LeCun, and Thomas Scialom. Gaia: benchmark for general ai assistants. In The Twelfth International Conference on Learning Representations, 2023.
Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. Communications of the ACM, 65(1):99-106, 2021.
Long Phan, Alice Gatti, Ziwen Han, Nathaniel Li, Josephina Hu, Hugh Zhang, Chen Bo Calvin Zhang, Mohamed Shaaban, John Ling, Sean Shi, et al. Humanity's last exam. arXiv preprint urXiv:2501.14244 2025.
Renjie Pi, Jianshu Zhang, Jipeng Zhang, Rui Pan, Zhekai Chen, and Tong Zhang. Image textual- ization: An automatic framework for creating accurate and detailed image descriptions. arXiv preprint wrXivv2406.07500) 2024.
12

---

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, Vladimi r Vondrus" Vincent-Pieme Berges, John Turner, Oleksandr Maksymets, Zsolt Kira, Mrinal Kalakr- ishnan, Jitendra Malik, Devendra Singh Chaplor, Unnat Jain, Dhruv Batra, Akshara Rai, and Roozbeh Mottagii. Habitat 3.0: A co-habitat for humans, avatars and robots, 2023.
Jianing Qi, Jiawei Liu, Hao Tang, and Zhigang Zhu. Beyond semanties: Rediscovering spatial awareness in Asion-language models. arXiv preprint arXiv:2503.17349 2025.
Jiahao Qiu, Xuan Qi. Tongcheng Zhang, Xinzhe Juan, Jiacheng Guo, Yifu Lu, Yimin Wang, Zixin Yao, Qihan Ren, Xun Jiang, Xing Zhou, Dongrui Liu, Ling Yang, Yue Wu, Kaixuan Huang, Shilong Liu, Hongru Wang, and Mengdi Wang. Alita: Generalist agent enabling scalable agentic reasoning with minimal predefinition and maximal self-evolution. CoRR, abs/2505.20286, 2025.
Changle Qu, Sunhao Dai, Xiaochi Wei, Hengyi Cai, Shuaiqiang Wang, Dawei Yin, Jun Xu, and Ji-Rong Wen. From exploration to mastery: Enabling Ilms to master tools via self-driven interac- tions. In ICLR. OpenReview.net, 2025.
Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint vrXiv:1709.1000 2017.
Tomas Rokicki, Herbert Kociemba, Morley Davidson, and John Dethridge. God's Number is 20.
httpp:// http///wwwwc..o wwwpwwwwwwww..www/wwwoww org/ 2010.
Tomas Rokicki, Herbert Kociemba, Morley Davidson, and John Dethridge. The diameter of the rubik's 's cube group is twenty. SIAM Review, 56(4))645-670, 2014. doi: 10. /0.1137/149973499
Ravi Sapkota, Konstantinos Roumeliotis, Shiva Pokhrel, and Manoj Karkee. From self-learning to self-evolving architectures in large language models: A short survey. Authorea Preprints, 2025.
Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, Devi Parikh, and Dhruv Batra. Habitat: A Platform for Embodied AI Research. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2019a.
Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, et al. Habitat: A platform for embodied ai research. In Proceedings of the IEEE/CVF international conference on computer vision, pp- 9339-9347, 2019b.
Mohit Shridhar, Jesse Thomason, Daniel Gordon, Yonatan Bisk, Winson Han, Roozbeh Mottaghi, Luke Zettlemoyer, and Dieter Fox. Alfred: A benchmark for interpreting grounded instructions for everyday tasks, 2020.
01734
Mohit Shridhar, Xingdi Yuan, Marc-Alexandrr Côté, Yonatan Bisk, Adam Trischler, and Matthew Hausknecht. Alfworld: Aligning text and embodied environments for interactive learning, 2021.
URL htttt::///attiiiiieetttttttttttt orgg abs /2//22110 03768
Sanjana Srivastava, Chengshu Li, Michael Lingelbach, Roberto Martín-Martín, Fei Xia, Kent Vainio, Zheng Lian, Cem Gokmen, Shyamal Buch, C. Karen Liu, Silvio Savarese, Hyowon Gweon, Jiajun Wu, and Li Fei-Fei. Behavior: Benchmark for everyday houschold activities in virtual, interactive, and ecological environments, 2021. URL
2108 03332]
Hongjin Su, Ruoxi Sun, Jinsung Yoon, Pengeheng Yin, Tao Yu, and Serean Ö. Ank. Learn-by- interact: A data-centric framework for self-adaptive agents in realistic environments, 2025. URL
https://arxiv.ont wttp:b////a/a/////ooaa 10893
Andrew Szot, Alex Clegg. Eric Undersander, Erik Wijmans, Yili Zhao, John Turner, Noah Maestre, Mustafa Mukadam, Devendra Chaplot, Oleksandr Maksymets, Aaron Gokaslan, Vladimir Von- drus, Sameer Dharur, Franziska Meier, Wojciech Galuba, Angel Chang, Zsolt Kira. Vladlen Koltun, Jitendra Malik, Manolis Savva, and Dhruv Batra. Habitat 2.0: Training home assistants to rearrange their habitat. In Advances in Neural Information Processing Systems (NeurlPS). 2021.
13

---

Published as a conference paper at ICLR 2026
Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Bud- den, Abbas Abdolmalcki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint wrXhv:1801.06663 2018.
Karthik Valmeekam, Matthew Marquez, Alberto Olmo, Sarath Sreedharan, and Subbarao Kamb- hampati. Planbench: An extensible benchmark for evaluating large language models on planning and reasoning about change. Advances in Neural Information Processing Systems, 36:38975- 38987, 2023.
Hongru Wang, Yujia Qin, Yankai Lin, Jeff Z. Pan, and Kam-Fai Wong. Empowering large lan- guage models: Tool learning for real-world interaction. In Proceedings of the 47th Interna- tional ACM SIGIR Conference
Research and Development in Information Retrieval, SIGIR '24, pp. 2983-2986, New York, NY, USA, 2024a. Association for Computing Machinery. ISBN 9798400704314. doi: 10.114577666672.36613888 URL https: attps://8ci.orgg/D00 1626772.3661323
Lei Wang, Chen Ma, Xueyang Feng. Zeyu Zhang, Hao Yang, Jingsen Zhang. Zhiyuan Chen, Ji- akai Tang, Xu Chen, Yankai Lin, Wayne Xin Zhao, Zhewei Wei, and Jirong Wen. A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), March 2024b. ISSN 2036.2236. doi: 10. 11100///1100002444400000
URL htLhhtt://// dx. doi org/
10. 10.1007/50 s 704- 024 40231-1
Renxi Wang. Xudong Han, Lei Ji, Shu Wang, Timothy Baldwin, and Haonan Li. Toolgen: Unified tool retrieval and calling via generation. ICLR. OpenReview.net, 2025.
Jason Wei, Zhiqing Sun, Spencer Papay, Scott McKinney, Jeffrey Han, Isa Fulford, Hyung Won Chung, Alex Tachard Passos, William Fedus, and Amelia Glaese. Browsecomp: simple yet challenging benchmark for browsing agents. arXiv preprint arXiv:2504.122 2025.
Jialong Wu, Wenbiao Yin, Yong Jiang, Zhenglin Wang, Zekun Xi, Runnan Fang, Linhai Zhang, Yulan He, Deyu Zhou, Pengjun Xie, et al. Webwalker: Benchmarking llms web traversal. arXiv preprint ar arXiv:2501.00577 2025.
Tianbao Xie, Danyang Zhang, Jixuan Chen, Xiaochuan Li, Siheng Zhao, Ruisheng Cao, Toh Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, et al. Osworld: Benchmarking multimodal agents for open-ended tasks in real computer environments. Advances Neural Information Processing Systems, 37:52040-52095 2024.
Frank F Xu, Yufan Song, Boxuan Li, Yuxuan Tang, Kritanjali Jain, Mengxue Bao, Zora Z Wang, Xuhui Zhou, Zhitong Guo, Murong Cao, et al. Theagentcompany: benchmarking Ilm agents consequential real world tasks. arXiv preprint arXiv:2412.14161 2024.
Wenrui Xu, Dalín Lyu, Weihang Wang, Jie Feng, Chen Gao, and Yong Li. Defining and evaluating visual language models' basic spatial abilities: A perspective from psychometrics. arXiv preprint arXiv:2502. /859,, 2025a.
Wujiang Xu, Kai Mei, Hang Gao, Juntao Tan, Zujie Liang, and Yongfeng Zhang. A-mem: Agentic memory for IIm agents. arXiv preprint arXiv:2502. 2025b.
Jihan Yang, Shusheng Yang, Anjali W Gupta, Rilyn Han, Li Fei-Fei, and Saining Xie. Thinking in space: How multimodal large language models see, remember, and recall spaces. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp. 10632-10643, 2025a.
John Yang, Carlos E Jimenez, Alex L Zhang, Kilian Lieret, Joyce Yang, Xindi Wu, Ori Press, Niklas Muennighoff, Gabriel Synnaeve, Karthik R Narasimhan, et Swe-bench multimodal: Do ai systems generalize to visual software domains? arXiv preprint arXiv:2410.03885 2024.
Rui Yang, Hanyang Chen, Junyu Zhang, Mark Zhao, Cheng Qian, Kangrui Wang. Qineng Wang, Teja Venkat Koripella, Marziyeh Movahedi, Manling Li, et al. Embodiedbench: Comprehen- sive benchmarking multi-mod large language models for vision- driven embodied agents. arXiv preprint ar arXiv:2502.nm 09560, 2025b.
14

---

Published as a conference paper at ICLR 2026
Jianzhu Yao, Kevin Wang, Ryan Hsieh, Haisu Zhou, Tianqing Zou, Zerui Cheng, Zhangyang Wang, and Pramod Viswanath. Spin- beinhhench: How well do llms plan strategically and reason socially?, 2025. URL:ttts:://axttt org
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.3662, 2022.
Hongli Yu. Tinghong Chen, Jiangtao Feng, Jiangjie Chen, Weinan Dai, Qiying Yu, Ya-Qin Zhang, Wei-Ying Ma, Jingjing Liu, Mingxuan Wang. et al. Memagent: Reshaping long-context IIm with multi-conv rl-based memory agent. arXiv preprint arXiv:2507.02259 2025.
Tianhe Yu, Deirdre Quillen, Zhanpeng He, Ryan Julian, Karol Hausman, Chelsea Finn, and Sergey Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on robot learming, pp. 1094-1100. PMLR, 2020.
Danyang Zhang. Lu Chen, Situo Zhang, Hongshen Xu, Zihan Zhao, and Kai Yu. Large language models semi-parametric reinforcement learning agents. Advances in Neural Information Pro- cexsing Systems, 36, 2024a.
Dingchu Zhang, Yida Zhao, Jialong Wu, Baixuan Li, Wenbiao Yin, Liwen Zhang, Yong Jiang, Yufeng Li. Kewei Tu, Pengjun Xie, and Fei Huang. Evolvesearch: An iterative self-evolving search agent. arXiv preprint arXiv:2505. 22501, 2025a.
Genghan Zhang, Weixin Liang, Olivia Hsu, and Kunle Olukotun. Adaptive self-improvement Ilm agentic system for ml library development. arXiv preprint arXiv:2502.02534. 2025b.
Guanghui Zhang, Li Niu, Jianwei Fang, Kun Wang, Lu Bai, et al. Multi-agent architecture search via agentic supernet. arXiv preprini arXiv:2502.044 04000 80, 2025c.
Wenyu Zhang, Wei En Ng. Lixin Ma, Yuwen Wang. Junqi Zhao, Allison Koenecke, Boyang Li, and Lu Wang. Sphere: Unveiling spatial blind spots in vision- laigunle models through hicrarchical evaluation. arXiv preprint arXiv:2412.1 22693, 2024b.
Zheyuan Zhang, Fengyuan Hu, Jayjun Lee, Freda Shi, Parisa Kordjamshidi, Joyce Chai, and Ziqiao Ma. Do vision-language models represent space and how? evaluating spatial frame of reference under ambiguities. arXiv preprint arXiv:2410. 17385, 2024c.
Andrew Zhao, Daniel Huang, Quentin Xu, Matthieu Lin, Yong-Jin Liu, and Gao Huang. Expel: Llm agents are experiential learners. Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 19642, 2024a.
Haiteng Zhao, Chang Ma, Guoyin Wang, Jing Su, Lingpeng Kong, Jingjing Xu, Zhi-Hong Deng, and Hongxia Yang. Empowering large language model agents through action learning, CoRR, abs/2402. 15809, 2024b.
Boyuan Zheng, Michael Y. Fatemi, Xiaolong Jin, Zora Zhiruo Wang. Apurva Gandhi, Yueqi Song, Yu Gu. Jayanth Srinivasa. Gaowen Liu, Graham Neubig, and Yu Su. Skillweaver: Web agents can self-improve by discovering and honing skills. CORR, abs/2504.07079, 2025.
Shuyan Zhou, Frank F Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng. Tianyue Ou, Yonatan Bisk, Daniel Fried, et al. Webarena: A realistic web environment for build- ing autonomous agents. arXiv preprint wxXi:2337.138855 2023.
Wangchunshu Zhou, Yixin Ou, Shengwei Ding, Long Li, Jialong Wu, Tiannan Wang, Jiamin Chen, Shuai Wang, Xiaohua Xu, Ningyu Zhang, et al. Symbolic learning enables self-evolving agents.
arXiv preprint arXiv:2406. 18532, 2024.
Kunlun Zhu, Hongyi Du, Zhaochen Hong, Xiaocheng Yang, Shuyi Guo, Zhe Wang, Zhenhailong Wang, Cheng Qian, Xiangru Tang, Heng Ji, et al. Multiagentbench: Evaluating the collaboration and competition of Ilm agents. arXiv preprint arXiv:2503.01935. 2025.
Yangyang Zhuang, Wenjia Jiang, Jiayu Zhang, Ze Yang, Joey Tianyi Zhou, and Chi Zhang. Learning to be a doctor: Searching for effective medical agent architectures. arXiv preprint arXiv:2504. / 11301, 2025.
15

---

Published as a conference paper at ICLR 2026
A LLM USAGE STATEMENT
Model. The LLMs employed in our study are GPT-5 and Gemini 2.5 Pro.
Scope. We used large language models (LLMs) only as general-purpose assistants for language pol- ishing, typo checking, and minor code boilerplate generation. LLMs did not contribute to research ideation or produce novel scientific claims, proofs, or results.
Human oversight and verification. All text and code produced with LLM assistance were reviewed, corrected, and verified by the authors. Experimental results were reproduced independently of any L.M outputs.
Data governance. We did not share proprietary or sensitive data with third-party services beyond materials already included in the anonymous submission artifacts.
Atribbttoon. LLMs not authors and bear no responsibility for the content; full responsibility lies with the paper's 's authors.
B WHAT EXACTLY DOES CUBEBENCH MEASURE?
CubeBench not intended to be a broad coverage benchmark that competes with large embodied suites or classical Rubik's Cube solvers. Instead, it serves minimal, verifiable, factorized diag- nostic environment. By stripping away perception noise, multi-object dynamics, affordances, and actuation, it allows us to focus on three core cognitive abilities that repeatedly emerge bottle- necks for LLM/MLLM agents in more complex settings: (i) 3D spatial reasoning, (ii) long-horizon non-commutative planning, and (iii) belief-state construction under partial observability.
Our three-tier design decouples these abilitics by progressively increasing the burden placed on the agent's internal world model. Tier 1 (Full Symbolic) exposes complete 54-character state, so all perception and grounding are provided by the environment; this setting primarily stresses non- commutative long-horizon planning and state tracking. Tier 2 (Full Visual) replaces the symbolic string with 2D unfolded image, forcing the agent to construct its own symbolic representation from pixels: segmenting the cube, clustering colors, assigning stickers faces, and mapping the 2D layout to a consistent 3D frame before any planning can begin. Tier 3 (Partial Visual) further restricts each observation to a single face or corner view, plus view-change actions, so the agent must actively explore, aggregate partial views over time, and maintain coherent latent world state while its own actions continuously perturb the cube.
On top of these observation tiers, the different solver configurations act controls that selectively remove specific difficulties. A Basic Agent must handle perception, internal state tracking, planning, and formatting. In the Standard-Solver setting, we outsource optimal planning to Kociemba- based solver, so performance is driven mainly by visual + symbolic translation and correct schema formatting. The ideal-Solver setting goes one step further by also hiding the solver's input schema, leaving only the requirement to output a correct symbolic cube state; any gap between Standard- and Ideal-Solver performance therefore isolates visual grounding and spatial mapping errors rather than planning or forin-fooraat issues.
This factorized design explains "what" CubeBench measures in contrast to existing planning and embodied benchmarks. Classical planning suites such as PlanBench (Valmeekam et al. 2023). SPIN-Bench (Yao al. 2025). and ARC/ARC-AGI (Foundation) 2025) probe rich algorithmic and combinatorial structures, but they do not directly target the specific triad of 3D spatial reasoning, non-commutative dynamics, and partial-observee -ostrvaiobservation belief-state tracking in single, fully verifi able physical system. Conversely, embodied 3D suites such as ALFRED (Shridhar et al., 2020). Habitat(Savva et 20.9|219aa] [Szo et al., 2021 Puig al. (002). BEHAVIOR 100 (Srivastava al.) 2021), LogiCity (Li et al. 2025), ) BebcchedBench (Yang al. 2025b), and EAI (Li et al.) 2024) place agents in visually rich, multi-object worlds with realistic physics and affordances, but neces- sarily entangle perception, control, and high-level reasoning. As several of these works themselves emphasize, final success rates in such environments make it difficult to pinpoint which cognitive ability has failed.
CubeBench occupies an orthogonal niche in this landscape. It uses a single rigid object with de- terministic kinematics provide low-noise, automatically verifiable testhed where failures can
16

---

Published as a conference paper at ICLR 2026
be crisply attributed: incorrect 3D world modeling, short effective planning horizons, unstable belief-state tracking under partial observation. The negative results we obtain- universal collapse at depth 8, severe degradation from symbols to images, and near-zero success under partial views- mirror the failure modes reported broader embodied benchmarks, but in a setting where they can be disentangled and systematically ablated. In this sense, CubeBench is best viewed nostic stop before running expensive embodied evaluations: if an agent already fails to maintain a consistent 3D mental model and long-horizon plan in this simplified domain, is unlikely succeed in more complex physical worlds.
first diag-
C REVISED BASELINE PERFORMANCE USING MOVE RATIOS
To account for the variation in task difficulty, we introduce the Number of Move Ratio (#MR) normalized measure of search efficiency. Optimal path lengths increase non-linearly with scramble depth, therefore define #MR as the ratio of the agent's move count to the optimal solution length:
#MM (number of make_moves
#MR (number of move ratio) depth (number of optimal moves)
Table 5: Baseline performance across modalities and horizons on CubeBench. Top row: metric groups (Pass rate, #MR, where #MR the average number of move ratios; second row: obser- vation modalities; third row: task horizons (Short S, depths 1-4; Long I., depths 8, 12, 16, 20). Tier denotes the hardest split, evaluated under two projections: Face View and Vertex View. Blue shading denotes open-source models, and pink denotes proprietary models. For each metric column, we shade the top-3 entries (redd 1st, orange 2nd, yellow 3rd). We also train an MLP with policy gradient on the Full Symbolic setting; details are in Sec. H "_", Model does not support visual inputs.
Pass rate
Fall Symbolic
Visual
view
Vertes
Full Symbolic
Visual
Fice view
Vartes view
Model
1.
1.
GPP-55
I:75
[0:00]
0.00 (0:00
0.00 0.05
0.00
(3992178
29.21
17,89
837885 672.77
MLP (Policy Gradient)
0.75
0.00
5.17
400.00
apt-iss-126 206
0.20
01.00
47173.21
14219.57
Grok-4
0.26
(1.00
[005
0.00
0.00
0.00
0.00
0,00
1.34
0.97
1.76
5.28
181
0.25
18.36
0.84
Kimi K2 (2004-99-55)
0:15
0.00
25705
118.25
Gomini 2.5 Pro
0.10
0.00
[006
0.00
0MS5
0.00 0:00
0.00
59.01
12.55
19.30
3.15
4.05
0.55
13.28
1.85
DeepSeek RI (2025 05 28)
0.05
0.00
14004,88
4724.51
Clande Sonnet 4
B,25
01000
0.000
0.00
0:00
1,000 0:00
0.00
28.59
9:115
14.11
1.93
2.67
2.43
9,40
5.75
Qwee3 Max
DJ2
0100
15.92
3.48
DeepSeok-VV) V3.1
0,05
0.00
21.89
1.66
doubao seed 1-6 vision
0.05
0.00
0.00
0.00
0.00
0:00
4.77
0.94
6.79
1.00
6.26
0.84
1.10
InternVL-3 (780)
0.00
0.00
0.00
0.00
0,05
0:00
0.00
(5666677
4.85
23.27
18.06
2.61
29.14
6.84
Qwea2.5. 5- S..VL.--76
0:00
45712.71
2575.65
5.97
27.25
2.44
kimi-ola Sh-thinking
0.00
GPT-40
55.41
5.17
21,08
(immma-1278..
0.00
0.00
0.00
12.20
1.56
15.49
9.38
11.49
1.21
OSS. 36B- Instract
0.00
0.00
9.22
0.95
D THE NO-CODE EXPERIMENT
Experimental Setup. In our primary evaluation (the Code setting, which corresponds to the Basic Agent configuration in Experiment 1), agents are permitted to write and execute Python code. While writing code to perform search algorithms is valid problem-solving strategy in the agentic era, we acknowledge that distinguishing intrinsic spatial reasoning from programmatic search is crucial. To isolate the model's internal state tracking and planning capabilities from code-based search, we introduce a No-Code evaluation mode. In this mode, the agent must output pre-planned sequence (e.g., "moves" " "D' "B', "B']) without the ability to manage control flows during tool use. This mode is more consistent with common tool-use interfaces such the OpenAI APL. We conducted an ablation study comparing the No-Code and Code settings on the Short- Full Symbolic с tasks. The results are presented in Table
Key Observations & Insights. (1) Models employing intensive search strategies (High #MR) suf- fered catastrophic declines. Both GPT-5 (0.75 to 0.25) and gpt-oss- (0.20 to 0.00) saw their performance evaporate as their search volume collapsed (e.g.. GPT-5 #MR: ~22k to ~72 gpt-oss- 120b #MR: 447k 14). This confirms that for these agents, the code-based search compensates
17

---

Published as a conference paper at ICLR 2026
for limited internal planning. (2) Models with initially low search volume (Low #MR) displayed mixed outcomes rather than uniform drop. Grok-4 improved (0.20 to 0.30) in the No-Code setting, while many remained poor.
Table 6: Comparison of agent performance in No-Code vs. Code settings on Short-Horizon Full Symbolic lic tasks. #MR is averaged over testcases.
Code
Code
Model
Pass Rate
#MR
Pass Rate
#MR
GPT-S
0.25
72.79
0.75
27124.66
gpt-oss-120b
0.00
14.20
0.20
47173.21
Grok-4
0,30
2.02
0.20
1.84
Kimi-K2-0905
0.00
55.15
0.15
23705.38
Gemini 2.5 Pro
0.15
18.68
0.10
59.01
Claude Sonnet
0.00
68.03
0.05
28.59
DeepSeek-V22 V3.1
0.00
17.11
0.05
21.89
DeepScek-RI 1-0528
0.00
12.28
0.05
14074.89
Owen3-Max
18.11
0.05
GPT-4o
0.05
61.53
0.00
GLM-4.5v
0.00
16.61
Depth
Depth vs
Geree no Vin CITTS
Gemiel Pro
gats
0.7
0.6
Grob-i
4G
Pass Rate
0.5
CITTO Vertee Viea
GPT'S View
Grob-4 Viee
0.3
0.0
0.0
12
16
20
12
Depth
Depth
Depth vs #MR (Tier 1)
Depth vs eMR (Tier 2 & 3)
DespSest-R1 01-0000
Gemee Pro Viww Gemeee Pull Vtew
150000
(911
17500
Somee Pro vortz View
125000
1i--0nn 1200
15000
:2500
100000
Gric-l Viee
GHOR-4 Vertox View
7500
50000
5000
25000
12
2.
Figure 6: Pass rates and average number of move ratios (#MR) across varying depths. Top row:
Pass Rates for Tier (Left) and Tier 2/3 (Right). Bottom row: Corresponding #MR analysis.
E DEPTH-WISE METRICS
Experimental Setting. We adopt the experimental protocol from Experiment 1, extending the eval- uation to three independent trials per test case to ensure robustness. For this analysis, we mainly focus exclusively the perforrformnng models in Experiment 1. The comparative results pre- sented in Figure
Key Observations & Insights.
18

---

Published as a conference paper at ICLR 2026
(1) Seeth-vs-Perfomme GPT-5) maintain high accuracy across Depths 1-4,, with pass rates decaying gracefully. Conversely, less capable models (e.g., Grok-4) succeed at Depth via direct policy but degrade immediately at Depth 2. In Tier 2/3 settings, the performance cliff arrives earlier. While agents can manage Depth 1 tasks, we observe drop starting just Depth 2. A universal limit appears between Depth 4 and 8. Pass rates drop to 0.00 at Depth 8 across all settings, confirming that current planning capabilities fail to track state over extended horizons.
In the Tier setting, top-tier models capable of systematic search (e.g.,
(2) DMP We interpret the #MR metric not as a measure of "effort" scaling linearly with difficulty. but as an indicator of cognitive mode. A low move count typically signals reliance on direct intuition or trivial heuristics, while high move count signals the activation of explicit search. The switch often discrete jump rather than gradual increase. close examination of execution traces reveals how agents dynamically adapt within a single trial. Typically, earch-based agents begin with low-cost heuristics, switching high-volume search when those initial attempts fail. In rare instances (e.g.. Appendix L.2). we observe a further strategic shift: abandoning search entirely to implement structured human algorithms, such as the Beginner's Method (see Appendix D. as fallback.
F RELATED WORKS (CONT.)
Spatial Cognition. The ability to reason about three-dimensional space (Li et al. 2023, Pi et al., 2024 Alayrac et al. 2022), cornerstone of intelligence, relies on an internal spatial mental model (Johnson-Lirdd 1980; 1983) to infer unseen properties and predict the consequences of actions. Yang et al. 2025a Zhang al. 2024c) This concept is rooted in cognitive science and has been a long-standing goal, with specializes systems like SLAM in robotics (Aulinas et al. 2008 and
NeRFs (Mildenhall et al. 2021) in computer vision designed to construct explicit 3D representa-
tions. However, the intrinsic ability of Large Language Models (LLMs) (Bai et al., 2025 Hurst
al. 2024 Chen et al. 2024a), which excel sequential data, to form and manipulate such spatial models remains a critical open question. Recent works have begun to probe this (Xu et al.]
2025a
Zhang et al./ [2024b] Chen al., 2025c Qi et al. 2025); for instance, MindCube (Liu et al. 2024)
evaluates an agent's 's ability to reason about a static 3D scene by reasoning about its complete layout from few partial viewpoints. While also leveraging partial observations, CubeBench introduces the distinct challenge of long-horizon interaction with a dynamic cube. Our work therefore shifts the focus from reasoning about static perspectives to the more complex challenge of updating a mental model through direct, state-altering interaction with the environment, emphasizing mental simulation and long-horing monghoorzoon state tracking.
G CONFIGURATION OF TEST SPLIT
Our evaluation set is constructed across eight distinct levels of task difficulty. These levels are determined by the state's "ddpth", which is the optimal number of moves required to solve a given cube configuration. For each of the eight difficulty levels, we sample five unique initial states. Each state is then tested across four different environment settings derived from the three-tiered framework: Full Symbolic (Tier 1), Full Visual (Tier 2), and the two Partial Visual modalities (Face View and Vertex View) from Tier 3. This methodology yields a total of 160 unique evaluation configurations (8 difficulties x 5 states x 4 settings) for each Large Language Model (LLM) agent. To provide an estimate of the resources required, a single, complete evaluation run of these 160 configurations GPT-5 consumes total of 59.3 million tokens (50.2 million input tokens and 9.1 million output tokens), resulting in a total cost of approximately $153, based on the pricing of $1 $1.25 per million input tokens and $10 per million output tokens.
H INTRODUCTION TO THE POLICY GRADIENT BASELINE
As a baseline for comparison in the Full Symbolic setting, we implement a classic reinforce- ment learning agent based the Policy Gradient (PG) method. Policy Gradient algorithms directly optimize the parameters of a policy by estimating the gradient of the expected return. The core idea is to adjust the policy's parameters to increase the probability of taking actions that lead to higher
19

---

Published as a conference paper at ICLR 2026
cumulative rewards. Our implementation uses the REINFORCE algorithm, a foundational Monte Carlo policy gradient method.
The objective of the REINFORCE algorithm is to maximize the expected total discounted reward, (0), by updating the policy parameters the direction of the gradient (oJ(0). The policy gradient theorem provides estimate for this gradient:
VaJ(O) ETTWT
Σ Va log (a(ass)))
where To(a; (s) ) is the policy (the probability of taking action in state st), and Gt Eker 2 "T the total discounted return from time step onward.
Our specific implementation utilizes Multi-Layer Perceptron (MLP) to represent the policy net- work. The training conducted using curriculum learning strategy, where the agent progres- sively trained on more difficult tasks by increasing the scramble length of the cube. The detailed configuration as follows:
Algorithm: REINFORCE
Policy Network: A five-layer MLP with 256 neurons per layer and ReLU activation func- tions.
Optimizer: Adam with a learning rate of 5 10-4.
Discount Factor (r)) 0.99.
Training Environment: We use 64 parallel vectorized environments for efficient data col- lection.
The policy updated after collecting rollout of 512 steps from each par- allel environment, using batch size of 512 episodes for the gradient update.
Update Rule:
Training uses the curriculum learning for better convergence. We train two separate models, one for short-horizon tasks and for long-horizon. For short-horizon tasks, the model is trained sequentially on scramble depths of 1, 2, 3, and 4, with the number of training timesteps scaled quadratically for each level (e.g., from 40,000 for depth up to 320,000 for depth 4). For long- long-horizon tasks, separate model is initialized from the converged short-horizon agent and then continues training on the more challenging depths from 5 to 20 with 320K steps each level.
Curriculum:
Max Number of Make-moves During Evaluation: For short-horizon tasks, the maximum number of making moves is 16. For long-horizon ones, they are 400.
I TOOLS FOR AGENTS
I.1 FUNDAMENTAL INTERACTION TOOLS
make move: This tool executes single face rotation. It accepts one of 12 possible inputs corre- sponding standard Singmaster notation: (Front), (Back), L (Left), R (Right), U (Up), and (Down) for clockwise turns. A prime symbol (") denotes a counter-clockwise rotation (e.g., F²). Each call to this tool deterministically alters the cube's s internal state. Since the agent can generate custom scripts in the Code block, this function can be called multiple times (e.g., in a loop) within a single step to exccute a sequence of moves.
get oissobservation: This tool retrieves the current observation of the cube. The format of the returned data is contingent upon the experimental tier:
In Tier (Full Symbolic State), it returns a 54-character string that symbolically repre- sents the complete state of the cube.
In Tier 2 (Full Visual State) and Tier 3 (Partial Visual State), it returns an image. De- pending the specific task configuration, this can be complete 2D unfolded map of the cube, an image single face (face view), or an image from corner's perspective (vertex view).
20

---

Published as a conference paper at ICLR 2026
Exclusive to the Tier 3 (Partial Visual State) setting, this tool allows the agent to alter its viewpoint (e.g., up, down, left, right). This capability is essential for actively exploring the cube to reconstruct its full state from series of limited views.
1.2 AUXILIARY SOLVER TOOLS
StandardSolverTool. and IdealSolverToll: These tools provide the agent with access to a solver based on Kociemba's two-phase algorithm (see Appendix K They differ in crucial aspect related to data formatting. The underlying solver requires a specific input format that is distinct from the state representation provided by the get_observaticn tool.
The IitanaadSSo verTool requires the agent to perform the necessary format conver- sion itself, thus testing its ability to transform data into a usable representation.
The IdealSolverTool features a built-in converter. allows the agent to input the state in the environment's native format and receive solution directly, thereby bypassing the format conversion challenge.
J HEURISTIC ALGORITHM FOR SOLVING THE RUBIK'S S CUBE: APPROACH
This subsection formalizes the heuristic algorithm for solving the 3x3 Rubik's Cube using the layer- by-layer (LBL) method. We drew the method from solvethecube website and adopted its illustra- tions. The cube-solving process is divided into seven major steps, each focusing on solving specific parts of the cube. Each step involves operations algorithms that manipulate specific pieces, pro- gressively solving the puzzle. As introduced in our discussion on reward functions (Sec. (Sec.3.1.4) this LBL structure forms the basis of our Heuristic Metrie (Dhearistic). To calculate a score for any given cube state 8, we evaluate it against the seven steps of the LBL method. The state's score, @heuristic is defined as the highest step number (from 0 for scrambled cube for solved one) that the configuration has successfully completed.
Overall Strategy The solving process begins with the initial scrambled state So and progresses through seven steps until the solved state S achieved. Each transformation corresponds specific phase of the solution:
4
L2
I s*
So
S2
where:
f:: Forming the bottom cross.
fz: Positioning the bottom corners.
fs: Solving the second layer edges.
fa: Creating the top cross.
fs: Permuting the top edges.
fo: Positioning the top corners.
J:: Orienting the top corners.
Each step is represented by algorithm or set of moves that solves a specific portion of the cube without disrupting previously solved sections. See Fig. for an intuitive schematic.
Step 1: Forming the Bottom Cross The first task to form cross on the bottom layer by positioning the four edge pieces such that their colors match both the bottom face center and the adjacent side centers. This step can be formalized as:
URRL UURLLtttpss//ooeehccuu..ccc//
21

---

Published as a conference paper at ICLR 2026
(a)
(b)
(c)
(d)
(e)
(f)
(g)
Figure 7: The diagram from solvethecube website illustrates heuristic method for solving a Rubik's 's
Cube: (a) Forming the bottom cross, (b) Positioning the bottom corners, (c) Solving the second layer edges, (d) Creating the top cross, (e) Permuting the top edges, (f) Positioning the top corners, and
(g) Orienting the top corners.
feross Obotiom
Cettom
where Chottom {F1, F2, Fg, F4) represents the four edge pieces positioned, and Chotom represents the state where the bottom cross is correctly formed. The process involves identifying the edge pieces and applying algorithms move them into place.
Step 2: Positioning the Bottom Corners After the bottom cross formed, the next objective is to position the bottom corner pieces. Let Obottom comner = {C1, C2. C3, C4) represent the four corner pieces be positioned in the bottom layer. This step formalized as:
f foorners Cbottom-comeer
C Chotom-commer
where Cottom-comer represents the correctly positioned bottom corners. The operation involves ap- plying specific algorithms to move each corner piece into correct location without disturbing the already solved bottom cross.
Step 3: Solving the Second Layer Edges The next step is to solve the edges of the second layer. Let Osecond layer edge (Fs Fa, E7, Fig represent the four edge pieces that need to be positioned in the middle layer. The operation can be formalized as:
f scccond-layer Caecond-laye-edge
C Cecond Layood-llyerreddge layer
where C* sccond-laye--edge represents the state where the second layer edges are correctly positioned. The goal is move the edge pieces from the top layer the second layer, maintaining the solved bottom layer.
Step 4: Creating the Top Cross After solving the second layer, the next objective is to create cross the top layer. Let Crop-edge (Es E1o, E11, Eig} represent the four edge pieces that need to be positioned on the top layer. This step can be formalized as:
Cup-enoss:
Crop-edge
Ct
Ciop-odge
22

---

Published as a conference paper at ICLR 2026
where Ciop-ddee represents the state where the top layer edges correctly aligned. The transforma- tion for each edge piece is represented by:
Ar
E
E for i E {9, 10, 11, 12)
The goal to position the edge pieces correctly on the top layer without disturbing the solved portions of the bottom and second layers.
Step Permuting the Top Edges Once the top cross is formed, the next objective to permute the top layer edge pieces into their correct positions. This operation be formalized as:
pprmute-cdggss
Cup edge
C edge
where Cop edge represents the state where the top layer edges are correctly permuted. The goal is to apply specific algorithms that permute the top edges into their correct positions.
Step 6: Positioning the Top Corners the top layer corners. Let Crop-comer This operation can be formalized as:
After the top edges are permuted, the next step is to position [C1s: Cia. C15, C16} represent the four top corner pieces.
Pposition-comers Cro-scomer
C
top-comer
where Cip comer represents the state where the top corners are positioned correctly. The goal is to apply specific algorithms to move the top layer corner pieces into their correct positions.
Step 7:
Orienting the Top Corners The final step to orient the top corners, ensuring that the top face becomes uniform in color. This operation can be formalized as:
farient- corners
Coop-comer
S
where S* represents the solved state the Rubik's Cube. The transformation for each corner piece represented by:
Ac, C for E (13, 14, 15,
C
The goal to apply specific algorithms to orient the top corners without disturbing the already solved portions of the cube.
Mathematical Summary of the Layer-by-Layer Approach mathematically summarized as series of state transformations:
The Rubik's Cube solution can be
So faos
S forse S2
fusconl-aaye
S3
Sup-enos
S4
fyemute cdgo
Ss
SB
F CORECOS
S
Each transformation fersss fourners:- ... forient corners corresponds specific of moves that trans- form the cube toward the solved state. By applying these transformations sequence, the cube is solved layer by layer.
K CUBE SOLVERS (TWO-PHASE AND OPTIMAL)
This appendix introduces the two solvers used in our benchmark: the Two-Phase Solver and the Op- timal Solver. The two-phase solver used as the basic component for St andd verTool and
while the optimal solver is used for generating the testcases. In the fol- lowing, we first outline the mathematical background for the two-phase method, and then describe the I/O formats and the roles each solver plays in experiments.
23

---

Published as a conference paper at ICLR 2026
K.1 INPUT AND OUTPUT FORMATS FOR CUBE STATE
To interact with solvers, the cube state must be expressed in a precise facelet string representation: fixed ordering of all 54 stickers. Figure illustrates the two indexing conventions used in our system: (1) the Initial Format used by our environment, and (2) the Solver Format required by the Kociemba two-phase solver.
g
Initial Format. The environment internally stores the cube 2D unfolded cross (see left of Fig. 8). Each sticker is labeled by its face and index, e.g. U1-U9 for the Up face. R1-R9 for the Right face, etc. Within each face, indices increase row by row from top-left bottom-right:
U1, U2 U3, U4, U6, U7, U7,U8,U5 U9,
and similarly for R. L,,
The environment's ' concatenation order follows the visual "cross net" layout: first the Up face, then Left-Front Front-Right in row, followed by Down, and finally the Back face. Explicitly, the 54 54-character string is constructed
(F1,
F9, B1.
B9,
L1, LI.... L9, RI.... R9, UI.... U9, D1,..., D9).
Solver Format. the strict order
The two-phase solver requires the cube state as 54-character string, concatenated
(UI...., U9, R1 R...... R9, FI...., F9, DI, D9, LI,.... L9, , B9).
Each character encodes the color on the corresponding facelet. For example, the string UBL... means: position U1 has the U-color, position U2 has the B-color, position U3 has the L-color, and so on. This flattened sequence the standard facelet string convention used Kociemba's solver.
Conversion. Figure 8 shows how the Initial Format is mapped into the Solver Format. This con- version step is crucial: any misalignment (e.g., rotated faces or incorrect indexing) produces invalid solver inputs and prevents the plan from being executed correctly. The Standard-Solver Agent must handle the format conversion by itself, whereas the Solver Agent has the conversion built in dlealSolverTor and requires further effort.
Initial Format
Solver Format
1Z
RI
E4
LS
F6
R4
RA
2.5
C6
F4
RLS
R6
26
Figure 8: Input/Output formats of cube state. Left: Initial Format used in our environment. Right: Solver Format required by the two-phase solver. Both correspond to the same cube state but differ in indexing layout and concatenation order.
K.2 THO-P SOLVER
Mathematical Background. Let Go denote the full Rubik's Cube group generated by face turns in the half-turn metric (HTM). Using standard Singmaster letters, convenient presentation is
24

---

Published as a conference paper at ICLR 2026
G. (U.D.R.L.F.B)
=U,U', D,D', R, F,F", F., B,B,
That is, quarter turns, their inverses, and half turns generate the same group.
The Two-Phase method (Kociemba wik) reduces arbitrary state to structured subgroup and then completes the solve inside that subgroup. Let H (often also written as G1) be the Phase-1 target subgroup,
H { E Go all edges oriented, all corners oriented,
and the four UD-slice edges lie in the UD slice }.
Equivalently, H is exactly the of states reachable using the restricted Phase-2 move set (U,U",U D,D', R?, L2 F², B²),
since these moves preserve the above invariants. Finally,
{c} G2 C C Go.
where e is the identity (the solved cube). The overall decomposition is
Phase 1: Gg - H (reduce H)
Phase 2: H {e) (solve within H).
In practice, both phases use depth-iterative search guided by large pruning (distance) tables; Phase explores cosets of H in Go. and Phase searches within H/ down
Algorithmic sketch. Phase 1 finds short maneuver (typically < 12 HTM moves) that sends the current state into H. Phase 2 continues from H using only U U',, U² reach the identity. Due to strong heuristics and symmetry reductions, solutions are obtained quickly and are usually < 20 moves, though not formally guaranteed to be optimal (Kociemba).
D=1 D2, R² L2 F² B to
Typical properties. The method is fast, yields short, clean plans, and is well-suited as callable planning tool for agents.
K.3 OPTIMAL SOLVER (IDA* * WITH COMPLETE PRUNING)
Algorithmic sketch. The Optimal Solver performs Iterative Deepening A (IDA*) search (Korf 1985 1997). guided by admissible heuristics derived from large pattern/pruning databases. IDA combines the space-efficiency of depth-first search with the optimality guarantees of A* The search depth limit is increased incrementally; once solution is found at depth d, minimality is certified since all shorter paths have been exhausted.
Algorithm IDA* with Pattern Database Heuristics
1: function +ss))
2: bound t h(sa) while true do
4: t - SEARCH(So. 0, bound)
5: if = oo then return failure
6: else if solution then return solution path
7: else
bound function SEARCH(s, 9, bound)
9:
10:
f 9 hhs)
11:
if bound then return
12:
if s is goal then return solution
13:
min f-o 00
14:
for each successor s' of do SEARCH(S', + bound)
15:
if solution then return solution
17:
it < min then min +- return man
18:
25

---

Published as a conference paper at ICLR 2026
Heuristic. The pruning tables (pattern databases) precompute exact solution lengths for subprob- lems such as subsets of edges or corners. During search, these values serve as admissible heuristics, drastically reducing the number of expanded states.
Typical properties. Under HTM, the with some positions requiring the exact 20 moves. (Rokicki et al. 2014, 2010). While run time can seconds on easy instances, hard positions near the 20-move depth may require minutes to hours. However, the returned solution is provably optimal, making the solver suitable for dataset construction and difficulty certification.
cube can always be solved within 20 moves,
Table 7: Two-Phase vs. Optimal Solvers.
Solver
Optimality
Role
Near-optimal Provably optimal
Agent tool
Optimal
Testcase construction
L
CASE STUDIES
Sec.
An agent solves the cube by applying heuristic beam search.
Sec.
2
An agent tries first with IDDFS and then with the Beginner's Method.
Sec.
...
A less capable agent attempts random walk (brute-force) and fails to make progress.
An agent implements a meet-in-ther midde search, but its pruning strategies insuffi- cient to overcome the exponential state space.
Sec.
An agent bypasses visual reasoning, relying exclusively on heuristic reward to guide its symbolic search.
Sec. L.3
Sec. L.6
A capable agent is misled by a simplistic reward and only succeeds after abandoning favor of its own subgoal- based reasoning.
Sec. simple external reward successfully guides an agent's search, leading to incremental progress.
Sec.
L.8
An agent learns to use an external planner by systematically experimenting with input
formats.
An agent succeeds on a structured visual task by using symbolic shortcut but fails on a distorted view that requires genuine spatial reasoning.
Sec. L.9
L.1
BASIC AGENT BEAM SEARCH
Model
Agent Type
Input
Reward
Depth
GPT-5
Basic
Full Symbolic
No reward
8
In this case, GPT-5 applies heuristic beam search strategy to solve the Rubik's Cube. Initially, the agent deduces the exact permutations of the six basic moves (F, B, U, D, R, L) using randomized scrambles and signature matching. With these move permutations, the agent can simulate cube state transitions internally, allowing it to conduct search without repeated environment queries.
The search itself implemented as a beam-style search with heuristic pruning:
Heuristic function: The agent uses simple facelet mismatch count to evaluate each state relative to the solved configuration.
Beam width: At each depth, candidate states sorted by heuristic value, and only the top 1,500 candidates are retained (frentier candidates (:beam width]] }), limiting the branching factor.
26

---

Published as a conference paper at ICLR 2026
Pruning rules: Immediate inverse
skipped (if last and inverse [last] mv: continue), and already visited states are not revisited (if new.state in visited: continue).
During search, the frontier grows progressively with depth (c.g.. 12 + 114 + 1,068 candidates in the first three layers), demonstrating layered expansion with controlled breadth. Eventually, the agent identifies four-move solution, applies it, and verifies that the cube reaches the solved state.
Step 3
Thought.
Thoughts previous actempi failed not natch the anvireament. will new zobustly dedace the exact pernutation for each basic nove (P, B, beloze
the
crientations
did
signaluze natching: Ifll mulliple ramdonized sccetbles, and after asplying the nove, and then rocenstruct the Index permatation by natching the 8-length color orientations. learned, 2/11 porforn houristic bean search etriine to find solution, then apply the nove sequencs verity.
independent
permutations
solved, 1'11 call (""
Code.
import import time
utilities
inverse_neve (MV)
return mv[i-1] id my ww.eendvvit(""") else my
def apply (seg))
segs
nake_nove (n)
def Lnvert_seg (seq]: [inverse_nove (m) xeversed
def dedure_novs__y_cinneee wtw.oo/ww....cttaurrereeeee
seremble_len" 1en-12)
Ensure we start zron known base and return to de atter caon triai and at the eno. based get_observation
lie_ -
post_ 11st
Alllvdd neves for scrambl novws 112', "B", 1U', 'D", "R", !L!]
all_novas moves [gante for in neves]
for in range itrials):
scramble []]
for in range len)
while
rendon. choicee (all. moves)
if inverse_ntve continue
appandd
last
Aoply scranble
apply_soq(eerrmble)
s_pce get 1b
Apply the
leezn
make nove (neve)
aove
make nove (inverse nove (nove)
sccamble
apply_seq (Lavortt_egrcccrrrreet
Viriiy secuzced to based
it pot_otsorvation) In basc0:
print ("Kazning: misnatch acter undoing scramble during deduction ot", movel
pre_i1st.
post_ ts_pon
27

---

Published as a conference paper at ICLR 2026
Bulld signsture
each
pro_sigs " ("".joinipreli1 for pre in pre lie_i for range (911) post_oiqs ("t.joon
post_ilscs) for
Map post fndex to index euch that signatures aaton peen [None]+54
Ralld diet From signature indloes for sig_ta_
for in enunerste (preeeerrggeeeee sige)s
iog_to_indiow seldefauil (eig, I1) (1ppandd))
arbiguuux []
niszing
sig cnumerate spost_
candidates to__itos (sla, II)
(caadidattes)
pernigl cardidates(()
elif (en(ddndddaltes)
nissing ajpend
anblquous, appand cand:daces))
if nissing oz ambiquous:
additionsi trials discnbiguste excza
while (nincing or anbus) and extra rxt
8 Do one extra trisi
xcranble
for in [scranble_len]s
B. zandon, wwo.ccccccc..o randon,chaice (ali_noeeee
Invecse_novve (last)
continue
aopenel..appenddmm (m)
12st
apply se..eegssoee seg.eoraabble)
s.rre (sservairva)))
make move [rove]
R_pust gel_cboerval
nake_move Haverse_nove [nve]]
apply_aeg (lavert_ (scoaaaaall pra_list. append (a_ore)
2 Recompute aignatures
pro_sigs 1"alao="""o [o".oointp
pro_list) in c2ng
post_ ["*.join 11 for post an list_ for in range 1551] siq_to_iadicss
for i, sig in cnumerate(pre.eet siget
sig_to_indicws.co weddi (agendddd
pern x54
ni missing-
anbiguous
for 1. sit in crunsrate(port_ptige
candidacea siq_to_indios (sti, II)
if Ien (candidates)) mn 11
pern(a] condicates(
elif lcn (atasidatss)) mn 0: aisoing.appendii!
elxe:
ampipooss.appencccc (13, candidatesi)
missing anbiguaus:
print (f"Could not uni uniquely ly deduce nappiig for (nove)- Mi asi age ( mmianingt anbig dubigauusellee (unbiguous)
zeturn None
Validato by applying to fresh anapshot stsevvstrttti
nake: mowe (nove)
nake nowe nowe (inverse move (noee])
Pulld sinulated appilcat Zon sim jo.join (base/pern(s]] for cange((5))
if xin I- wir
(2"
[move].")
zeturn Mone p0zm
aove parmutations
28

---

Published as a conference paper at ICLR 2026
"D", "B11
perm__o 13
print LLeazning permutation tor", mV1
deduce wiy.signttoremm trielse), voramble__ennlll
ix p is None:
print ("Pailed to learn nove:", my)
Try aecund abcempt moze Ledala
dedoce
signature (mv, trialae10, aoranble_len-i
P None:
print print ("Giving up nove:",
parn [av]
if ler (parr_naa)) 1= print ("Failos
pesmutations. Learned:", deeeen_mpp.eeee.oe
else:
Bulld
perne
def invert pernígerm::
[4]
for i, aze a
zeturn inv
parm_nap parn_ [avatt_.err//eennnsssloloo
def sin sin_apply... staat__tttteee
state lstate, nove)
pernunap [move]
return ::oinictaae/pprmmlll [per][]]] for (ong
Solved Lazget solved *RAA9 notig 1BE49 tyPeg *oPk i raru
def houristic (State):
Simple facelel: atanatch
zeturn sumil for c,ch in cnumerate (state) if ct. soived(4:)
Boan scarch
all_moves moves
noves]
inverse In: minte for in movesl
updesse.
in moves])
gel_cloervallinn
if start solved:
else:
1500
max_deoth 20
trontier letart, (1)]
[start)
best h seuristic
print ("initial hearistiess ios", best_h]
sal pwt. None
for depth in zange [1, mox_depth+!); candidates
for state, path in frontier:
path[-1] path
for in all_novas:
[Last]
continue
nex_etate wiw_apppy._ttteeeeee.
if new. state in visited:
nen_path state)
visited.aniires
if nex_state solved:
sclved_path new_path
break
houristie
candidates candidatess.ppend oppend (h, nex state, new pet_pa)h))
1f solved_path
None:
break
if path is not None:
print ("Found solution of length", len lendeelved_pat path))
break
candidates sort (Key-lanbda [XI9], (x(21)))
Front les Iist, pi for (b,, xt, in (bbbens
print (C"Depch (depth): Zeontier=[1en (1on|(onaaa)))) best_h_so_fas (ain (Brrrs) candidctes), defoult defoult/bost_hn best_hii"" fconcior:
29

---

Published as a conference paper at ICLR 2026
break
is Mone:
print (*Beam. seazch did not bind a solution."
elae:
print ("Applying solution:', ":poinioooved_pptt)
apply ved path)
Cinalattaee gel_obaervaion!)
grint ("Final states", final, state]
finelatate sulved:
tinal_answez("
prinz ("Solution asplication did not reach solved state. Nlamatchos:", hoursstiortinal_sttee)
Observation.
Learning permutation
Tearning permotation
Ieazning pecmutation For Tearning permotation Imazning pecnutation For Learning peznutation
Initial heusiatie: Dopth frantieze12, bost_h__o_far=3:
Depth 2: trontier=l16, best_h_co_ter-22 Depth
Found solution of Length 6 Applying
Final stale:
Solved.
L.2 BASIC AGENT IDDFS AND BEGINNER'S METHOD
Model
Agent Type
Input
Reward
Depth
gpt-oss- -20b Basic
Full Symbolic
No reward
8
In this case, the agent first performs depth-limited iterative deepening search dra tdepth, nex_depth, face) systematically explores move sequences, applying each candi- Pruning strategies are directly reflected the code: ie last_tace is not None and tace_ot cmi -- iast_race: continue prevents consecutive moves on the same face, and is_inversa
date move with asplytm and backtracking via
is used to avoid immediate inverse moves. Early goal checks ( le s=__oavod__tattt/petoooo (pet_obsorvatiean) terminate branches once a solution is found. Iterative deepening is implemented by looping depth limits for range (nitt depthht
Unfortunately, several searches failed. After a few failures, it attempted a different strategy.
In its thoughts (Steps 8-10), the agent correctly outlines the sub-goals of the beginner's method, from building the white cross to solving the final layer with OLL (Orientation the Last Layer) and PLL (Permutation of the Last Layer) algorithms.
However, the agent's execution is undermined by subtle but critical flaw in its internal world model-an an incorrect mapping of the cube's indices to its symbolic representation. The agent itself explicitly identifies this error in a moment of self-correction in Step 13, noting that "earlier mappings had mistakes." Despite this high-level awareness, the cognitive load of implementing the entire long- horizon plan within a single, complex code block introduces new, unperceived errors. The final outcome a failure, where the cube's state no closer being solved.
Step 4
Thought.
30

---

Published as a conference paper at ICLR 2026
Thought: The previous sesrches
inefficient. xill attempt carefolly pruned iserative despening search up ta depth uxing reduced move set that includes quarter and Lurna, early gosl checks at every node and strict praning Ino repeating the inversed). should keep number operations nanageable. will be Zound and applied direccly the real eober than will call anseer
inmediate sclution exists within noves,
Code.
Dept fieited ropes with proming early phesks.
# Usea noves including half cazna (2mp2onsntedd as LwD quaztez Luzos).
from time import Linw
def Vs__eolved_staaee
for ailic 'g" for an 5[9:181) and
and
ailic 12" for a[18:27]) and
allic "y" for an 5(29:35]] and
alllc t0" for xf36:4511 and
allic 19" for in o(43154]1)
a.ac. get_
is solved (start):
final amsees
else:
Derine variante with hair-turae
basis_faces 1B, 10,,
for in sasic_taces
moves. aprens)p
moves. (t-*1e]
append
Relper to apply and undo mover in the environment
apply
if n. endaxitaa
nake_move [Sace]
[face]
elee:
def undo in)
if endesii ("2")
taze m10]
make move [face]
nove [[ave]
else:
Znveruw of x X inverse if n. endoniichhh")
nake_nove(((0)
else:
makc_novo(m=r1ng
def face [m] n[3]
def is. inverse la, El:
swif
it a001 1- b101:
False
i8 e.endaxith (22%) and ands
18 s.endaxitaanmmy and (b -- a[01):
18 (a =- a(0]) and endswsth and (b[3) -- atol):
return Palse
nax nodes 330030 sateguard againet excessive search
node, 3
found
solut
def dEs (depth, dax_dapth, last_face):
nonlocal aode_count, found, solucion_pati.
it Cound:
nods_count +
node_count nox_nodes; return False
31

---

Published as a conference paper at ICLR 2026
Barly
evezy
it is_ (ptt_ooservation11.
return True
if depth -- depth:
return False
for in
peuning: avuid cepesting dade Grow consecut ively
if Last Face not None and face [m] last faces
2 oruning: avoid innediate inverse aich provious nove In path if exista
prev solucior_eathf 21 selutton_path else None notez ue append Sacceas;
prov Is not applicable
Apply
apoly (n)
Isepth+l, nax_copth, tasc_st (m))
eo solution path, sppent (n)
Racktracc
zeturn Palse
Itoracive deepaning up to depth 5
time!!
Limit_dapth
in [1imit_depth+]]
if (0, d, None):
break
Ie tound, the moves lesoing to solution were applied in-place during recursion. if Found and ix_xolved state oobeetntttetttee anave (**)
elas:
print Bearch exhauated (nodea- (node_oouni)) J). Could within depth ddepit_
Observation.
<dilled by the Pythen interpreter> Maybe there infinite loop sonewhere in the code, you're just eakingg caleulate leulations.
Step 5, 6 still failed. Changed strategy at Step 7.
Thought.
our previous hrute-fores search approactas hit interprater linits. I will now implenent seterministio, stop-by-step white-cross builder lbepianer's method)
Thought:
Anelyses the current state string (observat intevation-tyye ton-type is state state_string!. with Applies targeted moves to:
Locates each
color).
Life the white edge Lo the 0 layer with white facing using single face Lucns.
Rotate (and when needed! to aln the edge above its correst face.
Inawst with double face Lurn (X2) place is cusreally in the D (shite) pross while keeping previously placed edges intact.
will implament cobust napping edges 1/11/12, 0/2", b/ar). will repeat for the cour target white edges: MB (tc EDI, MY ito BD), m0 (to Atter beilding I will call sinel_cnswer("" It not, can procced surther in suasequcat stops lzut for now, tey to stage.
orly simels, noves (8/51/32, R/81/B2, B/B1/B2,
crose,
already
get place),
Code.
white croas acep-by-atep using Larguted noves. Facos and conters pez the problem: (tront)
9 (back) Green (G)
(lett) Blue
(right) Yellow (*)
32

---

Published as a conference paper at ICLR 2026
[dow)) Wnito (N)
Helpprr Apply nore, deuole move, inverse move def do)
nake_ (m)
[abel
nake nowe (facet make move (Face)
def Lcv (m)
zeturn mls a.mudaxcihh()))
return (allic 18" for in a[0:9]1 and
allic for s[9:181)
allic 18" for ån s118:2911 and and
wllie for
alllc r0" for ån a135:4511 and
<ll1e for 5445;54]1)
Centery indioes
def concers_of (state):
return
t2": state[4],
3 ahould be '2*
ta": (131,
shouid '6*
11' state (221,
t shouid be '8"
(811 (311,
'2"
19': state (401
t shouig be 'g"
10f: s49t
ehould be '9'
Adgg napt
([Cacel, idx1], (Cuce2, idx2))
adee_dofs
1UP": (C"01, 42), (1F), 113.
TUR1 10"0' (1), (TR', 2831,
rUB": (010% 39), (1B', 1031>
'UL": 10"0' 39), (122, 1931,
"ER": (CTE"
(TB', 3031>
"pr 1C'F 3t, (55) 2331,
"ED": (CT5
(TD', 6611>
(CT5, 323, (BB) 1231,
34),
1281 1055 21), (1B", 14)1
(015,
48)1,
100" 10751 15), (1D), 52)1,
"0X" and "XD"
UX ot 17F1s 10F1, 18'2 YUR', 'Bt: 1UB1, 1515 1061) XD_ot 1'F1 1FD', 'R's 'BD", '81 1BD1, 1212 '1D')
# Rot of that eycle DF 502 >09 302 >DP and 3ikenize the edge 0. o_eycle (10F', 1UR1, "UB", "UL"]
# Rons of that opole Po 31D 380 380 WPA under D1 cenottrcclookwieee 220 3RD 2.D0 XPD under
D_cycls_closawicc I'ED', 18D", 180", "ID"]
# Aciper to read current staro chaz at givon absoluro indox read(state, return state[idk]
def get_ edge (staat,,,,,,, edge rame): 11), (t2, edge_dets redge_nane] return (statelil), stateli2))
def locate white edge pertner partner_coloris
Reluzns tedge,_nane, wheze, sheze white (6, Indexes whilch the Lwo stlkuwee white
in itwe
sl, o2 statelil], state[:2]
(al -- 'X" return name, 0
partnes_ccloo1:
(c2 -- 'X'
partnes_ccloe]:
return name,
zeturn None, None
RotwEM Llows (k in (0. l_t (K)
Eor in range 4) do("0")
Rotaco clockwise
33

---

Published as a conference paper at ICLR 2026
def D_times
for in range 1K 47:
do(1D")
be et specl posfic fon by rotating def align_ Woogge_ pogo_to(statee, edge_naaee currenty torget_[X) be of U-layer 10e1, FOR foRr, 100
Al ign (1- d-lagerr
cospace offset
our ide "Leycle.indees (edge current]
igt_ide "Leycle, index [1X
(tst_idx cur_idk] 4.4 (_tinea(k)
D-iager edge at speciric position by rotating aus__rans_curente target_XD):
def alian_P_edgee aiien_p_edge_torabccc
cur_idx P_cycle_cioccioe wtw.seeeee.nndxeeeeee..e wewpeidegeee_ecuueeeeeee sgt idx = "_eycleecllll clockeise se indexitarget
(ktimes(k)
Given an adge in the aiddle layez, lift it to wich white sticker on using singio nove. def Lif._niddil
nage, thite_on__faee white_en__Face Ia 1P", 181, r8 121 zepresencing which face helds the white acickez for this adea. the turn moves the layer with whito
For middle edeo
if edge_name =* "FR":
1812
("E"")))
elif
d*R"
alif Hdge HPV1
ahita_or__Face 1p1
Fn do (*L!))
wdga nane if shite_on_face B72 (*R!*)
ellf white_cn__ace 1211
alif edge name 1881S coito_on_tace do ("I*)
elif
do (*B
Not middlo odge
U-layer
sido,
wdtch using single
def drop. weteeeettteeeeeeeeeeeeeeeeeeeeee Dletate, esge neme, white cere__oo_tttre tn_tec)) UR, 057 shite_on__ace if edge edge_nare name *Up* and whate_on face 121: do("P*)
121,
elif edge neme 'UR and toc_tee 'R's
do("
edge_nane 106" whise_on_faae 1B": do
edge_nane
whise_on_face 1D"s
"o'""")
# Bject from D when white da side: bring undor that faco thon do that Zoco" to bring to middlo/U eject_ s_side___eee_eeeee__eee__eeeeee_ white edge_nane, moitt_or__aaelll
edge name in i 19D1, 1RD7, 1827, 1o't, white, on fane in (PP, 1R1, 181, 1817161) sticker
rotate
oring
that
target whitt_oon_ face Face 1p"
Aiign_D_w@gelloocaaaa adge_pane, Largel)
New do the Lnverse face to wove the edge up inco the aiddle layer where we can Lift It In nexe slepe
do (vvhitaa_on_facs [1P]
# Aftor white adea is on D. faco with white up at sone Ss, alien above ies target faco and insort with
def insert fron white up letate, carget_faceel facel:
target_face 113 18", 'B",'s, (1*)
Being the white edge to UX poeition by U-curns, then do target fece?
know curzent UX posst lon, find an edge in 8 leyer:
Fut ve ostl this only after aligning with previsus helpersy safe to rotate 8 until the parener color aligns with carget oenter
adga is Decernine whichh (X curzwatly holds the (6, partner) edge
axolicitly zocate
desised_edgo_nane (XLo[[tarqet__aes
Find the current p-eage Zocarion of the piece with celors (R, coscarettarotttees) oet_abaezvation)
34

---

Published as a conference paper at ICLR 2026
(stato2)
partner contersitareet_taae
Find Unedocs
oupositions ("DE", "UR", "UB" TUD"
None
shore_Nhite None for in poxpitionnn:
(CI, il), 112, [dgn
c1, 62 state2[i1], state2[12]
(el "g"
partnws]s
cuzrear_2, vbaro_Nhita en, 21 8 whico on 22
break
if (o2 on 'K' and =. partnez): ourreat_9, Whoro_Nhite Cn, 22
break
current_s
return
bring (Lapottaree
elign U. ULeige_to (stacee,, cucrent in desired edge namel
Perforr double do2 (tarqet__face)
Enswed
Main shite cross buiider def besis_ynita_croor
Process tarqeta in ordez: F (R), R. (0), (0), (8)
1"E", "E',,""''""", (210
nax_outer_itere
crder:
iters
while iters 40:
iLera lone
oLe oenterssoofatt
paztner etr]face] desized partnor color for this adge
ii already solved
cuezeot orientation
xa x0_of[face]
11), (E2, [xgc_cats[xd]
ei, c2 st[4l], st:12]
Decormine orientation
wnite position?
if tel -- partner and o² -- 16'1 or Ie2 e- partner and al 1871
Andicionally ensure white on D (1.00, index corsesponaing
this XE)
For xn edge, the pair ie (Facey fdx Facely 10, didee downt, The D. Erdex may be either 11
Idaacify which is D:
'D' Solved chis
else None)
if down_idx is not None and at [down_idx]] 191:
break
Othervise, locate this white-partner edge
joctte/hite.coopppaarraaae partner)
edge name None:
Should not happen
break
Dacoznine which faces stdokera left, cil), (af2, 212) edac_dots [edge_nans] coll, [tflll, [e12]
colora
Case handling
if odge_nzme in. (1U2", TUR", 10B1, Y0D1]:
Leyer
Tdeee ffy where white fas on 0f or on xide
xaite_on
if stilll] 1W':
whiice_on afl
alif at [e12] =- 18":
whille_on wf2
1f white_on su "Dts
Rotate DX and Inswet with fave2
tst, (sco)
else:
White on side face in D Jayerr drop to wieh single nove on that face wbite_on)
dcop_U__ids__hhice
1PE edge nane in I"FR', 1P61, 18B", (18"):
Riddis layerr 3252 wich white on 7
white on Mone if [t[l]]] 1W1:
white_on allf stlm12] =- 197:
white_on
iift_nidsie_w:htee.c www.w_wootoo_eeeeeeeeeee edoc_rame, whito_ca)
edge_nana ['FD", 1801 18D1, "ID"):
35

---

Published as a conference paper at ICLR 2026
Retermine it shite de on 0 or on side
None
if stleil] 'W';
white mfl
elif ctiei2] "3'
white wf2
whillaonn
Rotate bring under target Face, insert wich Face? ouerent_xd adge_nane
aiior___odde_too curzent_xd, XD_of[faca]) (face)
else:
on layert esect up
oo edae_rane,, shite_on)
Should not happen
pasa
Next
target
End
Firet, solved already, finish
a:c vet_obseevatteer) is_solvoii_ttteesttt) (asva_an
else:
Pulid white cross
besis_yhite_croes
Check 1e solved by chance, eice coatioue leter
get_chrervation ion
Finse_ (**]
Print progress: show curront state to proceed next stops in scbsequent icoration print seliooggllbbee
Observation.
Step 8 Thought.
beginner's mothod. airoady boilt zoward whito cross. Next, I will insert the tour white corners into the rwhitel layer without dis:urbing the using standard triggers:
xill continus soiving
For DER (trom UZB3 : Bt D
For nRB (From U3B)
DBL (Erom U3L)
For DLF (From ULP): F 1* J
I xill:
Dafine coznez indicea.
Desect each tazget white corner by its color set (W, (faeel, (daco))) bring
tound
eject corseeponding
trigger until it pops to U.
place target slot, apply the corvesponding trigger
repeatedly unt solved.
bepeal all
solved, sall Finel_
Step
Thought.
I will proceed with the next stage of the begiarer's mechod: solve the middle layar adges (sacond layez) without disturting complesed white lsyer. will: Tderti-y mi middle layer target eeges (FR, Pl,, RB, 18).
36

---

Published as a conference paper at ICLR 2026
U-layer
contain colors (1.c.,
It no such U eages exiet, elect en incorrectly piaced niddle edge to the 0 Layer, ther insect correctly.
xill then print the updated cube state for call (nsverr)))) it by chance the cube becomes solved).
Step 10 Thought.
The cube has the first two layers solved. will complete the lest layer using begirnerfa net nethods oll: osient J (Orange) edges cress using the F3UR sequence with persect D rolationa; Lhen orient cornars using Sune/anti-Bume until
stickers Crange.
FiL: firat pernate matte corners using dr 11 0 at ur Ly then pezmule last-layer edgea us ua/Ub permutacions. will implemant helper checks
application with inverses so zovert it quess doesn't solve. I'll chock ter solved atter each. otage and tinich with tinal_anexee("" is
Step 13
Thought.
I will correct the cube indexing for eóges and corners (earlier nagpings had mistaket), then run Full beg method pipeline: build while firish: with ouD and PSL, I will expand any 12" terns into two quaster turna so the environeent accests then. will check for solved after phase, sulved any point, will immdiately aasai_answes (*").
while
giddle layer edges,
Code.
Corrected, end-to-snd beginner nethod solver with accurate index mappinge and sate *2" expansion.
Helpore and Mappings
do (n)
Papand #24 nevee fnca
('
4 a[3]
nake_nove
nake_nove (f)
make move (n)
def do2 Facel:
nake move (fecel
def states
for
and
allie 16" foz in a[9:181) and
ailic '2" for s[18:27]) and
allie ry* foz in a[27:38]] and
ailic 10* for a[35:(3]] and
allic for an a14o15411)
def centers of (etatel: return
12": state[4],
181: state(13 (131,
11" state (221,
18"1 state 7 Y
10": atale[40], 3
10"1 (49],
edge insicos on provided nec
adge_ defe =
37

---

Published as a conference paper at ICLR 2026
1051 1010 63, (1B) 28)1,
ruer: 1000, 27)
20)1,
1007 1010 39) (33 2911,
1881 (CE5 Str (RR) 3011,
"P (CPP) Sty (5%) 2331.
nat: (CRR) 32), (1B), 1231,
rarr (C15, 213, (1R) 1431,
1001: (C'F) Tr (101, 6831>
100:: (CRS, 34), (1D), 5011,
180": (C'B', 18), (10), 5231>
1025) 25), (1D) (8)1
Correst corner indices
UF81: 1 64), 22, (181,22))
[atar, 38), (121 (161,))))
1Us': (1),,,3),,13 (31, (121,111,,
U [173r,42), (20, ('P1,)))
1088: (170",47), (1) ('8r,33))
"DR5' (12"",
1Da1's (1) (12,,,,)))
"DLF'S (1'2",53),,111 (42, ()
# Cysles for 8f and D layer edges ULeyole (10P1, 1081, "Un", 'U1.]
D_oycle_ow (1PD1, 160", "BD", "ED!] Undez (slosknias)
WX 11P1 10F1, 181 YOR", 181: 10B1, 10te 1001) XD_ot 1111 1ED1, 1872 18D1, 1812 1801, 1016 1101)
def ULtimes (K)
in zange
(x)
for in range ik & 4): do!!n!)
def ign D. wdge, (statte,, cur edge, sarget_edgell ci (_eycle, index (our__dge) :1 0_aycle, (creottaare
U_times (K)
def alien_D_edee__t (staae,, car_edqe, carost_odge): ci D_cycle_cw, indexieur_odes
si b_cycle ow, edde
=1) (k)
def get weweeedeeeeeeeeeeeeeeeeeeeeeeeee cstare edge_rang rane): (f), 11), (E2, 12) adge_defs (edggeeemme)e (statelil), state!i2))
locata_ahite, www.ahitooooppsttteteeee (state, partner_coloc)s for nane, (1f1,1l), (f2,12)) edor_defs.itomd
fl, state[sl], statel:2]
if :l 'W" and cz en partnor_color:
nane, if c2 -= 'N' and el == color:: name,
return None, None
White Cross
def Aif__nitdll_vatte__tt (sttat,, edge_name, chita_on_facs): with
if odge_name "FR":
1Fts do("F"")
elif white on_ face 1811 6o1"
clif
white on Face 1p's do("P")
ellf fhit 11:: dol do1"!"")
elif edge neme 1881s
if white_on_
181s do("R!*)
fhit
(*3))
#Lif wage (LB1s
shite_on_face
do("1")
elif tnite_cc_face - 12"1 do "3""""
38

---

Published as a conference paper at ICLR 2026
def scop____iie__aateeee
whits_on_facs):
if edge_name 'UF" and white_on co face '211 do1")")
elif elif odge_neme 'UB' and white
'UR' white_on_ on_ 1B's do("
(R's do("R")
alif edge
NN and whise_on face Mils do(")))
Faccil def eject Duxide (hite edge_nane, white_or Facel:
Largel Fai
align eöge, (o(saat,, edge target)
inaeci_ B (slate, Laagel__ave):
desized_u [Xcc[ttarcct_aae]]
@et_sbscrvation
centers conters_of(st2]
partner contera[target_taee)
current None
"Leycle:
(fl, (52, edge defslenl
st2[i2]
it (el -* "W" and == partnes) OF (o2 =x 19" and cl partaez):
if break
zeturn (_ti__ do2 itarget__aaee
desirod_a)
def build white Maiila_witt__croes5 cross!)
order ['P', IR', TRR,"R" 185, (M1)
Jace ordee: for in range (60) (50))
gel_abaervationn)
etz ccaters_ofiee
paztnes ci:]face]
7 Check 1f soived at XD (bhito indox for that edeo)
xD_ot]
1I1,11), (f2, adga_dafa [xd]
'D"
12
if idx is not. None:
((ct[il] partner [t2] 'W' 1st pastnor [11] (W1)
st idx] "8";
place and brntede
3 Locato tarout edge
pww. (sb, pasiner]
if on is None:
break (e1t)ell), (o12 [dqe_dets[an]
Decornino white
white etl if st(esl]
else let2 if stlei2) 'N" else None)
t_cyclo:
if white_on 'D";
insert_ froert__roo__Lubiieeee..
Face)
else:
drop_ whittee_htttttttttti
chita_on]
on [1ER1, "FL', "RB", 11B"]:
lift lift_nidsie_win htt.moooii_.tttcsc__eee... ca, stitc_or)
D_cycle_ovs if waite_on mn "D'a
Lligg___ecge_ttt en, [tacel do2 (faco)
eject di white(ss, en, or)
a.c....*.n Whice Corners
def get get corner do latass,, name):
Laple(state[ddg)
def
return set cot__corer_cooozstsaae nane]]
top oppleyeleee. ( 'URB", 'UBL", 'ULP")
['DER", 1083', "D2L', 'DIF!!
def totootop (ourrent_ Lepg)t_bop): oi top, sycle.indee (ourrent (tpp) top) si top_oyele. index (Laiget_iog)) (iti ei)
coto_do (cursent_dower targes_down):
cl dexn_sycle, crdextccrrss
:1 doxn_tycle.c (croo
39

---

Published as a conference paper at ICLR 2026
(1ti
def wow.errnrr_oovvdeeeee
miite on tace and other two colore naton centers Faces for fr.. in corners [name]]
iaxs [1 for _r1 in corners[name]
None
antamrate (
if !af:
break
dLpus
retuzn False
stase [d_pos]] WW1
return False
contors_oot (state)
for i, in enunerstt (faces):
13": continue
if statelidks(11] 1- ctrlf):
return True
triggars
"DE81 UERR' 'do": lambda: (18)) do(")1)), do (llrrriee
"DRB1:
'do"s lambda: (de (1a)), dottor), do(rart), (otrreries
"DB1' 1: I'tppfruue 'do": lambda: ("D") do("t!"), do(') ((llnaroo
"DL''
l'tpp' PUUE'' 'do': lambda: (do 1795%) do("t")), so1')), 1iliia
daf Find gorner bol.elo (state, terght_.et);;
nane cornera:
if corner_ col (state, nane) ee target_aett
return None
def cjact_aavs_ccomae (slot_nandl:
tzig (al_ggereeloot_ammoo [' ['6o"]
for in 13]:
trigi)
cort__occonccccooooo.... :arget_set);
cop. name triggersia rame:elllltttttllllleeeee (ttop)
..ig Lriggers(slet__nnn// ['ds1] for in zange
gel_abaervattinn)
i2 to_corner_scived (st, slot_name):
pos Lind_ooreer_yyycoosttt. carget_set!
return False
to D_to__dww, commerrpp,,,,, name)
olif pos in top oyclee
O_tn_top_oeree trie()
top_name)
else:
Lrio()
return Folse
def solvo_ wtt.tttoooooocssit st get (et_onservationn ctr centers_.o
sargete
(1DER', 1'W,, str["P"), 19.
(1Das", eR. (1
(tDat, 11W,, etritht], ct. ("DEP', e 11
Largeta:
for in (En) (et_otseevatismn)
is corner solvedist, sleti:
break insert cornerislot, tset)
Riddle Leyer
tiqht_oZiface):
return 1'P1 182111 1B1 111
def of (faze):
zeturn (' 151 1BTETR", 18"
40

---

Published as a conference paper at ICLR 2026
def it_nidele__dge httpile_edd__ooeesstteeee polveeissttss. sict1:
112, (52, (slo_
cl, 22 state [1l], state[12]
centers (state)
return 2l ctr[ti] and c2 ctr(e2]
any wwndlllw.noolvdeedeaaee
return not Hi' middid edge wot.e.ooleeddtteeeeeoeee 1p21) and
(I3")
(LB") and
(FL")
rind_a_ede st__de_candssssssssseee for en in "_eycle:
(11, (E2, esge_dets(en]
cl, o2 statelill, statel:2]
("Ot, (M1) (101 1912
continue
return None
def Find_aLadea by (stata, colors_aat);
"Leycle:
(1I, (2) edae_defaten] ((state(1)), state[i2]] colors_set: return en
daf Insertt popettmmiie middiee flon above (Front__ face, directiar):
direction "right';
of
do(101) do(ef)s do(torr); dotati"!)) do(rott)); de (aee do(101 (f
else:
1eft_ot (front_facea
do(")'")) de (12-"1")) do("U!"1) do(12)) do()U)) do (aroott_tccal) de ("0%)) do (t
def incoct__ccccrrrtt_. riddle (fron=_
insest_miosie wewoddi_tttot____ LLo____oboveetrree
"eigat!!
soive_midele (
for in 130g)
get_obbeervalinn
it not any_naiddiounnolveeee
break
st cet_obaezvation))
on find____ddpe_aadi dat
None:
side_mep ('UP";"F', : 106//100
It1,il1, 112.121 edge_cets
if fl -- side:
side_cclor st
up_coler [1[12]
side_color st:12]
wo_coler st(ill
tazost_fron: Mone "R', if ctrif] cide_ccloz: target_tront break target_tront dol Bnl'g)); continue
gel_claweval
dor find n edge by (st2, set lssidee_oooor, up orlor))
do (11))) continue
-lign_0__ee Lo if cte (ronce_ ss us_color:
'rigat")
ctrileft of frenc) up. color:
(lett!)
else:
S01111)
else:
aat.aaddd_ddo_eevvddeee *E3"):
eject_ inpersett (iddll
1881)
Ancorsetc middle(1B")
ja_niddil__dde_oollee (18"):
41

---

Published as a conference paper at ICLR 2026
<jert_inerroct_piddll
elif not is_nidalc Logee_ soleessois,,,,, 1ED1) <ber__toerroct_pioll((1f11
Tast layer (006 PMy
0. indices (scaa)))
41,
return all (statelf] 10! For in (_indioes)
def (staate))
zeturn L'Lopts [Lal Niff''s stalm[391, Trightls acate[41], "bettonns aiatw[43]]
"Loross__rragge Istate):
(eedacstattat))
al'top"/ "topp""""""" c["latt") of ('"right"] "1otor el el"totton' 1-100
def [ellve_pll__ddexxd
FRURUPP 19F", *RO, 70%, "R17, r0rs, *prx]
range
st qet_ get_obaervation))
return
Elaqa [200: (001==1or) for pos, in a.izema 1)
if ont 01
elif ent
if [lagel"llft" and Flags("right
doLseg
wlif Flage (ttpp!) and flage ['botton"]:
U_tinea (1)s do_aeq (FRUROP))
else:
in cange (4)
st2 sbsaraaarvs
u_ndges
if 62 coppt "o and o2 "2["lcft'jont0
so_seq (FFURUT))) U.t timett)
do Se..eegiRRRRRP
def aclva_oll_pozne 13
[*8", *RU POT, R02", Harng
antisune trarn, ngnn, *RT, my marn, 1U27,881
st get_observation
return (znge(())
st get observation)) if [2] 1c":
do ro_rre(suuee:: break wlif [27] I0":
do_oeg
clse: do 1111)
edges_u Uop
"UF": (0101,431, p25,13
"UR": 1C105,11, (1812201),
rpat; 16101,371, 1011, "UL": 19705,91, (11,1911,
def edges in place (sttatte centera_ui (slatt))
for nana, (1fl,11), (22) in edoss_tL_tpp itans :1: 1- [C2]
return Folse
def wwtps_sscooococeooeeeeeeeeeeeeee www..oooccc_.ttccsstttt..o. semer_nane):
faces for f. in cornere loorner nane)
Ldxx for in cornersl [ame]es_name]]
ctr centers letatel
for 5, in xiatEasss idsa):
!g":
if vtatH(il otr(f);
return True
42

---

Published as a conference paper at ICLR 2026
def ell_porners Ltl_eornors_aa__lsee (state)
return all (ootner_ pideerrsddddoo.. cide_coloree ars_nnattii (otate, name) for name in ("UER', "URB", "UBM", (ULE1)
cozner cozner_cyale (1gh, "By, nynn torry ton, "Brn, (Dr)
(MR%, ayns, 185, noy, far, 10t, ran, fign, tass, surt, (R25]
Ub (*R2*, "0", (Ry nory TRT tor "Brr norr 1Rrh tor, "R"")
wolve_pp1 pow
for in 1121:
gel_.obaervattonn
if ssi_eernrss_in_paacc
tzy to position COFFOCE corner UFR
(i):
st qet_otserrvtiian)
cemme__sss__0laarcaaacctto (UER))
break
do(' do. (eg.eooorre...cllll
def Lnvert_nova tn)
if hrendwwch(""")) return n[:-1]
...
def Le
return Linvert_ move (m) for n in (eversed(eeg]
def ery. he____dg__eeem_cc___ (eigg:
(n
at ()
if is_xolved st (stt
in.plainn pok_top(ssh
return True do_ (Lnvert_ccq//aag)
soive_ppi__se (1
for in range 112):
(et_obrervationn)
if edges in place toges)to
for in range(4):
if txy_edro_ zeturn ('(')
Ron tull pipoline
520 (at_oascevateen)
is solved. state (st0); cinal_anowor("))
else:
1) White
build white_cross/ if wtw.:o/weeLetttlggeeee.eeeeeeeee
ainaa_anavez (**)
2) Wbite corners
soive_whitc_coonezza
if =inai__nneeez
3) Midsle layez
soive_niddil__epyee
if ie_
=inai__nnswez
4) Tast layer
selve_pl Solie_ool1_.0 coweollooorres
solve_pli_cuzaees
solve_pli_adped
Allga check
for in zangel0];
is_solvos_etata http://ttttttpeeoooooeeeeteool
finel ansver("*)
do('
st/il not rolved, print state for further iteration print (1)
</code>
Observation.
43

---

Published as a conference paper at ICLR 2026
L.3
BASIC AGENT BRUTE-FORCE ENUMERATION
Model
Agent Type
Input
Reward
Depth
gpt-oss- 11--bss--12bbb
Basic
Full Symbolic
No reward
12
This case demonstrates the behavior of less capable agent in a no-reward setting. The agent exe- cutes up to 20,000 moves, selecting each move essentially random, with only minimal stochas- tic backtracking mechanism (5% chance of undoing the previous move). There is no systematic planning, pruning, or search applied, and the cube remains unsolved. Aside from the stochastic backtracking, the agent's behavior is equivalent random walk over the state space.
Code.
import randon
Koves and theie Anversss
moves [*E", egrn, TBr, rart, nLr, rarr, TB7, 18r7, 10r, 701 inverse ("P"stEtty ereny harnn "arnuna", "Lngtor,, torn paan "Rranght "arneta", "0"sturn, eorneron, rony "0n "D"nero*)
def [s_polred[staat):
orders FRONTHR, BACKHGG LEFT=B, RIGHT-T, OP-O, +M
solved *9449 i *o*19 *Br syeug *0nL0
pccasionel aoceptance max_stops 20300 sllow many noves kichin sineis cool call
Biavlated anmesling
gei_obaeevatiion)
is_polvedistate)
("Srrezd solved"]
else:
trax_steps!
solved (statel:
print ("Cube break
stop",
sandon, candom.chccow chicow
(soves)
make nove (nv)
nww_xtate (bleeeeeeval
for equal) houristio, keep it. No dea "t have direct houristic, so se just keep the nove most of the time, occasionally revert nove avoid dead-ends.
Simpic rulo: if nox_etate is sane previeus (unlikely) pevert, clse keop. backeracking,
probsbilsty.
keep True
candon. randon
na nake_move www.moow/iinveeee [inverse[ne]]
oet_obbervation
Zeep False
elas:
('Beached without solving. Final ataces",
Finai veritication
sanai_onswez1"")
Not solved.
L.4
BASIC AGENT FAILED PRUNING
Model
Agent Type
Input
Reward
Depth
GPT-5
Basic
Full Symbolic
No reward
12
44

---

Published as a conference paper at ICLR 2026
In this test case, the model implements meet-in-tlee tee-ii--theemiddee search for Rubik's Cube solving. The procedure first builds a dictionary of states reachable from the solved cube (build_goal_aa) and then performs forward search from the scrambled cube (forward meet in mi middle to detect an intersection. This reflects the model's recall of classical bidirectional search techniques.
The implementation introduces several forms of pruning:
Move-level pruning. Immediate inverses are skipped. (i inverse_nove (Last__nove) continue
These rules eliminate trivial local redundancies such as R R', or U'.
State duplicate
elimination.
Both functions maintain
visited set
atw_ visiceds continue
prevent rediscovering identical states along different paths.
Despite these measures, the pruning remains insufficient. Move-level constraints only remove redun- dant short patterns, and the visited set curbs local repetition but cannot control the exponential growth of unique cube states. Indeed, even at depth 5 the algorithm reports over 9,000 states in the goal-side map. Without stronger heuristics (e.g., pattern databases or domain-specific evaluation functions), the search rapidly exhausts computational limits without finding solution.
This case illustrates that while the model can recall canonical pruning strategies, their limited scope fails to achieve practical efficiency in large combinatorial spaces.
Thought.
The previous sezrches exceeded oparation linits. will switch to toe--ln-the-iidds soazch: reachable
diet nove pormatatianal, stering the saquances fron solved to each state. Ther breadth-rirst intersects the ccal-side dictisnary. if so, consaterate the formard path with the inversa of the goal-rids
within depth bye5 luxing the leasned
the current
Jonb, checking
node
obtain full saluticn.
Apply the resulting seguence to the real cube using nake nake_nove, nove, verity if solved, and it so call
ssaa__answer)"")
This approach keeps expanaiios nanegeable and avoids recuraion long ronning loogs.
Code.
import tine
We these exist fron earliers nove,, pppay_ inverse_nove, inverigaey aulved, digaowes, gel_obeessation
aove_ordes (10%, 70th, TR', 12t", "P1, (1,, 10m,, torn, "B"";
build_gsel__ng Inoptt_ Himit"s, sime_1imst-6..01
start time time.time DI
nede: (stato, iast_nove, soc_tuplo)
start selved
visited ([starl])
goal_map +1 # state -> seg from solved to scate (tuple of noves)
frant [(start,
depch 0
while depth degithliiii and frontiees
if tima.tina start_time time_linit:
break
noxt__fontteer []
frontior:
for in oodeer
if Text is not None:
it prunez same face Exice or invediate inverse
if n[0] == move (0) inverse 1laxt_novee
stace epply. popplyyper((saatee perm_hy hrm_hy.nove [n]] nen_atate in visitwé:
continue
visited (tex_state)
nov_50g soq (m,) Locl_
nov_seg
next next_frontior, (nov_etttt,,, m, new_segl)
trontior next_ttontiar
depth 1-
45

---

Published as a conference paper at ICLR 2026
GGoal-map dapth", depth_iimit, ") 1co(2201_paa)1 return goa goap
def torvard_nest wttpi__nne__________e_e htt..iinnnsiieeettrrrssseeee goal_nay, limit_ tine_ tine time,timel)
if start_state gosi_
Dfrecctly within geal redios
invwet (aig (gos
return Frue, tail
visited set ([start_
Csantie: [(start_ataale, Nose, (1))
depth =
depth depth_iinit Eronticr:
if tima.tina start_iime tina_linit:
next trontier lest__nove, swg frontiers
i Chect neet
goel_nept
tail invert_sec (2ist (goal__aplstatal]
1ist (seg) teil
for a. in neve_ordez:
if if n[0] =* Las:__ove[[]] oz a Lnverse_nova wtw.sse_eoovaaast_pppoo neve continue
new state app-y. pep-yyeermeetato perm.yy ner_eyy_nveeiiee [m]) if continue
visites:
vixited. add (tex_stattl
new_ seq (n,)
Sarly abeck
new_alate goal_nap:
tail invart_ (1gst poc.pp/ioccoeeooooooooottaaaaaa
zeturn True, 1.st Inwv_segl
next feottiroo appand (nov_state, i, nex_seql)
crontior next_trontier
depth +o
mot--in-tne-niedle
start state get observation!)
pr
qoal_map build (dapchh time Hii
ok, solutionn_sy faweert_.ee__innnidbeeeee
gusl_nep, depti_ 1ime--ii
soluticn_rog
print ("Fizst most-la-the-nidlle actemst falledy trying alightly deeper on forvard side...") solution_pox torvard_ners_innniodd stttrr_ststo,
depth_ eino_iinitre.00
print I"Colld not 1ind a meet-in-the-middle solution within linite.")
Finel answer ("Could solve within linita.")
else:
print Ponnd sequence bengths", " len (eclut iongaa)
psint "Sqquencu"", (.joinnestttioo)ee))))
Apply reil cube
do_noves toggution_eg))
rinel_state gct_cbscrvation()
print ("Solves"', tinsi_state if tinal_state solved: =inai__nnwwee""
elae:
=inwe_anewez ('Applied esquence, not soives.")
Observation.
Cusrent states www.
Goal-nop size depth 9732
Pirss meet niddle aeteppt failed; trying slightly deeper Forward side... <Milled the Pythen Interpretus>
Not solved.
46

---

Published as a conference paper at ICLR 2026
L.5 REWARD BYPASS VISUAL REASONING
Model
Agent Type
Input
Reward
Depth
GPT-5
Basic
Vertex View
Heuristic
In this case (Step 1), the agent was required to explicitly call get observation () to view the cube image. However, throughout its search process the agent did not make any of the visual input; it only called the image observation once at the end, to display the final cube state. Instead, its entire search relied exclusively on the heuristic reward. The code shows greedy lookahead strategy up to depth three, where move sequences were evaluated and selected solely on the basis of their reward values.
This behavior illustrates that when a simple external reward is available, even capable agent may effectively bypass the provided visual input. Rather than engaging in visual reasoning to reconstruct the cube state, the agent defaulted to symbolic search in the move space, guided entirely by reward optimization.
Step !
Thought.
Thoughts 1'11 greedy and Linited Lookabead search guided by the heuriatis reward, At wach iteration Tey all 12 basid moves and pick the cae with the largost pasitive reward; 12 zound, apply it and If no single neve improves, try pairs of neves (dopth. 2) to find positivo not improvencnt) 12 apply zest
If still na improvement, try depch 3 sequences for pos iovi net inprovement; if Fourd, apply the triple.
Repeat until ne inprovenents are found up to depch or reasonable move limit is reached. visually
cursent cube observation call Final_aneser (**).
will
salved. will
Code.
Greedy Tookaheed solver using the begriacte to rewerd
Deflie and Inverses
moves [Tp", agrn, 18", rarr, "L*, rutr, "R", tars, *0n, ngrn, 107, *D**]
inv [n: [m]s-1] if endewith else 11) for noves]
def cry -ey_postt_squuaeee (nax__apthh
Try to Find the best improving zequence ta max depth, Returns (bess_r best_sequence) with best_reward round, cize (0, 111.
0.0
best_seq
Deoth
21 nake_neve (m1)
undo
nake_nove Hav [m]])
best_reward
best__sg [n]]
if best_.rewerd depth =w return beat_rewasd, best_
Depth
for mi in moves:
make (m1)
for n2 in neves:
nake_move 1m2)
nct xl #2
make nove nove (inv(12))
47

---

Published as a conference paper at ICLR 2026
best_roward: best_revard not
undo m1l
make, nove [inv]nl))
if beat rewerd > 0. depth return beat_.ewwedd, bee
Depth
foz mi in moves:
ve (m1]
for 02 in neves:
nako__ovve (m2)
Zoz m3 noves:
x3 mako_nove (m2)
net rl x2 r3
make move [invin3]] if best__wward: beaa_r net best__eg
undo a2 undo nl
nake_nove (nn)
Kein isprovement Toop
inpal__iprovvment
appli led movex []
i.erations
itorattat 200 safoty cap on number of applicd moves
("Starting houristic-quidd improvenent....)
icerations nax_itorstionee
iterations =x
best_r, best_seg tsy_best__ cest_sequence mmxx_eppth-) if best de 3 or not best seg:
(2"No improving sequence
(sterations). Stopping search.")
break
Apply the
zeguence
seq_x_sun 0.0
best__seg
2 nake_nove in]
opplee__ovaa.appendd
inp_osieenntt +-
print It"Steration [iteratione]: Applied (best_seg) with net rexard [seg sum:: Total ixprovement: irtss__tppoorammn::3331
prin (iniiiss Applied (enn moues, Tocal heuriatle Ingrovement from starts (zotal improvveentee:.... 3t)""
prins ("Pinal ooservation len for vixual check:")
abs cet_ebseevatien))
print (obs) 7 This will display the curzent cubo in vercox view for viseal verification.
Observation.
Scar:ing heuristie-quided Exprovement...
Iicration 1: Asplics "er"; Iseration 21 Asplied [*D*"] with net reward 2.030, Total improvenents 6.000 inproving sequence
Total improvement: 4.000
Stopping local
Firished, Applied moves, Totall heuristic improvement trom stacts 6.000
Firal ahservat fon for visuel check: Inage InI...na....g inage modeeRGB
0x75C129633400>
L.6 REWARD As A MISLEADING SIGNAL
Model
Agent Type
Input
Reward
Depth
GPT-5
Basic
Full Symbolic
Heuristic
48

---

Published as a conference paper at ICLR 2026
This experiment shows how simplistic external reward can misalign with advanced agent's internal reasoning. In Steps 2-7, GPT-5 applied several non-trivial search strategies: greedy hill- climbing with 2epth-2 lookahead and random shaking, heuristic- heuristic-guided DFS, constrained stochas- tie search, and macro-based methods incorporating standard Rubik's Cube algorithms (e.g.. "Sexy Move" and "Sune"). However, all of these approaches heuristic reward-a single numerical score intended to measure progress. The result was limited: the heuristic plateaued (no improvement in cumulat aetatiiveleeeeeeeeeeeeeeeeeeeeee and the cube was never solved.
centered maximizing the provided
In Step 8, the agent explicitly reflected, "The heuristic-based approaches failed to make progress... I iestrrinntdriver search that directly targets subgoals (e.g.. build the
will switch to deterministic, white cross)." After abandoning the external reward and instead adopting a subgoal-bass -bssed strategy, agent made immediate progress (white cross success).
This case illustrates that even for highly capable agents, simplistic reward signal may conflict with their internal problem-solving process, reducing performance until the agent reverts to own structured reasoning.
Due to space constraints, we only include the observation outputs and code fragments the key steps.
Step 2
Thought.
Thought: will try to solve the cube using the avail toole, Since can get heuristic rewerd 19.1 lerent greedy hill-eliniing approach gui evaluate all moves and choose the one that gives tae aighest positive improvement, It no single move gives ieprovenent,
as step,
ipairs of moves). still sandon "shake" novea Lo eacape local ninine. I will keep checking if the cabe is solved by verifying ved,
try depth-2
Final, (*t)
Code.
zendon import
(42]
Holpez Sunct fons def Le_salved(stato)
if not isinetance Istato, str) or (stato) 1- 541
Palse
taces state(0:9),
Fnour (8)
stabel9:18]
BACK (G)
state(18:2]],
LPFT (R)
statm(27:36]
RIGHT (3)
statm(36; 451,
UP
sLatw[45:54],
(N)
(1en (ect (tace))
sacos)
inverse (move)
return move t-1] 1 if move move. endexcith (rrny else move
moves IPP oprn, "B', "Bte, "S,, 1375, 'R', "RIE, 10% Pgtr, 'D", *D**]
def cry winging noves (12
PPollate single
the pieitive revard
best_nove None
BnEt)
for m in noves:
revert make_navo
if = mest_rewwadd best_reeaadd
best_nove
return best best reverd
def d2 nover
Pouloute paiza aoves retuen positive paiz and canulative soward best_pair Nope
49

---

Published as a conference paper at ICLR 2026
best_rcxard flost ("-ine") for mi in movect
for m2 in noves:
make neke
total revert n2 then n! naka (1avers if total best rexard: best_ Lutal best_paiz a (nl, m2) nove (inverse return Best_paiz, bost_rovard
def
number ruily racos
faces
stal=(0:5), stabe[9r18), 4:atw(18:27),, stale(27:36), (3:44)33::4),, state[45:54)
sun() Eor
[an
from observatioon
scatet get set_esssevaticn))
print ("Initial states", statel)
prinz ("Inicially solved?", ia_solved (ataca01) ("nitiil
faces_ocived_couee (stazc01)
nox_itorations stagnation novex_mede cumiiative_dulte 0.C
it range ih, nax_iterations Check solved at gel_cbservvtton)) if is_eoived(at)) peint at (it) wita (len ( noves.") #inal_anawez("")
Try single move
ni, =1 - try www.siiggleeeeeeeeeee m)ves()
2E nake_neve (n1)
sumuiative_dell
moves_nade. appandd
else:
depth-2 pait, spair try deppt2 moves
not None
rrl nake, nove (pair(0))
rx2 nake_novw (pair(13) cumolative delta (trl rr21
nade, extend [paair[] pair[1]]
atagnation ion
else:
Randon rand_ randint 31 yange isans_novest:
escape local
choice (n0925)
se make__ove cumulstivee ivv delta noves_mase apppenccpmmmmmm st stannat fon a=
Pertadie logging
st oet_observation])
12 camulative Iscas_solved- (ooe
novese(len [novesgnneee]
else:
completes without
status
st = get coservation
peint (NNo. solved within itmrasion budget.")
print i*Feces solved:", faces solves count letl)
print (CCursent states", st)
Observation.
50

---

Published as a conference paper at ICLR 2026
Initial state: w
Initially solved? Palse
Initial Saces solved:
cunulatioon wwmmlatioo.dellee...oo noves=33, Faces_ollvdde
I:er 40: cumuaatve_ddaraa0..oom noves=?1, faces_solvad-0
comilatvo_ddiear11 mo3cs-103, raccs_solved-o
I:er 80: cum.iatie__daiaa00.000 noves=147, faces_aolved-0
cum01ctaP5_$01ta00... movas-183, :sccs_polvedd0
Iser 120: ammulative__eltam00 movec-230, taces_solived-
cumu1ctass_$0tta00... movas-251, :3ccs_polveed0
Iser 160: sumuletive_0eltan00.00
moveo=312,
saces_solive--
cumulative_deltae0.000
So
Iser 2001 1allattive_eltta0.00000
moveo-381,
_aces_solvedd
cumoletive.delte00.000
I:er 240:
cundaative_deltee moves-672,
Caces_aolvedda
rumuletive.del1ee00000
I:er 280: cumdlativ_@@etaad..00 movea-555,
Caces_aolveded
cumiictvs__@ltar0..000
Izer 320: cumuketive_00ita00.000 moveo-638,
taces_poivedd
Izer 260: cumolctive_00lta-0....
moves-11B,
tacos_solvved-
Teer 980: cumulatiive. seliie_deelle del-0a000000
movex=757,
Izer 400: cumoictive_@0lta-0.... movep-196, taces_solved-0
420:
cunulatiive.. settiiv_deltteee deltta0.000
movez=834,
comolalive_@eleeed..o nove
Teer 460: cunulativve.. seeiie_dellteee del.tt0.0000.
movex=122,
Faces_ soleee
480: cumdal.ioe_delleed..o 055e Saces_aol velved
I:er 500: cumulativa_daltadd.. nove>=1000, facos_solvad-0
520: cumclative_dellae
move>=1043
fecea_aolvede)
Iser 540: sumlaativa_dalt=dd.000 move>=1082, facos_solvad-0
cumulstive_scitt)
moves-1124, rases_colved-0
Izer 580: cumulative. de della-0.0000 00,
moveg-1161, 11,6, races, 8o solved=)
cumulstive_deitt
tases_celved-0
Step3 3
Thought.
The previous greedy sandon approach did make coliable progewas swiech monotonis hearistiooguide depth-linized search: at each iteration, will search for abort sequence of noves (up Lo given depth) sloaw cunulative hearist istristic ceward noganegaiive proferably pesitive, This avoids regressing in the staged heuristic and should help climb from D will implament DPS the sana face coasecutively, and finds the best camulative gain sequence. I will apply sequences that piain pasitive goin; none tound, can apply restral 10 gain) sequence repocition tey again with deaper depth. I will keep checking for solved state, and call ainai_ansvez imeedattll solved.
leariatic aetric.
only accepla noves with regative imediate sevard, avuids zepeating
Sipe
Thought.
The previous approsch explored too many branches and ait the operation limit, I'll swisch to rainde st-ochaxt in search that samples linited number of short randon evaluates heuriatic gain (sun nove revards), and asplisa best posicivergala seguence if found, IF none found, 1/11 apply small randon Yahake" to escage local minine. tHis computacion bounded sncal_ensweei"m) ineediately when. it is.
each iteration,
deep rucuraion. 1'll zeqularly check
solved
Step Thought.
51

---

Published as a conference paper at ICLR 2026
The previous stocrestic and exheussive searches inpeoving the heuriatie. well-knom Robik's Cobe algorithns (sexy sledgehemner, evaluate net heuriatie gain esecuting ing laaming sevards). net gein 0, If1l keep itz ethervise Ifl1 undo it. This bounded, decerniniatic approach reduces oparations while atill seeking nococonic heuristic improvenents. 2111 ropeat tais for solved atate Iroquently. solved, kill inmediately call Final_anavez
heavy and hit the operation linit without switch to wight, structured nauro searcht try snall library
eto.). for esch
1111
number iterations, checking for
Step 8
Thought.
The houristie-ltted approaches failed to make progress and hit operation linits. I will pwitch to seterministio, ccastraint-driven search directly
subgssis build white the Down face) by explering shart sequanees usine the environment as the cubs model. The search: cavironmens consisteat.
backtracke Frunes imediste inverses and esne-face regetitiors.
Checks goal prodiestes reading
res_observstion1).
1'll first try to complete the white croes (Sour Bown edges in correct positions and orientecionst. If I the cube solved any point, 1'1l imediately call ansve (*S).
Code.
import
0t:l2itlle
def 19. solvve(state))
isinntanc
Len(state) 54;
zeturn Palse
[stat= (0:9), state():18), stat=(18:27), 32735(27:36), state(36:45), stsce(45:34)] zeturn all (len faet (face)) -n 1 for face in (aces)
def taces_poived__coue count (statel: [stata stato[9:18), state[18:21), stste[27:361,, state[36:d5),, stszott5:50] return sun E. for in taces len (t)) e-
def inverse nove inve:se_nove (MI1
return m|s-1] if h.endswith("19) else 911
PPP,, optr, 1B', PRtE, 1h,, PLU 1R', PRIP, 1D', r0ts, 1b', *p
# Targett constraints helpers: (index expected color)
FaoM centeea znZermton (Eaxed)
CENTER " 18": 4, 1311 13, 121s 22, 181s 31, 12t1 40, 101 49
CENTER_COLOR 62181, 13:1G", 22:'3", 31:'1", 40210", 491'3"
croEs on (D), Me require Rased on the provided netz faom indiows:
edges be placed oriented correctly.
65 <6 47
52 52 53
mhitching edigese
DP: DE01 223-48 with P121122-4 +> colors il and R
R12)12)-34 colors D121 [21-52 with Bk cop-nidite B10] [2]-16 >> colors #f and 2
DB:
-48 (12)12)-25 colors and
daf ponst 1))
return
46: 'w1, 75 181, 'R1, 342'2',
52s 181, 10,18'.
'81, 25,
def [iae_ccosscciia__FF(( 1461'W", (1181)
wtw._oonntciaa__RCCGC return 150: 34:1113
52

---

Published as a conference paper at ICLR 2026
def srgp_.conttciia__0B1 10:101)
def edge rennttriint return (48:W", 2511B1)
constraini aaaat (stall,,, cumasseinta): const rainter dice Fndex-2nolor ids, col in constraints items 1)
if stake[idk] In col:
return True
def ( got_otserrstionn)
Depth limited
sequence
given Lie
Prones ianediate inverse and sene-face repeticions,
def [intLssqueeme__er wtweemee__or__oreeeeeee for_eomatteenii best l'seq": None)
dex_depphhe,, new..enpansicnee-12000
(lexp": path 1]
def dEs (desth, last_mecet:
sest("sez"] is None:
return depth
pax_expansions:
return
Greck lanedaate gool ldepth can be G at stwet)
get_atate(
if wet.traintttstttaaaiiie.. const rwintsl
[est[" copy.)
zeturn
depth nax_depth:
zeturn
moves:
if last_move is not Mone:
m|0] last_ nove [0]:
avoid same face
continue
inveres_nove (Last_nove):
continue
counters ['oxp"] +
patt.ap
dłs Idepth 1, m1
best ('coq']
leare acate as Σsy sequence already applied duzino search? Ho, so applied the aoves during nust becktreck to restore betore returning control to cailer
path.pop:)
retuzn
backtrack this nove
nake_movw tinverae_ (n)
pop
if counters ['xpp] >n nax_cxpansions best is not None:
19,
return best['sec)
Punct fon to sttenpt but but ldiing the white cross (teratively
targeta = [edige constraint ceattrrint___i_ (F möge constraint nR(, edge constt DRC,, edge_ wonnttaintttttiiii (t. edge uaiil all sulved
He 111 Lay
at atterpt 4. per, per,.edge = bounded actempty with sna1l randon pertonbation (Lazgeta):
for atterpt in rance rance (ascrttttttttt_peoooo0)))) gel_aslate))
a iz edee already selved, nove to next ccastrsiats.cotistiie
break
Find
this
seg find sequence cor_.conttreineeee (tgt, max depthep, max expensione-99000g
if not Rone:
Apply the sequence lit's alressy applied during the search? No, we backtracked; we need tu apply now)
in s0g:
nove
Vezity
st2 get_statc0
not constraints tetl:
53

---

Published as a conference paper at ICLR 2026
sonchow secisried, undo chake for in reversed
(anverso_nove
else:
break
else:
Snell randon shake ohange positions
laxt face None
in cange (4)
cand [e. for in noves if last_face is None or a[0]] 1a last_face]
candon, chuicw (cand)
navo_ (av)
last_tace mv]0]
else:
Falicd
edgo atterpes
return False
solving individual edges, full
fali
st get. statel)
ixfiddist, crows_unstrrintss()
zeturn True
fully consisient, bry refinement
fuil constraints
wtw.eeccccc__orccosstttooooo cog.oooccttttttoooooooooooontsss max_dopta"", nox_expanstone
if 2eq is not None:
nake_move Im!
return ccnstraints wtt.ssstetssttssiesesett.. (ross_onstraintts))
return Talae
Brivert acterpt hoild white crossz if cube becomes solved, Final
candon. (233
statel get_state!)
prin-("Btass ("Btatt states", statef)
(rices salved at start:", [eet__oovos_ccuuttteeeeeeee is_oolvedistate0)) tinal_anovar(*))
success cross but ld wwwtteccosseeee crose (et_state()
prin: ("Mhite croas successs", success cross, *Paces solved after cross attempt:", feswe_ tat), "Blales",
fully snlved finalioe.
is_solvedist): rinsl_anover(")
Observation.
Start stater BORSSOAAGAARRRORRBBRRRARRSEOOOOO
While cross sucuesss sas
True Paces solved afies crosa abcempl: Stabes arcaaaasseeeeeeeoeaooeeeeeveeeee
Step
Thought.
worked same constraint-baeed search approach to solve the tour white corners and complete the firet layer. eneade the tour dovn-layes corner constrsiats, then coazch shart eequencos satisty caca corner's a constreinte while pruning redundant brarcaes. It any time the cube becones volved, I. villl innedaatlly cinal_anaver
Thought: lbuidingg
houristic
concinus
54

---

Published as a conference paper at ICLR 2026
L.7 REWARD AS A GUIDANCE
Model
Agent Type
Input
Reward
Depth
Claude Sonnet 4
Basic
Full Symbolic
Sticker
2
In this example, the agent explicitly relies on the external reward signal to guide its search, At each step, candidate moves are evaluated by their immediate reward: negative rewards trigger an immediate undo (e.g., U with reward -22.0,, while positive rewards are retained (e.g., D with ward +12.0). The agent's s behavior shows that even a simple reward can provide effective guidance, shaping its local search trajectory and preventing it from devolving into purely random exploration.
Step 7
Thought.
Thoughts : Rxcel The à nove gave us 130 rewerd and ve now have better cube state. let de check loocing positive
Code.
Chock
current state get observation (e"Crront
(curzent_etate)""
# Gount correct at scickers
correct stickers sum(l for in range (69) current statels] solved stste(i)) prin: (f*Coreect atickers [cocreot (okerr))))))
f Continuc trying noze moves to sec i2 se can improve further zomaining_naves (*U", "D", *B"] for nove in remciaino_moves: make_neve
print (1"Hove [ncve]: rexord (zovard)")
if revard > 0:
print (2"Kooping (move) improved cube*) break
else:
Undo the nove apposite__ove
undo_roware nake_nova nogo
(s"Uddccn with (sppasito_nove) [undo_rexezd)")
Observation.
Ourrent statw after wanaayewwcccceeeaaaaa........ Cosrect stickers now:
Nove U: zeward -12.0
Undoing with Ut: rexard
Nove Di zeward 12.0
Keeping
improved cuse
Step 8 Thought.
Thought: Great progessa! The nove gave us anoilas +12 reward, Lst aw check the curswal. sbace and su0 how close solving cube.
55

---

Published as a conference paper at ICLR 2026
L.8 TRIAL-AND-ERROR TOOL LEARNING
Model
Agent Type
Input
Reward
Depth
GPT-5
Standard-Solver
Full Symbolic
No reward
In this example, the agent initially attempted to convert the environment state into the solver's quired format and call the planner (Step 2), but the planner returned errors due to undefined edges. In Steps 3-5, the agent experimented with alternative mappings, but all attempts failed to produce a valid planner input. To overcome this, the agent exhaustively explored all 46 per-face rotation combinations to find scheme compatible with the planner's input format, ultimately identifying scheme compatible with the planner. Upon applying the planner-generated move sequence, the cube was successfully solved. This process exemplifies trial-and-error tool learning, where the agent iter- atively experiments, identifies the constraints of the external tool, and adapts its strategy to reliably harness the planner for spatial reasoning tasks.
Step
Thought.
Thought: have cuerent cube scabe stzing. Nexi, convert unvironmen, s-ate (colos boded with facas in the order R, to the solver's requized facelet fornat (URFDL2), csing the center start
colore nap solors face lastors: 0-00, 1-3,, 3-32, M-SD, B-bd, G-8B, simplest per-face oriencation (Cop-laft te betton-rigat) and faze order napping: 0(36144), B127(35), FiC18), 2145(521, ((18)26), 219/171, eeneatensted shat order. scring and print the eolution for error), It solatior is returned, in the tolloving step sill parse expanding querser
coll-plannee with
and apply
sultiple calls.
Code.
Build napping from unvizonnent oolox to solvez face Jotter
color_to_faze
10's 10',
Up
"21s 1B',
'R's "F",
Front
191s 10'.
Down
'B's '5', Zert
'G's 'R',
Reck
a.ale obsx Zxcss peevioue step
Derino the index ranges for each face in the cavironment (face-on, soN-ma1o22 wav__aces
"P"s l1st (sange 9)),
*B"s (s2nge 1811,
161s list (range 2211,
'R's (sange 361).
1ptg H1st (range (36, 4511,
1b's (raggra
# Selver zequizes URFOLB ordez falleee_aae__rrdee 118',
1D', 11', rar]
orientation idcatity (Iaco-on ros-maaor)
solves_indices for in selver_tacs_ordrr: if tace "p";
inddwe wxt.eeeteddeeee eeteeed////ee (101])
elif face 'B':
www.:iidddeee.eeedddddio.e faces (1B1])
face IP':
sollweriiddcen weteindeeeetttnd/eeee... faces (1P1])
facu 1D':
indvor_indicos. extend (sav_faccea ['
facu 12':
solver_indices extend cav_facoss"""1]
face
sodvor_indices extend sav__aces[""""
Convert envi ronsent eo colore ore to soiver face letier sering in the computed order
56

---

Published as a conference paper at ICLR 2026
foiver_stz
BeyError ttt.:ooor_.totttotttttelelllll for in ondver_indicesi
print "EEcounteeeed unknown color in etabes"> el solver_str None
print Proppoee not ver string:", solver_str)
solver str is not None:
plan planmp (Lool print (*Pianner cutput:", plan)
Observation.
Execution
Proposed solver string: DarrOOrAARAAAARROPPSSSSSSSS Planner outpoti Error: Some undetined.
oucput fron code anigpel:
Erzor: Sone edgea aze undefined.
Step
Thought.
My previous edge-ve idation ueed sortes exo-letter stringe but congared then to unsorted expectations, which made all candidates fail.
I sill fix the validation lon conparing to the alphabesionlly socted set of expected edge labels. Then beute-Iorae face cotations, fand schane, planner, verity la selved.
Code.
# Fix edge validation and brute-fozoe zearch for vaidd per-tace rotation scheno, then plan and apply
obx current cube state string
Environment face indices (zow-najoz problam)
savesaces =
"P"s (sange 91,,
*B"s (sange,, 1811,
161s (range 2211,
'R's (sange 361).
kgtg H1st (range 4511,
1b' (raggea,
def
waaessttto___nieeee zotacion):
(Ede (969 (R), (180%) (270r
if rotation s= 0: (1,4671)
elif rotation 11
(,,3,
elif rotation 21
order [3, 4,,,,,,,,,
elif rotation 31
order [2, 1,,,, 1,,5,,,
raise Valuakeror ("Ineel ad rotat ion') indiowsi
ozdee]
cclor_to_face aapping osntezs conters
"E's state[f],
"B"s scate[3+61,
tD"s state[10+4],
tp's st24e(2244),
57

---

Published as a conference paper at ICLR 2026
scate136+41, 191s statel1bbt),
color_to_taze
cencera("""] 101,
cencersl""" '8",
cenceral"P!): 18",
cen.era["'!]: (D',
cen.era TB'
(inn:("Cneerrs"" veaters) prin:("Color ("Coloo=>Facoi", color_to_face)
# Procctouto rotaced indieos for each face and zotation spced oo pro_rot (Saces (x: soatoo.nnticcssen..beerr (tact), zange 1913 110% 1P", 13", 18"11
def bui 80. solver. str. fast (scheme)
16x 1- 919_xet(101 [schane [101]
pre_rot [schene [1R1]]
18x 1- Sre_ret (121 [schane ['11]]
[schone ['D"]]
18x 1- ore_ret (1L) [schane [121]]
['61]]
return http://cooor_ttttollooeoeeo
for in idx)
def tace_ (asc letter)
base 1"0's0, fnts9, ("'',,, base (aweeeaaaa_eelleeaeaaaa
18,8 1D1:27, MM636, (81445)
get__ Ta, face, pos)
return (aaac__ -pas]
Edgo dorinitions in Rocienba URPOLE Indoxing (face-local 0..
adges_des
(3701,33
('E1,1),
7 UF
(3001,5) (3), t
12101,15, (281,11,
# om
13101,3), (1D')13), 12/01,13, (191,731,
# or
(SDD1,5) ("B',71),
(C1D1,7) (1B1,7),
3 2B
(15555)
(1R1,31, 3 2R
(1R1,5), 3 BR
(8855)
Expected edges as alphabeticsily corted two-letter strings xorted, pe set FI"PU', 1B8", 1887, 1101, toP1, faR "ent, "DE", 1PR1, 1951, rare, 1B2711
def edges_ validd))
Bulld sosted two-lecter aczings counts
edge paie
(1I,e13, 92) adgea_det: (c, fl, Fi)
(e, 52)
pair = (cdditootttol(())))))
paic
expectet_eorted.coo
return False
[panti counts. get (pair,
Pheure esch expected edge appeare exectt ly done in expected_ pozilee
if counts.ge get peetle. le, 01 [-
False
return True
focnd_schena None tound_solver_stt
9"6 rotation conbinations (4096)
outer break Talse
for range (4):
if oute- break: break for in 14];
outar_break: break for f in range(4); outer_breake for in zange (d):
creak_
58

---

Published as a conference paper at ICLR 2026
38 outer_ brr_kk: break
scheme 1"0";0," (2 (D"sdd 12 (Br:b]
buf wewooooeeeerree Fast (schene)
seess_volddss:
Found xcceeme acheme
count_aelver_att
outer break Frue
("Pond sclienez", print ("Solvar string proviex:", toun__oivor_aee(133] it Tound_solver_ste else None!
if sovvn_solver_atz:
plan pilLpie (taol (taol_cube, wwtpecucrreeeettttttteeeeeeeeeee pold__oovee__ttr print (*Rlannee cutpoti", plan)
Observation.
Conters: 'R", 1B11
1871
10", 1D11
Color-oPace: (101: 181, 1911 1R7, 1811 1P1 1911 101,
1871 161, 16t1 1B1)
Found schomes 1101: 1R12
0, 1D"1
1211 1811
Solver string previes: DRFFUDFUL
Planner put:: R2 L. B2 m1 01 R1
02 (14E)
Then executed the solution sequence and solved at Step 7.
L.9 BYPASSING VISUAL TASKS VIA SYMBOLIC REASONING
We illustrate the performance gap between Face View and Vertex View inputs using two representa-
tive cases.
In the Face View setting, the cube is presented as regular 3 x 3 grids. The agent reframed the task as a symbolic parsing problem: mapping each face's colors the URFDLB string required by the solver. This bypassed visual reasoning, worked reliably due to the input's highly ordered structure. The planner accepted the constructed string and returned valid solution, which the agent exccuted successfully.
the Vertex View setting, these distorted layouts cannot be parsed directly into solver input without geometric inference. The agent nevertheless attempted symbolic reconstruction via pixel sampling, palette classification, k-means clustering, PCA ordering, and multi-view accumulation, but the re- sulting cube string incomplete.
These two cases highlight a key difference between the tasks. Face View, the orderly layout enables symbolic parsing shorteut that bypasses genuine visual reasoning. In Vertex View, this strategy is infeasible, and performance drops sharply. This suggests that even highly capable models tend to prefer symbolic over visual reasoning whenever possible, and that less regular task formats are informative for exposing their limitations in spatial understanding.
L.9.1 FULL VIEW
Model
Agent Type
Input
Reward
Depth
GPT-5 Ideal-Solver
Full Visual State
no reward
20
Step 7
Thought.
59

---

Published as a conference paper at ICLR 2026
Our previous claesi fication nistakenly excluded rear-utice pixels, undercount M. will the at ioker colors by averaging pasches acound each suicker senter while only agnocang the gray background and black grid lines (not near-white), then classity the nearest canonical color. 1111 rebulld character abale at atnung, wosure has wath culor, the planser, expand and apply the noves, and finally subniz (haai_anavee
Code.
Recorpute Incinding pixels properly (ignore only gray background black grid), ing get_abaeevvtien) ing.size BG 50, ELACK 00,0,0)
def www..ooo...rrann..oooeeeeaaaaas. 208):
cx, my
for dy in zenge(-I, x+1):
it y < 0 or y > h2
continue
cange f, xill:
continue
rgo gng.gettixcl (16)9)
if rqb 2G reth BLACK:
samples. aep.eedd (zgb)
not samples:
samplee les (ing: win..gepixellee 10x, cylil [0]
samplest (eamples)
sum 1p for in sampless est /en teamp lest
samplest Goapples) return (as, ag, ab)
[2]
cason
'K's
15' 10, 255, 0),
1B's
"Y's 1255, 255, 01,
10's 1255, 165, 01,
1W's 1255, 255, 2551,
def classing (rgbbff b. 19hl None) bd-1e18
k,v canon ilemn
dxbd:
bard; bestek
def colors__ron_grid Fron_gridd patch wii. pointt
return lclassify aaglavg wwg.aagg.ooooo color_ anw.aaroooddddeeeee include whice r-61) for in grid pointel
# Use proviously conpuced grids Warld, Florid, Plarid, BLarid, Alaeid, RLordd (ULirid)
[_polors cctora_fsonoor watttrriddttttnnnnnnaaa (B_grid)
F_colora
P_colors alar__rronoorspppttttnnnnnnuaa
R_colors a (B__ge gB_grid
L_colors tolara_ttoo_grsd__aatttt.. wtt.apoorcpptttt__n__tttotoo
R_colors colors www.ooorid_aateeoroeeee (R grid:
from collections import Counter
"'.jiinf_ee colors Rucolor fooslors Roloors BLoolors (_oolors) (fColo countas", Counterattaze) "lengthe", (statw1)
prin: ('States, state)
# Call plancer
plan [edl__golde___anne (tool_cube_ee floo__ouhl_.errsasaaiiiooeee Drins("Flannerr"" plan)
f Parse and exeand neves 1ike 123 02 92 52 (195)
Amport tokens re. Findall 11 (e' (JURPDeR): (1123)) plan)
60

---

Published as a conference paper at ICLR 2026
expanded
for taco, nun in tokens:
i8 h 1:
expanded. apperd (face)
olif 2:
expanded. exterd ((Fae,, Facel)
expanded, exterd ((Fam, Face, facell
prin- ("Expanded noveas", expandwd)
Apply asvea
Ioz ny expanded:
print mnakc_nore my)]
Submit
firal_ 1"
Observation.
Color countiss
length:
State:
in Ps
UE (200)
Expanded noves: [101, 101, 10r, "Pt, "ET, 181, 181, 10% 101 187 TEN 1D1, 10%, 181, 127, 1D1, 1B4
'a', '2", '8", 101, 101, 'et, 1ety fety 121, 12 "2 127 18' 10% 107, '11, 18r, r37, 1p1, 101, 101g
Applied -U"
Applied move '0" on the cube Applied -U"
cubc
Applied move 'F" or the cube
Applied move 'p the cube Applied move 'B" or. the cube .....
Applied nove "B" or .ba cabe
Applied move "p" the cabe Applied move "D" on. .ba cabe
Applied move "D" or the cuba Applied "U"
Solved.
1.9.2
VERTEX VIEW
Model
Agent Type
Input
Reward
Depth
GPT-5
Standard-Solwe
Vertex View
no reward
20
Step
Thought.
The misclassitied zolors. I'll svitch zo a lighter pipeline: classidy
aperation linit
broad
(0/M/R/0/B/1) robustness.
Sample far tover pixels lstride-5) and run k-meane with rexer iteratiens (k-27, 1ters-01 to tind iecer centers in each vier.
Gcoup the 27 clupters epatially into 3 ssces, order each tsce's 5 3x3 via PCA, and use the center iiceer
the face.
Collect exactly vievs (sight, right, down, right, sight] to coves Intes.
Convert the six color grids into the UREDLB string B, mapped to L, call the planerr, epply the noves, Uhen check
state.
plannor ercozs (nasping inzonsistent), print composed string dozug. 2'11 exccute the plan and finlsh.
Code.
61

---

Published as a conference paper at ICLR 2026
from collections de
inpoct eget
Neareai pelecte color napping rabuainess PALETTE 1012 1253, 143, D1, 1W's 1255, 255, 2551,
crange (slighely dazker than pellow confusion)
181 1220, O, 0).
181 10, 200, 0 220),
181
10's 1255, 255, 91
def rgb wtw.tttooooooo....o....oo.....tt letter (ngh):
9 19o
fgeore wid-gray
polored
beat None
bestd 2c16
for k, (21/99/3)) in PALETTE, (ttent 1)
(b-pb)+*2
it bestd:
bestd best
return best
pa_ooloord__pielll (p)
max (), gi
ze/ect dazk fgsid/outline/
retuzn False
rosect mid-zray background (LoN caturation, aid-high brightnesz)
if Im-n) < 25 and 120 <e de 230 and 120 de <e 230:
return accepe bright white
rigis 703:
return True ascept sufficient
if [m:n) 2- 35:
return False
def piala atzude-E, mas_sanples-150)
v,h ing.size
pts, cols
ont
for in range 10, staride))
cange (i,
px(xyy
pi
pts apsend (t) (ppend))) cat + pax_ienpes:: return pts, cols
ptc,
_ww.ns_poontteeeeeop__ooooooe points (pcinte, 11oro-0):
if not points or len (pointst <
None
init farchest-point [psints[0]] for in zange bestd
for p in pointa:
drin bestd:
bestd
conters.agpendionn asxigns [0]x [o]allettoinees
for in range liters):
changed Palse
1,9 in enunesate (pointa):
ci nin (zange (k), key lambda 1: [p[[]-ccators| [il caaee (-1)--21
assigns
assigna[1] cij changed True
changes: break
noMe
for in range(k):
poinnte [1] zange (points)) assigns [1j=d]
ye- pot [5 for in range (1en (poirtsi) assigns (1]=-]]
62

---

Published as a conference paper at ICLR 2026
newe. awwend (reun (x5) /Len 1xs,, cun /Len (307))
clse:
ReMC www.caapendcccnneereee
centers
clustors (U] for range (X)
for in range flen (points)):
clustecs [ass append((1
return centers, sesigns, clasters
def na
counts defaaitdics (ink)
for zab in cslor_list; 1es_to_colo__ettee
counts[e] +x
nox(ccttts.
key-lanbda KV(1)) counto
def inkerss ling):
pts, cols semple. colored cerlored_ppeee ting, stridens, nax comples-1500p ("Sanpled coloreds", (plst))))
rea kmeans_pointa (pts, 27, 1cera=81
zeturn []
assigno27, clastero27
atickers = [I
idxs clastero22131
continue
[1][0] for idkst/ [lndiddss ey sun [1]
idxat /lan fidast
col jajjoitty.blor colooi(ooll [cola]1] for idxs])
appendd (ox, eyt, coll)
return stickers
def pca_axes (points):
not points:
retuzn 11.0,0.01, (0.0,1.0)
nx [0] for pointe) (points)
ny sumppp)) for in pai mtt (ete))/ll(ggnnntt (points)
[p13] m0--)))--0
pointsl/ (points)
sun (pT (-y)) 2x for in poincel /lee (poirts)
*xy
(p[1]
p. points) /lentpuinss)
22 SxX =xy--vy
disc
max (c2rte/d det, 0.C)
lami tr/2 sgrt (dise)
if abs (axy] abs [1am1 230) 10-92
01..0,0031
else:
(5Xy, lan1
sgrt (al
u- f=100/ ufl]/n)
v-t-u|tl, u(0]]
return
def lancans scales (values, k- stors=8):
isplunents
wzappez zeuse
pts [(,, 0.00 for in values)
kreenss_pcnnts ipte, return assigns, clusters
assigne,
def group intoo Faces facee (ctent)))) centere- [6[0] for stickers]
res knmans, points lpenters, 3, (cers=8)
return []
assigns3, clusters3
faces-[] []
in sange13);
idxs clastero3[1]
[stickore[1] for in idxs]
(groupt be (gropp)
return faces
def order face grid stickere): ptx-[x(0] for in face ickers] V pas_axesttts)
praj-!l
col) enunorata (facs_atickora):
pt[0]_u[e] pt]l]=-[[]
PE[0]-vIO] pell]-v[]]
63

---

Published as a conference paper at ICLR 2026
pro1-appead (pu, col [p(0] for 5 in proj.
cols_aesigne,
coo_s_ssoaarrco__ooooo 3, iters-il
scalar(ros vala, isers=8]
col_groupe dctacitsictilist): rox_groups (ctalltdtetllis))
for ids, ppo,pe, in mnumerateiproj.
col (oolappooooaaasiiooeoo [[qx]]-)ppeo((3) groupss oodersdi sorted coolggtopa keyall, key=lanbda or sun (or
sssigns [idd)]-agpeedd
An
col_groupsee] /elp://eee//eeeeee (co1_
rode worled keyatl, key-lanbda sun sun(Saoraatikkees
rom_aroups [xlp)]]1]]//ee (tw. [x]]1
grid [
sarge[31]
for idx, pp, in anunerata (pro]):
:lab wwwp_scciin (1CK)) clab cols_ascigns [idx]
ordered rows, index (rlax c ordered cols, indextelabb
grid]e][e] (ile_
return grid
def (ioo__
stickers iib
print ("Sticker cluacers:", tentatickers)
group_into_tacee (eeessse_cccssseeeeee))))
("Facss in this viewe", len (faces)
for group in tacee, gecee_.groups:
grid aedes__acc_essc(areup
center (r]
[acex(senter] ("gridht grid)
Saces
ascunulate, aaaaualal___aaaeeeeeeeee (aco, Taceaa) for Y, in ttw__taos.iitmaeee not abos
ac2[k]
Collect races from fixed snall sequence of viewo obeerved
ing get coservation!)
accumcisto_races (observes, saccs_sron_vveniiiin apply_viev transfomation ("vviex ing get_pbseevallenn
accunciato_ (observed, facaa_tron_yien (1me))
agply_view_lranssoone (fPoiiieghh
ing get_osseevateen
sccumcisto_taeee (observed, focss_tree_rrooxttnn)) wtw.::/raaaottttttttttoooooooooe
ing (at__ossevatice
accumclate. saces (observed, faces from ting) apply_viv__tannctomatet
ing get get__eese___eeeeeee coservattion!
accomo Taces (observed, Fronk_.ron_vvee (ing))
prin: ("Colledted faceast, Lixt keyy
observed: print cascrved[k] ("orid"])
Map solver's URFOLE letrors
color_to_tace to_tte_lltter ("0":10', "Wte""" "RTETE", 181113 B (01E181)
grid_to_stteeeeeeeoe t return 1 "".joni"".jonnlig""" joiinggriddr for in (a1ge(3)) for in (31ge(31)
def compose Jebs):
DSPCL8 eulor
(B),
order 110", 191, 181, 1R,, 2=**
for ck in order:
print ("Kazning missing facss", ck) [[ck]+3
[31ge(31]
else:
cbe [oc]cc"]"rraa ["orid"] napped Iccolar to face. letter.get (ch,, (D") for oh in rowl for row grid] Lo Inapged!
return
soives_ate canpose_UReCLLAAe (observed)
prin: (SSvver string:", sclver_xtes
plan paanner (tocl_cuttocc.. cttp.ccoooppccottssioooooooooo solver_stz) ('iaan"Plannor output:", plan)
64

---

Published as a conference paper at ICLR 2026
def execute exocute_plan(plaae (pannn
sppist
for t in toke:
if !1' in end marker with oxdf
break
Face E[3)
nun Lil] (L) else
if -n !1";
print (nake_novw (Cacm))
ellf nun an 12"
print mowk (facm)
print (naxo_ (face))
nun 13"
print (naxo_nove (face (11))
if plan and not plan.etripi staattoich (*Feron")s
Finel cleck ansae_n
Observation.
Sanpled coloxeds 106 Stieker
Fausa in this vieat 3
Sampled colored:
sLickes clusters: 27
this
Sampled colored: 106
Sticker
Faces in this view:
Sampleed coloreds 103
Sticker elesters: 27
Faces this vieus Sampled culoreds S:icker clusters: 27
Fatee this vleas collected facess [TB', TR', Hone, 101, t0', 'N']
[IT,', "Y', 10"), 1107, "B", '0t), (None, 'B', Nora]l R [[None, "y", rWtly [181, 18", ry",, [lone, None, 'B"I]
[I"R', Heno, 'c'l, ['M1, Nona, Nonol, [*G', 'y', 'Y"]]
o [ITR', 'R", 10"h, 1'8", 10", 'B"), (Xone, 'G', Nore]l [I"B", "0', 'N"), 1'8", "5', 'W",, (*8", 'o', [eae]] W [1",,, 'w", (T"), 1"Y", "W", "w",, ('",, 'y", Nonel] mixsing Solver string: output
definision string WOONNNAAARRRBBBBBBBBRUT DUTRRRAAD
does not contain exactly 9 faceleta of each colos.
Not Solved.
65


Reviews:
[{"review_id": "cBgUk2GiTo", "reviewer": "Reviewer_aJqe", "summary": "The paper presents CubeBench, a three-tier benchmark for diagnosing LLM agents’ spatial reasoning, long-horizon state tracking, and exploration under partial observation using Rubik’s Cube tasks. Tier-1 exposes a full symbolic state, Tier-2 a full visual unfolded map, and Tier-3 partial visual observations with view-change actions; evaluation follows a Thought-Code-Observation loop with strict budgets. Across many frontier models, all long-horizon settings achieve 0.00 pass rate. Dense reward shaping improves some short-horizon cases but does not fix long-horizon failures. Equipping agents with solver tools sharply improves performance and separates planning from spatial translation challenges. Overall, CubeBench provides a verifiable, decoupled diagnostic suite that yields crisp negative results and actionable insights for agentic research.", "questions": "1. Could you break out pass rates by each target depth (1,2,3,4,8,12,16,20) to show precisely where performance collapses?\n2. Why Rubik’s Cube? Please articulate a principled rationale vs. existing planning/3D benchmarks: what capabilities are uniquely isolated here (beyond verifiability), and which insights demonstrably transfer to non-cube domains?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The three-tier design cleanly isolates (i) symbolic state tracking, (ii) visual/spatial reasoning, and (iii) exploration under partial observation.\n2. The universal 0.00 pass rate on long-horizon tasks highlights a concrete direction where current LLM agents systematically struggle.\n3. The paper contrasts sparse terminal rewards with thoughtfully defined dense-shaping variants (sticker/face/heuristic), enabling reproducible ablations.\n4. End-to-end diagnostic arc. Framing the Rubik’s Cube across presentation (state/observation), optimization (with/without shaping), and tool use (standard/ideal solver) yields a coherent suite of ablations that pinpoint where capabilities break.", "weaknesses": "1. While the cube is a controlled, verifiable domain, it’s not yet clear why it’s the right anchor benchmark relative to other long-horizon planners (e.g., PlanBench, SPIN-Bench, ARC/ARC-AGI) or embodied 3D reasoning suites (e.g., VisiBench, ALFRED). A side-by-side rationale (capabilities stressed, evaluation verifiability, cost, and failure taxonomy) would better justify CubeBench as a first diagnostic stop rather than a narrow puzzle niche.\n2.Tool-use evaluation may entangle multiple difficulties as well. “Standard-Solver” demands both perception→symbolic translation and strict format compliance; “Ideal-Solver” removes translation entirely. Without granular error audits, it’s hard to tell whether failures are due to spatial mapping, formatting, or simple string schema slips.", "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": "hrIXI5nv2J", "reviewer": "Reviewer_ScbV", "summary": "This paper introduces CubeBench, a clever benchmark using the Rubik’s Cube to test LLMs on three tough abilities: spatial reasoning, long-horizon planning, and active exploration under partial observation. It defines three tiers — full symbolic, full visual, and partial visual states to progressively stress these skills.\n\nThe experiments are thorough and frankly pretty sobering. None of the tested models (GPT-5, GPT-4, open-source LLMs) managed any long-horizon solves 0% success across the board. Even short tasks were shaky: GPT-5 hits ~75% on symbolic cubes but drops to 20% with images and nearly 0% when only partial views are given. It’s a clean way to show that current models can describe cubes but can’t really think in 3D or maintain state.\n\nReward shaping helps a bit on short cases (0.2 - 0.55 success), but doesn’t fix planning. Adding a classical solver module boosts success to nearly 100% once perception is perfect, proving the core weakness is long-range reasoning, not local step choice. But even then, partial-view perception totally breaks them still 0%.\n\nOverall, CubeBench is a strong diagnostic tool. It clearly isolates where LLMs fail — in sustained reasoning, 3D mapping, and exploration. The work is solid, though maybe a bit narrow (just Rubik’s Cube). Still, it makes a sharp point: today’s models can talk about the physical world, but they can’t mentally move in it yet.", "questions": "Do you expect CubeBench insights to generalize to broader physical tasks like manipulation or navigation? Or is it mainly diagnostic for cube-like puzzles? Some discussion on how this setup could extend to other domains would strengthen the paper’s relevance.\n\nWhy did models perform better with sequential face-by-face views than full 2D maps? Is it due to attention limits, easier focus, or prompt design differences? A short analysis of this counterintuitive result would be helpful.\n\nSince the MLP agent learned via RL, did you consider fine-tuning an LLM similarly? Would more exposure or reward training help overcome the 0% long-horizon failures, or is the limitation inherent to transformer reasoning?\n\nIn the Standard-Solver setup, where exactly do models fail—misreading colors, wrong face mapping, or confusion in coordinate translation? A brief error breakdown would clarify which spatial step is the main bottleneck.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "This paper does a great job of cutting straight to the heart of the problem to clearly identifies three big cognitive gaps holding LLM agents back in physical reasoning: 3D spatial understanding, long-horizon planning, and exploration under partial observation. It’s refreshing to see these challenges framed so directly, with tasks designed specifically to isolate each one rather than mixing everything together.\n\nThe idea of using the Rubik’s Cube as a controlled testbed is honestly quite clever. It’s simple enough to simulate and evaluate, but complex enough to expose real weaknesses in reasoning. The three-tier setup (symbolic - visual - partial visual) works really well it’s systematic, and you can literally see where the models start to fall apart.\n\nThe experiments are solid and well-rounded. The authors test multiple top-tier LLMs (GPT-4, GPT-5, open models) and even include comparisons with smaller RL agents. The results are both surprising and sobering none of the models solved long-horizon cubes (0% success!), and even short ones get much harder as soon as the cube is shown visually instead of symbolically. The dense-reward experiments are a nice touch, showing that short-term feedback can help a bit but doesn’t fix the fundamental planning issue. And giving the agent an external solver was a smart diagnostic move success jumps instantly, proving the bottleneck really is long-term reasoning, not basic logic.\n\nThe paper is also cleanly written and easy to follow. The structure, figures, and summaries make it painless to digest what’s otherwise a pretty complex set of experiments. You can tell the authors put care into making the results interpretable rather than just dumping numbers.\n\nOverall, this is a well-motivated and genuinely insightful piece of work. It’s not just another “benchmark paper” it actually deepens understanding of why LLMs struggle with embodied, physical reasoning. CubeBench feels like something the field could really build on for years, especially for testing new architectures that claim to reason spatially or plan over long horizons.", "weaknesses": "The use of the Rubik’s Cube is smart but narrow it’s a clean test of reasoning, but still a very specific domain. It’s not obvious if the lessons from CubeBench will generalize to other physical problems like robotic manipulation or navigation. A short discussion or even a small test on another environment would make the results feel less domain-locked.\n\nThe heavy reliance on GPT-5 is another weak spot. Since the model isn’t public or well-documented, readers can’t really verify or reproduce much of the analysis. The paper could be clearer about how GPT-5 was accessed and what capabilities it had, especially for the visual tiers. Including more open-source baselines, even weak ones, would make the results more trustworthy.\n\nI also wanted a bit more about how the models behave. The paper hints that GPT-5 sometimes tries tens of thousands of moves or performs better with sequential observations than full maps, but doesn’t dive into why. Some short qualitative analysis what reasoning patterns or blind spots the model shows would add real depth.\n\nAnother missing piece is any attempt to train or adapt the models. The work focuses on evaluation and simple interventions (dense rewards, external solver), but doesn’t test whether fine-tuning or curriculum learning might help. That leaves an open question: are these failures fundamental, or just lack of experience with structured spatial tasks?\n\nOverall, a few clarity nits: “GPT-5” appears without explanation, definitions of “short” vs “long” horizon are easy to miss, and some table cells are left blank without note. Minor, but they add small friction to an otherwise very clean paper.", "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": "FBEiwjJFnU", "reviewer": "Reviewer_zB6V", "summary": "The paper introduces CubeBench, a benchmark designed to evaluate large language model (LLM) agents on spatial and long-horizon reasoning tasks under varying levels of observability. Centered on a Rubik’s Cube environment, CubeBench presents tasks of increasing complexity, defined by the cube’s optimal distance from the solved state. The benchmark comprises two main settings: a fully observable mode, where the agent has access to complete symbolic or visual information, and a partially observable mode, limited to local face or vertex views. The authors further explore how providing dense rewards and external solver tools affects performance, using these interventions to diagnose how effectively agents can represent, aggregate, and reason over spatial information across time.", "questions": "- **No-code (pure reasoning) setting**: Could you add an evaluation mode where the agent is not allowed to write or call code (no programmatic search), and must output only a move sequence (e.g., as a JSON list)? This would isolate the model’s internal state tracking and planning ability from code-based search, which it might recall from pretraining data.\n-  **Difficulty sensitivity and search usage**: Can you provide a plot of state depth vs. performance? Additionally, a histogram of state depth versus the number of moves (or relative number of moves) would help reveal when agents switch from direct planning to search-based strategies.\n - How many runs per state has the model performed? Can you make a few extra runs to verify the consistency of the results?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The choice of the Rubik’s Cube environment is well-motivated, offering a compact yet challenging testbed for spatial reasoning and long-horizon planning, while also enabling automatic verification of solutions.\n - The experimental evaluation is comprehensive, featuring multiple ablations across agent types and settings. The results clearly expose consistent failure modes—particularly in the vertex-level partial observation case—even when solver tools are available, while also highlighting interesting cases where agents learn to use tools in-context.\n - The paper is well-structured and clearly written, making the motivation, methodology, and results easy to follow.", "weaknesses": "-  The benchmark does not exclusively measure an agent’s intrinsic ability to mentally simulate and plan within a spatial model, since it permits writing code that performs explicit search. While this capability can be viewed as part of a general planning process, the paper should make this distinction clearer and discuss its implications for the interpretation of results.\n - The sample size per setting appears quite limited — only 20 states per difficulty–tier combination. It is unclear how many independent runs were conducted per model and configuration; if each setup was evaluated only once, the reported results may not be statistically robust or representative.\n - Reporting performance as #MM is less informative than expressing results as a percentage relative to the optimal path length, which would normalize for differing task difficulties and provide a fairer comparison across samples.\n - The pass rate presentation is inconsistent -- expressed as a percentage in Figure 1 but as absolute counts in Table 2 -- which can be confusing or misleading.\n - The claim of testing \"physical intelligence\" seems overstated, as the benchmark primarily probes spatial reasoning and planning rather than broader aspects of embodied or sensorimotor intelligence. A term like \"spatial intelligence\" would more accurately describe the benchmark’s current scope.", "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": "ETFtAhQLQW", "reviewer": "Reviewer_kiAJ", "summary": "The paper proposed an benchmark named CubeBench. It is a Rubik’s-cube benchmark for LLMs that probes three weak spots:\n- 3-D spatial reasoning\n- Long-horizon state tracking\n- Active exploration under partial views\n\nIt offers three input tiers: (1) full 54-char state, (2) 2-D unfolded map, (3) sparse local views. The authors also try to give dense rewards and use an external solver.\n\nTests on 15+ top models show: everyone fails long scrambles, accuracy tanks when switching from symbols to visuals, dense rewards help only tiny tasks, and even with a solver models can’t reliably rebuild the cube. All code and task generators are open-sourced.", "questions": "If an LLM/VLM works well on CubeBench, can it translate into tangible gains on real-world 3-D embodied tasks (e.g., physical-robot manipulation)? Or can you explain the correlation between CubeBench scores and actual physical-world capabilities?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1.  An interesting task that can test  LLM's spatial reasoning, long horizon, and expoloration abilities. \n2.  Large-scale comparison across 15+ proprietary/open LLMs yields actionable insights for the community.\n3.  Inclusion of dense-reward variants and solver tools makes the dataset usable for both RL and tool-augmented-agent research.", "weaknesses": "1.  Scope limited to a single puzzle; conclusions may not generalize to broader physical reasoning tasks which can be really useful in the real world.", "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": "Md9E92PPkr", "reviewer": "Reviewer_tzUm", "summary": "This paper introduces an interesting benchmark based on Rubik's Cube for evaluating the capability of LLMs. The authors introduced three tracks of tasks: full symbolic, visual, and partial visual. The authors have conducted solid evaluations of LLMs and have also discussed some insightful findings.", "questions": "See weaknesses", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The benchmark is useful in evaluating long-horizon, interactive, and spatial reasoning capabilities of LLMs.\n- The presentation of this paper is good, with clear figures and well-written paragraphs.\n- The evaluation of different LLMs seems to be extensive.", "weaknesses": "1. Lacks performance comparison to classical methods.\nUnlike ARC [1], I think we should have some existing symbolic tools to solve the Rubik's Cube (correct me if I am wrong). What's the performance of them in this benchmark? And \"why\" do we need to consider the problem of \"LLMs can solve them or not\" if symbolic solvers are already very good at this task? (as against in ARC, we don't have performant classical program synthesis methods while human can easily achieve >90%). \n\n2. I am a bit confused by the visual and partial visual tier tasks.\n- For visual tasks, if the image is simply generated with colored grids without any noise, isn't it the same as a symbolic state? As we won't have a grounding issue like discussed in LogiCity [2].\n- For partial visual tasks, I think the agent can easily get the full state by simply turning the columns one by one and rotating them back to the init state, right? Since the Rubik's Cube is deterministic, if LLMs do this, isn't this the same as full-observability? Usually, POMDP is hard because it is very hard/impossible/very inefficient for the agent to get full states, like in LogiCity [2], so I am a bit confused by the setting here. Why is the full state hard to observe?\n\nI will consider raising my score if these two concerns are resolved during rebuttal.\n\n[1] Chollet, Francois, et al. \"Arc prize 2024: Technical report.\" arXiv preprint arXiv:2412.04604 (2024).\n[2] Li, Bowen, et al. \"LogiCity: Advancing neuro-symbolic ai with abstract urban simulation.\" Advances in Neural Information Processing Systems 37 (2024): 69840-69864.", "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)