Pith. sign in

REVIEW 5 major objections 4 minor 5 cited by

BuilderBench claims that open-ended block-building is a tractable benchmark for embodied agents, and that current algorithms fail all non-trivial tasks because they lack genuine exploration.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 11:17 UTC pith:P7RGUUIC

load-bearing objection BuilderBench is a genuinely useful, fast, open-source block-building benchmark, but the headline 'agents fail' claim rests on a task-solvability assumption the paper doesn't yet make airtight. the 5 major comments →

arxiv 2510.06288 v4 pith:P7RGUUIC submitted 2025-10-07 cs.AI cs.LG

BuilderBench: The Building Blocks of Intelligent Agents

Raj Ghugare , Roger Creus Castanyer , Catherine Ji , Kathryn Wantlin , Jin Schofield , Karthik Narasimhan , Benjamin Eysenbach This is my paper
classification cs.AI cs.LG
keywords block-building benchmarkopen-ended explorationembodied reasoningself-supervised reinforcement learningintuitive physicslong-horizon planninggeneralizationlanguage models
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

BuilderBench is a benchmark built around a single idea: an agent should learn to build block structures by exploring and experimenting in a physics simulator, rather than by imitating human data. The paper argues that block-building is a surprisingly rich testbed, since stable construction requires motor control, intuitive physics, geometry, and long-horizon planning, and the task suite is designed so that unseen target structures demand genuinely new combinations of these abilities. The central empirical claim is that current methods—both reinforcement-learning agents trained from scratch and large language models prompted with the environment—cannot solve any of the non-trivial tasks, which the authors read as evidence that today's AI systems lack scalable exploration abilities. If correct, BuilderBench offers a fast, reproducible way to measure progress toward agents that learn through their own experience and generalize beyond their training data.

Core claim

The paper's central claim is that open-ended block-building can serve as a benchmark for generalist agents, and that the resulting tasks are hard for current algorithms in a way that isolates a missing capability: open-ended exploration. Concretely, the environment is a simulated 3D workspace with a two-finger gripper and cube blocks under Newtonian physics; a task is specified only by the target positions of some cubes. The authors manually solved most tasks using the agent's own action space to show they are feasible, and they designed tasks to require distinct abilities such as packing, counterweights, temporary scaffolding, and the maximum-overhang problem. Their experiments show that tw

What carries the argument

The load-bearing object is the BuilderBench environment itself: a hardware-accelerated physics simulator of a robot hand moving in 3D with a 5-dimensional action space, manipulating cube blocks under Newtonian physics. The task suite pairs this simulator with 42 target structures, each specified only as a list of target cube positions; success is measured by a permutation-invariant reward that matches cubes to targets via the Hungarian algorithm, so the agent must learn the physical logic of construction rather than a fixed pick-and-place order. The protocols are the second piece of machinery: a self-supervised multi-task protocol where agents explore without any task specification, and a si

Load-bearing premise

The load-bearing premise is that the non-trivial tasks are genuinely solvable: the authors manually solved most tasks using the agent's own action space, but they report no independent human baseline, admit a small minority they could not solve, and the paper is inconsistent about the task count (abstract says over 50, main text says 42).

What would settle it

Have a group of independent humans attempt the same task suite with the same action space and measure solution rates; if a substantial share of the 'non-trivial' tasks cannot be solved by humans, or if the simulator's stability check rejects structures that are stable by physical standards, then the reported agent failures would reflect artifacts of task design rather than missing exploration abilities.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • If the benchmark is valid, progress in open-ended exploration can be measured quantitatively: a method that solves the self-supervised protocol would demonstrate the ability to discover physical principles through interaction rather than from human data.
  • The failure of current LLMs on the five representative tasks, despite descriptive prompts and an example, implies that language-only pretraining does not yet transfer to embodied construction planning.
  • The single-task 'training wheels' protocol gives researchers a fast debugging loop (the paper reports training a PPO agent to stack two blocks in about 30 minutes on one GPU), so the field can isolate whether a method can represent a solution before tackling the harder self-supervised version.
  • The simulator's speed (roughly 10–100x faster than CPU-based open-ended benchmarks) makes it feasible to run many seeds and ablations, which is important for reliable conclusions about exploration algorithms.
  • The staged difficulty from one cube to nine cubes provides a natural curriculum that could test whether agents that master easy tasks generalize to harder unseen ones.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper does not ablate whether the bottleneck is exploration or low-level control; a natural next experiment would give a privileged agent one successful demonstration per task, and if it still fails, the missing piece is not open-ended exploration but sensorimotor generalization.
  • Because a few tasks have unknown solutions even to the authors, BuilderBench could double as a discovery environment: an agent that solves one of those tasks would be contributing a new construction strategy, not just passing a test.
  • The LLM evaluation only asks for open-loop language plans with no simulator feedback; a more interactive protocol that lets a model propose an action, observe the result, and revise might reveal whether the deficit is planning or the lack of closed-loop grounding.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

5 major / 4 minor

Summary. BuilderBench introduces a hardware-accelerated MuJoCo/JAX block-building environment with 42 target tasks, together with two evaluation protocols: a multi-task self-supervised protocol and a single-task supervised 'training wheels' protocol. The paper reports that unsupervised goal-sampling algorithms (SFL, MEGA), standard RL algorithms (PPO, SAC, CRL, RND), and two proprietary LLMs fail on the non-trivial tasks, and interprets this as evidence that current agents lack open-ended exploration and embodied reasoning. The manuscript also provides open-source code, task visualizations, prompts, and single-file baseline implementations.

Significance. If the central claim is valid, BuilderBench is a useful and timely benchmark: it is fast, physically grounded, and designed around tasks that require composing motor control, geometric reasoning, and long-horizon planning. The authors are to be credited for releasing the simulator, task suite, exact LLM prompts, and single-file implementations, and for being transparent about tasks they could not solve. The main contribution is the artifact plus an initial negative result; the value of the benchmark depends on the tasks being genuinely solvable and the success metric correctly detecting stable goal achievement. These are currently not established to the standard needed for the paper's headline claim.

major comments (5)
  1. [Section 5.2 and Appendix A.2] The paper's load-bearing claim is that current agents fail on non-trivial tasks because the tasks are solvable but require exploration and reasoning. The only evidence of solvability is the authors' statement that they 'manually solved most tasks using the same action space as the agent,' plus an admission that 'a small minority of tasks which we were not able to solve.' No oracle policies, solution trajectories, or independent human baselines are provided. Given that the success criterion in A.2 is a 2 cm instantaneous position tolerance, it is possible that some tasks are not solvable under that exact metric (e.g., contact jitter or gripper constraints). I request that the authors release and run a solution script/trajectory for every task used in benchmarking, and verify each one triggers the 2 cm success condition in the released simulator. Without this, the negative results are not
  2. [Section 7, Figures 6 and 7] The experimental evidence covers 12 of the 42 tasks in the self-supervised protocol (one to three cubes) and 17 of the 42 in the supervised protocol (one to four cubes). The abstract and intro state that agents 'cannot solve any of the non-trivial tasks' in BuilderBench, but this is not established for the full task suite, and Figure 7 reports nonzero success on low-cube tasks. The claim should be scoped to the evaluated subset (e.g., 'the tasks we tested,' 'tasks with three or more cubes') or the full suite should be benchmarked. As written, the conclusion overstates the evidence.
  3. [Section 7.1 and Appendix C] The LLM evaluation is limited to five text-planning prompts given to two models. These are open-loop, language-only plans; the models cannot take actions, observe outcomes, or explore. The paper concludes that solving tasks requires 'non-obvious steps of reasoning,' but the experiment does not measure exploration at all, and a negative result on five prompts does not support the broad claim that frontier LLM-based agents cannot solve any non-trivial BuilderBench task. I recommend presenting this as a pilot study and either adding closed-loop LLM-agent evaluations or softening the corresponding claims.
  4. [Section A.2 and Section 5.2] The reward definition declares success when all cubes are within 2 cm of their assigned targets at a single timestep. The task descriptions in Section 5 and the LLM prompts emphasize that the target structure must be stable and must not fall apart under minimal perturbation. The current metric does not verify sustained stability. A configuration that is briefly aligned during a fall, or one that is stable but settles just outside 2 cm due to physics jitter, would be scored incorrectly. Since the paper uses this threshold for all agent evaluations and for human solvability, I ask for a stability-sustained success criterion and a short sensitivity analysis of the 2 cm threshold, especially for the harder multi-cube tasks.
  5. [Section 8] The Limitations section acknowledges missing algorithmic baselines but does not address the solvability and metric-validation concerns above. Given that these concerns directly affect the interpretation of every reported failure, they should be addressed explicitly in the limitations and, more importantly, in the benchmark release.
minor comments (4)
  1. [Abstract/Contributions] The number of tasks is reported inconsistently: the abstract says 'over 42,' Section 5 says '42 tasks,' and the contributions say 'over 40.' Also, the abstract says 'six different algorithms' while the contributions list four RL plus three self-supervised algorithms (seven total). Please harmonize these counts.
  2. [Figure 7] The legend is absent or incomplete: the caption mentions PPO, RND, SAC, and CRL, but the curves are not labeled in the figure text. Also, the y-axis for normalized return appears to start at 0.5; please clarify the normalization and provide error bars or per-seed curves, since the text says all results are across three seeds.
  3. [Section B] The speed comparison relies on previously published numbers from Matthews et al. and is described as 'not precise.' Please report the exact hardware/software configuration and, if possible, include a one-row table comparing measured FPS on the same GPU for at least one external environment.
  4. [Section 6] The self-supervised protocol states that the policy takes 'a state (R^{11+13n}) as well as a task specification (R^{3k}).' It would be clearer to explain how the task specification is injected (concatenation, FiLM, etc.) and how the agent handles tasks with k < n cubes.

Circularity Check

0 steps flagged

No significant circularity: BuilderBench is an empirical benchmark artifact, and the headline negative results are produced by externally defined algorithms rather than being forced by construction or by self-citation.

full rationale

The paper's central claims are that BuilderBench provides a fast simulator and diverse block-building tasks, and that current algorithms fail on nontrivial tasks. These are empirical claims about a newly constructed benchmark, not mathematical derivations whose conclusions are wired into their inputs. The task targets are hand-specified coordinates; rewards are defined in Section A.2 by a distance tolerance; and the agent failures are measured, not inferred from any fitted parameter. The only self-citations that appear (e.g., Eysenbach et al. 2019, 2022) are used as standard baseline algorithms and prior skill-learning references, and the benchmark's validity does not depend on these methods succeeding. The closest potential concern is Section 5.2's statement that 'we manually solved most tasks using the same action space as the agent' and the admission of 'a small minority of tasks which we were not able to solve.' This is a solvability-verification gap that bears on benchmark validity and could be flagged as a correctness/evidence risk, but it is not circularity: the benchmark's challenge is not derived from the same data used to define success, and the unsolved tasks are honestly disclosed rather than hidden. Section 8 similarly lists missing baselines as a limitation, which is a completeness remark, not a circular step. No uniqueness theorem, no fit-then-predict reduction, and no ansatz-via-self-citation chain is present. Accordingly, the appropriate finding is no significant circularity, score 0.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 0 invented entities

The central claim relies on no fitted physical constants or invented entities. The load-bearing free parameters are evaluation-protocol choices—success tolerance, episode lengths, and reward shaping—because they trade off between 'too easy' and 'mechanically impossible' and can dominate whether an agent is scored as failing. The axioms are domain assumptions about simulator fidelity, human solvability, geometric success criteria, and the validity of text-planning evaluation.

free parameters (3)
  • Success distance threshold = 0.02 m
    Defines when cubes count as forming the target structure; directly sets measured success rates and task hardness (Appendix A.2).
  • Episode length = 100 + 100N (supervised); 500N (self-supervised)
    Hand-chosen horizon limits affect feasibility for RL agents and can mechanically produce failure regardless of agent capability (Appendix A.1).
  • Dense reward shaping = 1 - tanh(assigned distance), summed over cubes
    The choice of reward transform shapes the optimization landscape for all RL baselines and influences measured progress (Appendix A.2).
axioms (4)
  • domain assumption MuJoCo rigid-body dynamics accurately capture the physical stability of block structures
    The benchmark measures physics reasoning through simulated stability; if the simulator is miscalibrated, success and failure signals are distorted (Section 4).
  • domain assumption Author manual solutions demonstrate that tasks are solvable by humans
    Section 5.2 says 'we manually solved most tasks'; no independent participant baseline is provided, and some tasks are admitted unsolved.
  • domain assumption The 2 cm geometric tolerance plus Hungarian cube-target assignment measures the intended building ability
    Success is defined by center positions, not by structural stability after perturbation, so an unstable arrangement could be counted as built (Appendix A.2).
  • domain assumption Open-loop language planning is a meaningful proxy for embodied reasoning in LLM evaluation
    Section 7.1 gives models only text prompts and asks for a high-level plan without simulator interaction; failure in this setting may not generalize to closed-loop embodied use.

pith-pipeline@v1.3.0-alltime-deepseek · 24032 in / 9251 out tokens · 67575 ms · 2026-08-04T11:17:07.590028+00:00 · methodology

0 comments
read the original abstract

Today's AI models learn primarily through mimicry and refining, so it is not surprising that they struggle to solve problems beyond the limits set by existing data. To solve novel problems, agents should acquire skills by exploring and learning through experience. Finding a scalable learning mechanism for developing agents that learn through interaction remains a major open problem. In this work, we introduce BuilderBench, a benchmark to accelerate research into agent training that centers open-ended exploration. BuilderBench requires agents to learn how to build any structure using blocks. BuilderBench is equipped with (1) a simulator of a robot interacting with various physical blocks, and (2) a task-suite with over 50 diverse target structures that are carefully curated to test an understanding of physics, mathematics, and long-horizon planning. Agents are provided with a target structure at the start, and can interact with the environment for multiple episodes to experiment and learn various skills for building the structure. Solving these tasks requires \emph{embodied reasoning} in a way that is not reflected in words but rather in actions, experimenting with different strategies and piecing them together. Our experiments with multiple state-of-the-art frontier language model based agents and tabula rasa reinforcement learning algorithms show that these agents cannot solve any of the non-trivial tasks in the BuilderBench. Our analysis throws light on the lack of exploration abilities in these models.

Figures

Figures reproduced from arXiv: 2510.06288 by Benjamin Eysenbach, Catherine Ji, Jin Schofield, Karthik Narasimhan, Kathryn Wantlin, Raj Ghugare, Roger Creus Castanyer.

Figure 1
Figure 1. Figure 1: The BuilderBench Benchmark. (Top Left) Training consists of self-supervised exploration: agents can collect data to learn to reach various goals via trial and error. Agents are not given any information about the test-time goals or their distribution. (Right) During evaluation, the agent is given a goal and attempts to reach that goal by taking actions in the environment. (Bottom Left) For prototyping, we … view at source ↗
Figure 2
Figure 2. Figure 2: T-Block (Left) and Four Cube Packing (Right) Example 1: T-Block. This task requires building a simple T shaped structure with one cube at the base, and two cubes on top ( [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Hexagonal Portal Example 3: Hexagonal Portal. This task requires constructing a hexagonal, portal-like structure using eight cubes and two extra cubes placed on the floor on either side. ( [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Leaning Tower Example 4: Leaning Tower. The target is a leaning tower composed of seven blocks and two extra cubes placed on the floor (see (A) of [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Maximum overhang problem Example 5: Maximum Overhang Problem. In this task, the environment contains five cubes, but the task only specifies the target positions for three cubes (see (A) of [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Self-supervised evaluation on BuilderBench task-suite. We evaluate MEGA (Pitis et al., 2020) and SFL (Rutherford et al., 2024) on 12 of the lowest complexity (yet still difficult) tasks from our task suite. The results show that directly using these algorithms out of the box only succeeds for the simplest tasks. 0 1 2 0.0 0.5 1.0 normalized success cube-1 (2 tasks) 0 1 2 0.0 0.5 1.0 cube-2 (5 tasks) 0 1 2 … view at source ↗
Figure 7
Figure 7. Figure 7: Training on the test goals. Training on the test goals improves both the returns and success achieved by the best agents. However as the number of cubes and the complexity of the tasks increase, current algorithms are not able to achieve a non zero success. Although this setup does not directly evaluate generalization, it makes the problem of building gen￾eral agents much more approachable. For instance, r… view at source ↗
Figure 8
Figure 8. Figure 8: Evaluating language models on Builder￾Bench. Task Name ChatGPT-5 Gemini 2.5 Pro T block ✗ ✗ Four cube packing ✗ ✗ Hexagonal Portal ✗ ✗ Leaning tower ✗ ✗ Maximum Overhang ✗ ✗ Each model was provided with a descrip￾tive prompt about the environment and the task. The goal of the model was to pro￾vide a high-level open-loop plan in lan￾guage, such that following this plan would stably build the target structur… view at source ↗
Figure 9
Figure 9. Figure 9: Environment steps per second during PPO and MEGA training runs In [PITH_FULL_IMAGE:figures/full_fig_p017_9.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 5 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Agentic World Modeling: Foundations, Capabilities, Laws, and Beyond

    cs.AI 2026-04 unverdicted novelty 7.0

    Proposes a levels x laws taxonomy for world models in AI agents, defining L1-L3 capabilities across physical, digital, social, and scientific regimes while reviewing over 400 works to outline a roadmap for advanced ag...

  2. LeAct: Learning to Reason from Expert Actions

    cs.LG 2026-07 conditional novelty 6.0

    An AI can learn to reason by sampling explanations for an expert's actions and keeping only the ones that help it predict those actions.

  3. Goal-Conditioned Agents that Learn Everything All at Once

    cs.LG 2026-05 unverdicted novelty 6.0

    LEO enables efficient all-goals learning in goal-conditioned RL by jointly predicting for all goals in one network pass, yielding >250x speedup over relabelling and better performance on Craftax.

  4. Interactive Evaluation Requires a Design Science

    cs.AI 2026-05 unverdicted novelty 5.0

    Interactive evaluation of AI must be reframed as a distinct paradigm that maps interaction trajectories to judgments on process, recoverability, coordination, robustness, and system performance, supported by a two-axi...

  5. Agentic World Modeling: Foundations, Capabilities, Laws, and Beyond

    cs.AI 2026-04 conditional novelty 4.0

    A survey proposing a three-level capability taxonomy (L1 Predictor, L2 Simulator, L3 Evolver) for world models across physical, digital, social, and scientific domains.

Reference graph

Works this paper leans on

63 extracted references · 5 linked inside Pith · cited by 4 Pith papers

  1. [2]

    Final answer:

    Place the cube at [0.1, 0.0, 0.02] with a yaw of 0 radians. Here is the task: N = 3 K = 3 Start location = [ [ 0.05, -0.08, 0.02], [ 0.05, 0. , 0.02], [ 0.05, 0.08, 0.02] ] Target location = [ [ 0.1, 0.02, 0.06], [ 0.1 , -0.02, 0.06], [ 0.1 , 0. , 0.02] ] ChatGPT-5 Pick up the cube from [0.05, 0.0, 0.02]. Place the cube at [0.1, 0.0, 0.02] with a yaw of 0...

  2. [3]

    Motor skills cube-2-task4

  3. [4]

    Motor skills cube-9-task4

  4. [5]

    Final answer:

    URLhttps://api.semanticscholar.org/CorpusID:204972004. Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. Emergent abilities of large lan- guage models.Transactions on Machine L...

    Pith/arXiv arXiv 2022

  5. [9]

    Final answer:

    Place the cube at [0.1, 0.0, 0.02] with a yaw of 0 radians. Here is the task: N = 4 K = 4 Start location = [ [0.05, -0.12, 0.02], [0.05, -0.04, 0.02], [0.05, 0.04, 0.02], [0.05, 0.12, 0.02] ] Target location = [ [0.1, 0.02828427, 0.02], [0.1, -0.02828427, 0.02], [0.12828427, 0.0, 0.02], [0.07171573, 0.0, 0.02] ] ChatGPT-5 Pick up the cube from [0.05, -0.1...

  6. [11]

    Final answer:

    Place the cube at [0.1, 0.0, 0.02] with a yaw of 0 radians. Here is the task: N = 8 K = 8 Start location = [ [0.05, -0.24, 0.02], [0.05, -0.18, 0.02], [0.05, -0.12, 0.02], [0.05, -0.04, 0.02], [0.05, 0.04, 0.02], [0.05, 0.12, 0.02], [0.05, 0.18, 0.02], [0.05, 0.24, 0.02] ] Target location = [ [0.1, 0.02, 0.02], [0.1, -0.02, 0.02], [0.1, 0.04, 0.06], [0.1,...

  7. [13]

    Final answer:

    Place the cube at [0.1, 0.0, 0.02] with a yaw of 0 radians. Here is the task: N = 9 K = 9 Start location = [ [0.05, -0.3, 0.02], [0.05, -0.24, 0.02], [0.05, -0.16, 0.02], [0.05, -0.08, 0.02], [0.05, 0.0, 0.02], [0.05, 0.08, 0.02], [0.05, 0.16, 0.02], [0.05, 0.24, 0.02], [0.05, 0.3, 0.02] ] Target location = [ [0.1, 0.0, 0.02], [0.1, -0.04, 0.02], [0.1, 0....

  8. [14]

    Pick up the cube from [0.05, 0.0, 0.02]

  9. [15]

    Place the cube at [0.1, 0.0, 0.02] with a yaw of 0 radians. Here is the task: N = 5 K = 3 Start location = [ [0.05, -0.16, 0.02], [0.05, -0.08, 0.02], [0.05, 0.0, 0.02], [0.05, 0.08, 0.02], [0.05, 0.16, 0.02] ] Target location = [ [0.1, 0.0, 0.02], [0.1, 0.031, 0.14], [0.1, 0.16, 0.14] ] ChatGPT-5 Pick up the cube from [0.05, 0.0, 0.02]. Place the cube at...

  10. [16]

    Pick and Place cube-1-task2

  11. [17]

    Task nameTask visualizationAbilities cube-2-task1

    Pick and hold Table 1:Tasks with 1 cube. Task nameTask visualizationAbilities cube-2-task1

  12. [18]

    Motor skills cube-2-task2

  13. [19]

    Motor skills cube-2-task3

  14. [23]

    Motor skills cube-2-task5

  15. [24]

    Two cube lift maneuver

  16. [25]

    28 Task nameTask visualizationAbilities cube-3-task1

    Motor skills Table 2:Tasks with 2 cubes. 28 Task nameTask visualizationAbilities cube-3-task1

  17. [26]

    Motor skills cube-3-task2

  18. [27]

    Motor skills cube-3-task3

  19. [28]

    Three cube lift maneuver

  20. [29]

    Motor skills cube-3-task4

  21. [30]

    Solving a packing problem

  22. [31]

    Motor skills cube-3-task5

  23. [33]

    29 Task nameTask visualizationAbilities cube-4-task1

    Motor skills Table 3:Tasks with 3 cubes. 29 Task nameTask visualizationAbilities cube-4-task1

  24. [34]

    Motor skills cube-4-task2

  25. [35]

    Motor skills cube-4-task3

  26. [36]

    Solve a packing problem

  27. [37]

    Motor skills cube-4-task4

  28. [38]

    Unconstrained Maximum overhang

  29. [39]

    Motor skills cube-4-task5

  30. [41]

    30 Task nameTask visualizationAbilities cube-5-task1

    Motor skills Table 4:Tasks with 4 cubes. 30 Task nameTask visualizationAbilities cube-5-task1

  31. [42]

    Motor skills cube-5-task2

  32. [43]

    Motor skills cube-5-task3

  33. [44]

    Motor skills cube-5-task4

  34. [45]

    Motor skills cube-5-task5

  35. [47]

    31 Task nameTask visualizationAbilities cube-6-task1

    Motor skills Table 5:Tasks with 5 cubes. 31 Task nameTask visualizationAbilities cube-6-task1

  36. [48]

    Motor skills cube-6-task2

  37. [49]

    Motor skills cube-6-task3

  38. [50]

    Motor skills cube-6-task4

  39. [51]

    Building support structures

  40. [52]

    Motor skills cube-6-task5

  41. [54]

    32 Task nameTask visualizationAbilities cube-7-task1

    Motor skills Table 6:Tasks with 6 cubes. 32 Task nameTask visualizationAbilities cube-7-task1

  42. [55]

    Motor skills cube-7-task2

  43. [57]

    Motor skills cube-7-task3

  44. [59]

    Motor skills cube-7-task4

  45. [61]

    Motor skills cube-7-task5

  46. [63]

    33 Task nameTask visualizationAbilities cube-8-task1

    Motor skills Table 7:Tasks with 7 cubes. 33 Task nameTask visualizationAbilities cube-8-task1

  47. [64]

    Motor skills cube-8-task2

  48. [66]

    Motor skills cube-8-task3

  49. [68]

    Motor skills cube-8-task4

  50. [69]

    Temporary bi-scaffolding

  51. [70]

    Motor skills cube-8-task5

  52. [71]

    34 Task nameTask visualizationAbilities cube-9-task1

    Motor skills Table 8:Tasks with 8 cubes. 34 Task nameTask visualizationAbilities cube-9-task1

  53. [72]

    Motor skills cube-9-task2

  54. [73]

    Motor skills cube-9-task3

  55. [74]

    Temporary mono-scaffolding

  56. [76]

    Temporary tri-scaffolding

  57. [77]

    Motor skills cube-9-task5

  58. [78]

    Building a support structure

  59. [79]

    Motor skills Table 9:Tasks with 9 cubes. 35

  60. [2007]

    Silviu Pitis, Harris Chan, Stephen Zhao, Bradly Stadie, and Jimmy Ba

    URLhttps://arxiv.org/abs/0707.0093. Silviu Pitis, Harris Chan, Stephen Zhao, Bradly Stadie, and Jimmy Ba. Maximum entropy gain exploration for long horizon multi-goal reinforcement learning. InProceedings of the 37th Inter- national Conference on Machine Learning, ICML’20. JMLR.org, 2020. Matthias Plappert, Marcin Andrychowicz, Alex Ray, Bob McGrew, Bowen...

    Pith/arXiv arXiv 2020

  61. [2014]

    Yi-Ling Cheng and Kelly S Mix

    URLhttps://arxiv.org/abs/1312.3005. Yi-Ling Cheng and Kelly S Mix. Spatial training improves children’s mathematics ability.Journal of cognition and development, 15(1):2–11, 2014. Franc ¸ois Chollet. On the measure of intelligence, 2019. URLhttps://arxiv.org/abs/ 1911.01547. Wei Chow, Jiageng Mao, Boyi Li, Daniel Seita, Vitor Campagnolo Guizilini, and Yue...

    Pith/arXiv arXiv 2014

  62. [2018]

    Danijar Hafner

    URLhttps://proceedings.mlr.press/v80/haarnoja18b.html. Danijar Hafner. Benchmarking the spectrum of agent capabilities, 2022. URLhttps://arxiv. org/abs/2109.06780. Danijar Hafner, Jurgis Pasukonis, Jimmy Ba, and Timothy Lillicrap. Mastering diverse domains through world models, 2024. URLhttps://arxiv.org/abs/2301.04104. Edward Hughes, Michael D Dennis, Ja...

    Pith/arXiv arXiv 2022

  63. [2019]

    Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine

    URLhttps://arxiv.org/abs/1907.13440. Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Jennifer Dy and An- dreas Krause (eds.),Proceedings of the 35th International Conference on Machine Learning, volume 80 ofProceedings of Machine Learning ...

    Pith/arXiv arXiv 1907