Pith. sign in

REVIEW 4 major objections 5 minor 31 references

Adaptive Domain Modeling with Language Models: A Multi-Agent Approach to Task Planning

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read LLM agents can build and repair a robot's planning model on demand, letting a classical planner solve tasks whose requirements were never predefined.

desk verdict TAPAS is a genuinely orchestrated multi-agent system for generating and adapting planning domains, but the central 'no manual models' claim is not yet quantitatively supported because the benchmark bypasses domain generation. read the letter →

arxiv 2506.19592 v2 pith:IYBD6BJ6 submitted 2025-06-24 cs.AI cs.RO

Harisankar Babu , Philipp Schillinger , Tamim Asfour This is my paper
classification cs.AIcs.RO
keywords taskplanninglargelanguagemodelsmulti-agentsystemssymbolicdomainadaptationnaturalgoalspecificationplanexecution
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper presents TAPAS, a system in which several large-language-model agents jointly turn a natural-language task description into a complete symbolic planning model, and then repair that model when the goal demands information it does not yet contain. The central claim is that adaptable symbolic planning can work without hand-written environment models: if a goal mentions a property such as color, size, or battery level, a downstream agent detects the missing fluent and asks an upstream agent to add it, so a classical planner can still find a correct plan. The authors report strong results on seven standard benchmark planning domains and show that adding novel constraints to blocksworld, grippers, and floortile succeeds in 70 to 100 percent of trials. If this holds, robots could take direct language commands and acquire a sound, verifiable plan without a human pre-coding the world model.

What carries the argument

The load-bearing object is the tool-mediated, bottom-up adaptation loop: the goal and initial-state agents hold structured tools such as 'add or fix a fluent' (a fluent being a state attribute like color or battery level), 'modify an action', and 'add missing objects', and they call these tools on upstream agents whenever the goal needs information the current model lacks. That request chain, sometimes ending in a user query for attribute values, rewrites the domain code before the symbolic solver runs. The execution half is a complementary decoupling mechanism: the solver's structured plan is translated into natural-language instructions, and a reason-and-act agent with a validator maps those instructions onto the robot's available skills.

What would settle it

Present a task whose goal mentions an attribute whose values are nowhere in the provided text, and block all user queries; if the solver nonetheless returns a valid plan, the adaptation claim holds for that setting, while an assumed or invented value, as happened in the floortile battery runs, would falsify it.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that the bottleneck to combining large language models with symbolic planning is not the solver but the model-building step, and that this step can be handled by a division of labor among specialized LLM agents that are allowed to change each other's outputs through tool calls. The Domain Generator writes code for types, fluent attributes, and actions; the Initial State Generator writes the environment description; the Goal State Generator writes the goal and, when the goal refers to predicates the model lacks, calls a missing-attribute tool that propagates the needed change upstream. The same mechanism updates action preconditions and effects, as when a size attribute changes the stacking rule or battery consumption changes movement and painting behavior. With this loop in place, the paper reports an average success rate of 88.42 percent across the seven benchmark domains at temperature 0.0, and 70 to 100 percent success on goals that introduce attribute types absent from the original domain model.

Load-bearing premise

Everything hinges on the LLM agents reliably recognizing when a goal needs a new attribute and phrasing the repair correctly, and the paper's own floortile and tyreworld failures show that recognition is not always reliable.

Editorial extensions

If this is right

  • Symbolic planners can be used on families of tasks that previously required an expert to hand-write the domain, because the domain code can be generated and revised automatically.
  • Natural-language goals that introduce novel attributes can be turned into executable plans without changing the planner itself; only the model representation is updated.
  • Generated plans are not tied to robot-specific skill names, since a natural-language abstraction layer plus a reason-and-act executor grounds them in whatever skills are available.
  • Explicit user feedback can be stored in a procedural memory and reapplied to later tasks, as demonstrated by the fridge-closing rule in the simulated execution.
  • Overall accuracy tracks the underlying LLM's code-generation reliability, so choosing a strong model and a low sampling temperature matters more than the planner details.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural next test is to measure how often the goal generator's missing-attribute requests are false positives; the paper reports robustness here, but quantifying the false-request rate would let a user set trust thresholds.
  • The tool-call interface could be extended to other model edits, such as removing obsolete fluents or merging redundant actions, which the current design does not explicitly do.
  • Because the domain model is produced as code, a compiler-style validation, such as type checking or checking whether the goal is reachable from the initial state, could catch adaptation mistakes before execution, complementing the LLM critic.
  • The procedural-memory retrieval may pull in superficially matching but irrelevant feedback; in deployment, a stricter gating criterion, such as requiring user confirmation, could reduce that risk.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper introduces TAPAS, a multi-agent framework in which specialized LLM agents generate and iteratively repair a symbolic planning domain model, initial state, and goal specification from natural-language descriptions, with a Unified Planning-based solver and a ReAct-style executor that translates and grounds plans for robot execution. The core claim is that this removes the need for manually defined environment models while retaining the soundness of classical planning. The paper reports planning accuracy on seven LLM+P benchmark domains (Table I), temperature and model ablations (Table II), small-scale experiments on novel goal constraints (Table III), and a qualitative VirtualHome execution demonstration with a procedural-memory anecdote.

Significance. If the central claim is substantiated, TAPAS addresses a genuine bottleneck in symbolic planning: the manual engineering of domain models. The architecture is modular and the tool-mediated upward feedback (from goal/initial-state generators to the domain generator) is a clean way to realize automatic domain adaptation. The paper includes useful ablations across multiple LLMs and temperatures, and it reports concrete failure cases. However, the headline quantitative evidence does not currently measure the full generate-then-plan pipeline: Table I is computed with pre-generated correct domains, so the paper's central capability of autonomous domain modeling is supported only qualitatitively. The contribution is promising and the direction is timely, but the evidence as presented is not yet sufficient to support the abstract's strong claim of solving tasks 'without the need for manually defined environment models.'

major comments (4)
  1. [Section V-A.b, Tables I and II] The headline accuracy numbers do not evaluate the full system. The text states that 'the successfully generated domain for each benchmark was provided directly, bypassing the initial domain generation stage,' so the 88.42% average and the model/temperature comparisons in Tables I and II measure initial-state generation, goal generation, and planning conditional on a correct domain. The paper's abstract and conclusion attribute this number to the framework as a whole, but the central claim of autonomous domain modeling is not quantified end-to-end. Please provide per-domain domain-generation accuracy (e.g., fraction of generated domains matching the ground-truth domain, and the downstream planning accuracy when using the actually generated domains), or substantially qualify the claim to state that the benchmark evaluates only downstream stages.
  2. [Section V-A.a/b, validation procedure] The evaluation says that 'solutions were validated against ground-truth data,' but the validation procedure is not described. It is unclear whether a plan is counted as correct when it is executable and achieves the goal, when it matches a reference plan, or when it matches an optimal plan length from the LLM+P benchmark. Without this definition the numbers in Table I cannot be reproduced or properly interpreted. Please specify the correctness criterion and, ideally, provide the validation script or a plan validator used.
  3. [Section V-B, Table III] The adaptation experiments, which are the principal evidence for the paper's key novelty, use only five problems per constraint type (four sets of five problems). With n=5 per condition, the reported success rates (e.g., 70% for floortile battery) are single proportions with wide binomial confidence intervals, and no statistical comparison is offered. Please increase the number of test problems per constraint and report confidence intervals or exact binomial intervals, or otherwise temper the claim that TAPAS 'demonstrated the ability to modify core action logic' on this basis.
  4. [Section V-C] The VirtualHome evaluation is a single qualitative demonstration: one task sequence with screenshots and no repeated runs, no task success rate, and no quantitative measures of execution failures, validator corrections, or plan-repair events. This supports feasibility but not 'strong performance in benchmark planning domains and in the VirtualHome simulated real-world environment' as stated in the abstract. Either report quantitative execution results over multiple runs or limit the claim to a demonstration of feasibility.
minor comments (5)
  1. [Table I] The number of repetitions is specified only for GPT-4o (two repetitions); for the other models in Table I the repetition count is not stated. Please state the number of runs for every model.
  2. [Table II caption] The caption contains a typo: 'T emperature' should be 'Temperature.' Also, the number of runs for temperatures 0.1 and 0.3 is not given; the text only says 'multiple runs'.
  3. [Figure 6] The caption says 'Modification of the generated PDDL domain (bottom)' but the figure shows a diff with plus/minus markers; please explain in the caption that plus lines are added and minus lines are removed.
  4. [Section V-A.a] The statement that downstream agent feedback was 'primarily limited to the barman domain' is in tension with Section V-A.b, which describes false positive modification requests in floortile and tyreworld; the relation between these two observations should be clarified.
  5. [General] The conclusion repeats 'an 88.42% success rate across diverse benchmark planning domains' without the qualification that this rate was obtained with pre-generated domains; the abstract and conclusion should be aligned with the actual evaluation conditions.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the benchmark and adaptability results are empirical and independent of the cited prior work.

full rationale

This is an empirical systems paper rather than a derivation, and no claimed result reduces by construction to a fitted parameter, a self-citation, or an ansatz. The central benchmark evidence in Table I measures planning accuracy after domain generation, and although Section V-A.b states that the successfully generated domain was 'provided directly, bypassing the initial domain generation stage,' this is an evaluation-scope limitation, not a circular step: the reported accuracy is not defined in terms of the framework's own outputs in a way that forces the result. The adaptability experiments in Table III and the VirtualHome execution are independent demonstrations of the claimed mechanism, with failures in floortile and tyreworld reported honestly. The only self-citations are to prior related work such as AutoGPT+P [24] and Makeable [26]; these are contextual references and are not used to justify the paper's central claim. No equation is fitted to data and no prediction is statistically forced, so the appropriate finding is no significant circularity.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The paper is an engineering system evaluation, so there are no fitted physical constants. The main hand-set values are the recursion limit, temperature, and an unreported quality threshold. The framework relies on LLM reliability and benchmark assumptions rather than on new physical entities.

free parameters (3)
  • Quality threshold tau = not specified
    The critic accepts a generated response only when its self-assessment score sigma meets tau; the paper never reports the value used, so the acceptance behavior of the refinement loop is underspecified.
  • Recursion limit = 10
    Maximum iterative refinement steps before the system proceeds with the latest response; this trades robustness for cost and can affect final domain, state, and goal definitions.
  • Temperature = 0.0
    Used for the main evaluation; ablations at 0.1 and 0.3 change success rates by more than 10 points in some domains, so this choice matters for the reported results.
assumptions (4)
  • domain assumption Natural language problem descriptions contain enough information to infer a correct, complete PDDL domain model.
    Section III-A: the Domain Generator converts a natural language description into domain code; if descriptions omit needed constraints, generated domains will be incomplete.
  • domain assumption Ground-truth solution comparison in the LLM+P benchmark validates plan correctness.
    Section V-A says solutions were validated against ground-truth data; the paper does not describe the validation procedure or show generated domains.
  • domain assumption The LLM critic's self-assessment score reflects actual output quality.
    Section III-B2 uses a critic to score sigma; acceptance depends on an LLM's own judgment, which can be miscalibrated.
  • domain assumption LLM agents can reliably distinguish missing fluents from already-represented ones.
    Section III-A: the Goal State Generator invokes tools to add missing fluents; Section V-A documents false positives and wrong interpretations.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Adaptive Domain Modeling with Language Models: A Multi-Agent Approach to Task Planning." pith.science (2026). https://pith.science/paper/IYBD6BJ6

@misc{pith2026250619592,
  author       = {Pith},
  title        = {Pith review of: Adaptive Domain Modeling with Language Models: A Multi-Agent Approach to Task Planning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IYBD6BJ6}},
  note         = {Machine review of arXiv:2506.19592}
}
read the original abstract

We introduce TAPAS (Task-based Adaptation and Planning using AgentS), a multi-agent framework that integrates Large Language Models (LLMs) with symbolic planning to solve complex tasks without the need for manually defined environment models. TAPAS employs specialized LLM-based agents that collaboratively generate and adapt domain models, initial states, and goal specifications as needed using structured tool-calling mechanisms. Through this tool-based interaction, downstream agents can request modifications from upstream agents, enabling adaptation to novel attributes and constraints without manual domain redefinition. A ReAct (Reason+Act)-style execution agent, coupled with natural language plan translation, bridges the gap between dynamically generated plans and real-world robot capabilities. TAPAS demonstrates strong performance in benchmark planning domains and in the VirtualHome simulated real-world environment.

Figures

Figures reproduced from arXiv: 2506.19592 by the authors.

Figure 1
Figure 1. TAPAS dynamically adapts domain models to ac [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Multi-LLM-agent planning framework overview. The [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Agent tools for modifying domain and initial state. [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: A structured plan translated into natural language. [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 6
Figure 6. Figure 6: Automatic modification of the generated PDDL domain [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: Explicit user feedback for the procedural memory. [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]
Figure 8
Figure 8. Figure 8: Plan execution in VirtualHome: The humanoid agent sequentially interacts with objects to complete the task. (a) Opening [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 23 canonical work pages

  1. [1]

    Chain-of-thought prompting elicits rea- soning in large language models,

    J. Wei, X. Wang, D. Schuurmans, M. Bosma, b. ichter, F. Xia et al. , “Chain-of-thought prompting elicits rea- soning in large language models,” in Advances in Neural Information Processing Systems, vol. 35, 2022, pp. 24 824– 24 837

    work page 2022

  2. [2]

    Large language models are zero-shot reasoners,

    T. Kojima, S. S. Gu, M. Reid, Y. Matsuo, and Y. Iwa- sawa, “Large language models are zero-shot reasoners,” in Advances in Neural Information Processing Systems , vol. 35, 2022, pp. 22 199–22 213

    work page 2022

  3. [3]

    Tree of thoughts: Deliberate prob- lem solving with large language models,

    S. Yao, D. Yu, J. Zhao, I. Shafran, T. Griffiths, Y. Cao, and K. Narasimhan, “Tree of thoughts: Deliberate prob- lem solving with large language models,” in Advances in Neural Information Processing Systems, vol. 36, 2023, pp. 11 809–11 822

    work page 2023

  4. [4]

    Graph of thoughts: Solving elaborate problems with large language models,

    M. Besta, N. Blach, A. Kubicek, R. Gerstenberger, M. Podstawski, L. Gianinazzi et al., “Graph of thoughts: Solving elaborate problems with large language models,” Proc. of the AAAI Conf. on Artificial Intelligence , vol. 38, no. 16, pp. 17 682–17 690, Mar. 2024

    work page 2024

  5. [5]

    Lan- guage models as zero-shot planners: Extracting actionable knowledge for embodied agents,

    W. Huang, P. Abbeel, D. Pathak, and I. Mordatch, “Lan- guage models as zero-shot planners: Extracting actionable knowledge for embodied agents,” in Proc. of the 39th Int. Conf. on Machine Learning , vol. 162, 17–23 Jul 2022, pp. 9118–9147

    work page 2022

  6. [6]

    Do as i can, not as i say: Grounding language in robotic affordances,

    B. Ichter, A. Brohan, Y. Chebotar, C. Finn, K. Hausman, A. Herzog et al., “Do as i can, not as i say: Grounding language in robotic affordances,” in Proc. of The 6th Conf. on Robot Learning, vol. 205, 14–18 Dec 2023, pp. 287–318

    work page 2023

  7. [7]

    Inner monologue: Embodied reasoning through planning with language models,

    W. Huang, F. Xia, T. Xiao, H. Chan, J. Liang, P. Florence et al., “Inner monologue: Embodied reasoning through planning with language models,” in Proc. of The 6th Conf. on Robot Learning, vol. 205, 14–18 Dec 2023, pp. 1769– 1782

    work page 2023

  8. [8]

    Reflexion: language agents with verbal rein- forcement learning,

    N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao, “Reflexion: language agents with verbal rein- forcement learning,” in Advances in Neural Information Processing Systems, vol. 36, 2023, pp. 8634–8652

    work page 2023

Show all 31 references
  1. [9]

    Critic: Large language models can self- correct with tool-interactive critiquing,

    Z. Gou, Z. Shao, Y. Gong, Y. Shen, Y. Yang, N. Duan, and W. Chen, “Critic: Large language models can self- correct with tool-interactive critiquing,” arXiv preprint arXiv:2305.11738, 2023

    2023 arXiv

  2. [10]

    React: Synergizing reasoning and acting in language models,

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “React: Synergizing reasoning and acting in language models,” arXiv preprint arXiv:2210.03629 , 2022

    2022 arXiv

  3. [11]

    Sayplan: Grounding large language models using 3d scene graphs for scalable robot task planning,

    K. Rana, J. Haviland, S. Garg, J. Abou-Chakra, I. Reid, and N. Suenderhauf, “Sayplan: Grounding large language models using 3d scene graphs for scalable robot task planning,” in Proc. of The 7th Conf. on Robot Learning , vol. 229, 06–09 Nov 2023, pp. 23–72

    2023

  4. [12]

    Reasoning with language model is planning with world model,

    S. Hao, Y. Gu, H. Ma, J. Hong, Z. Wang, D. Wang, and Z. Hu, “Reasoning with language model is planning with world model,” in Proc. of the Conf. on Empirical Methods in Natural Language Processing, 2023, pp. 8154–8173

    2023

  5. [13]

    Generalized planning in pddl do- mains with pretrained large language models,

    T. Silver, S. Dan, K. Srinivas, J. B. Tenenbaum, L. Kael- bling, and M. Katz, “Generalized planning in pddl do- mains with pretrained large language models,” Proc. of the AAAI Conf. on Artificial Intelligence , vol. 38, no. 18, pp. 20 256–20 264, Mar. 2024

    2024

  6. [14]

    Planbench: An extensible benchmark for evaluating large language models on planning and reasoning about change,

    K. Valmeekam, M. Marquez, A. Olmo, S. Sreedharan, and S. Kambhampati, “Planbench: An extensible benchmark for evaluating large language models on planning and reasoning about change,” Advances in Neural Information Processing Systems, vol. 36, pp. 38 975–38 987, 2023

    2023

  7. [15]

    Llms can’t plan, but can help planning in llm-modulo frameworks,

    S. Kambhampati, K. Valmeekam, L. Guan, M. Verma, K. Stechly, S. Bhambri et al., “Llms can’t plan, but can help planning in llm-modulo frameworks,” in Forty-first Int. Conf. on Machine Learning , 2024

    2024

  8. [16]

    Llm+ p: Empowering large language models with optimal planning proficiency,

    B. Liu, Y. Jiang, X. Zhang, Q. Liu, S. Zhang, J. Biswas, and P. Stone, “Llm+ p: Empowering large language models with optimal planning proficiency,” arXiv preprint arXiv:2304.11477, 2023

    2023 arXiv

  9. [17]

    Dynamic plan- ning with a llm,

    G. Dagan, F. Keller, and A. Lascarides, “Dynamic plan- ning with a llm,” arXiv preprint arXiv:2308.06391 , 2023

    2023 arXiv

  10. [18]

    Leveraging pre-trained large language models to construct and utilize world models for model-based task planning,

    L. Guan, K. Valmeekam, S. Sreedharan, and S. Kambham- pati, “Leveraging pre-trained large language models to construct and utilize world models for model-based task planning,” in Advances in Neural Information Processing Systems, vol. 36, 2023, pp. 79 081–79 094

    2023

  11. [19]

    Nl2plan: Robust llm-driven planning from minimal text descriptions,

    E. Gestrin, M. Kuhlmann, and J. Seipp, “Nl2plan: Robust llm-driven planning from minimal text descriptions,” CoRR, 2024

    2024

  12. [20]

    Lamma- p: Generalizable multi-agent long-horizon task allocation and planning with lm-driven pddl planner,

    X. Zhang, H. Qin, F. Wang, Y. Dong, and J. Li, “Lamma- p: Generalizable multi-agent long-horizon task allocation and planning with lm-driven pddl planner,”arXiv preprint arXiv:2409.20560, 2024

    2024 arXiv

  13. [21]

    Clmasp: Coupling large language models with answer set programming for robotic task planning,

    X. Lin, Y. Wu, H. Yang, Y. Zhang, Y. Zhang, and J. Ji, “Clmasp: Coupling large language models with answer set programming for robotic task planning,” arXiv preprint arXiv:2406.03367, 2024

    2024 arXiv

  14. [22]

    Coupling large language models with logic programming for robust and general reasoning from text,

    Z. Yang, A. Ishay, and J. Lee, “Coupling large language models with logic programming for robust and general reasoning from text,” in Findings of the Association for Computational Linguistics: ACL, 2023, pp. 5186–5219

    2023

  15. [23]

    Autotamp: Autoregressive task and motion planning with llms as translators and checkers,

    Y. Chen, J. Arkin, C. Dawson, Y. Zhang, N. Roy, and C. Fan, “Autotamp: Autoregressive task and motion planning with llms as translators and checkers,” in IEEE Int. Conf. on Robotics and Automation , 2024, pp. 6695– 6702

    2024

  16. [24]

    AutoGPT+P: Affordance-based Task Planning using Large Language Models,

    T. Birr, C. Pohl, A. Younes, and T. Asfour, “AutoGPT+P: Affordance-based Task Planning using Large Language Models,” in Proc. of Robotics: Science and Systems, Delft, Netherlands, July 2024

    2024

  17. [25]

    Delta: Decomposed efficient long-term robot task plan- ning using large language models,

    Y. Liu, L. Palmieri, S. Koch, I. Georgievski, and M. Aiello, “Delta: Decomposed efficient long-term robot task plan- ning using large language models,” arXiv preprint arXiv:2404.03275, 2024

    2024 arXiv

  18. [26]

    Makeable: Memory-centered and affordance-based task execution framework for transferable mobile manipulation skills,

    C. Pohl, F. Reister, F. Peller-Konrad, and T. Asfour, “Makeable: Memory-centered and affordance-based task execution framework for transferable mobile manipulation skills,” in IEEE/RSJ Int. Conf. on Intelligent Robots and Systems, 2024, pp. 3674–3681

    2024

  19. [27]

    Robots can multitask too: Integrating a memory architecture and llms for enhanced cross-task robot action generation,

    H. Ali, P. Allgeuer, C. Mazzola, G. Belgiovine, B. C. Kaplan, L. Gajdoˇ sech, and S. Wermter, “Robots can multitask too: Integrating a memory architecture and llms for enhanced cross-task robot action generation,” in IEEE-RAS 23rd Int. Conf. on Humanoid Robots , 2024, pp. 811–818

    2024

  20. [28]

    Openvla: An open-source vision- language-action model,

    M. J. Kim, K. Pertsch, S. Karamcheti, T. Xiao, A. Bal- akrishna, S. Nair et al., “Openvla: An open-source vision- language-action model,” arXiv preprint arXiv:2406.09246, 2024

    2024 arXiv

  21. [29]

    Open x-embodiment: Robotic learning datasets and rt-x models,

    A. O’Neill, A. Rehman, A. Maddukuri, A. Gupta, A. Padalkar, A. Lee et al., “Open x-embodiment: Robotic learning datasets and rt-x models,” in IEEE Int. Conf. on Robotics and Automation, 2024, pp. 6892–6903

    2024

  22. [30]

    Virtualhome: Simulating household activities via programs,

    X. Puig, K. Ra, M. Boben, J. Li, T. Wang, S. Fidler, and A. Torralba, “Virtualhome: Simulating household activities via programs,” in Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition, 2018, pp. 8494– 8502

    2018

  23. [31]

    The effect of sampling temperature on prob- lem solving in large language models,

    M. Renze, “The effect of sampling temperature on prob- lem solving in large language models,” in Findings of the Association for Computational Linguistics: EMNLP , Miami, Florida, USA, Nov. 2024, pp. 7346–7356

    2024

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.