Automatic Robot Task Planning by Integrating Large Language Model with Genetic Programming

Azizjon Kobilov; Jianglin Lan

REVIEW 5 major objections 5 minor 32 references

Automatic Robot Task Planning by Integrating Large Language Model with Genetic Programming

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

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

Pith's one-line read A hybrid method seeds genetic programming with language-model-generated behavior trees, reaching optimal robot task plans in far fewer generations than random-initialized evolution.

desk verdict Sensible incremental extension of LLM+GP for behavior trees, with an honest but under-supported efficiency claim. read the letter →

arxiv 2502.07772 v1 pith:ATIRUD2V submitted 2025-02-11 cs.RO cs.SYeess.SY

Azizjon Kobilov , Jianglin Lan This is my paper · ORCID

classification cs.ROcs.SYeess.SY

keywords behaviortreeslargelanguagemodelsgeneticprogrammingrobottaskplanningnaturalcommandsfitnessfilteringautonomoussystems

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

The paper is trying to establish that combining a large language model with genetic programming automates the creation of Behavior Tree control policies for robots, taking a plain-English instruction (plus a camera image) and returning a high-fitness tree without needing pre-written examples of good trees. The motivation is that task plans in homes, offices, and hospitals must be created and updated quickly, and current BT generation either needs domain expertise, long evolution, or ideal reference trees that are rarely available. The proposed pipeline, LLM-GP-BT, first filters the LLM's output trees by fitness and then evolves only the survivors, and the experiments suggest this reaches optimal fitness in a few generations and stays effective when actions have failure probabilities. If correct, this would make BT-based task planning faster and friendlier for non-experts.

What carries the argument

Behavior Trees (BTs) — a graphical control-policy representation whose nodes return Success or Failure when ticked, arranged under Sequence, Fallback, or Parallel control-flow nodes — are the output format. The load-bearing mechanism is the fitness-acceptance filter placed between the LLM and the Genetic Programming module: the LLM generates multiple candidate BTs, the BT Nodes Validation module rejects syntactically or contextually invalid ones, and then each remaining BT is scored by the fitness function $J = R - (\alpha \|s_d - s\|^2 + \beta b + \gamma T + \delta P)$ so that only trees above a chosen threshold enter the GP population. This filtering converts the LLM's variable-quality, sometimes hallucinated outputs into a high-quality seeding population that GP then refines, which is what the paper credits for the short convergence time.

What would settle it

Measure the complete pipeline from user command to final behavior tree in wall-clock time and API cost, including every LLM call, validation, and regeneration, for both LLM-GP-BT and GP-BT on the same tasks; if total cost is not lower, or if replacing the fitness function with physical task-success measurements erases the convergence gap, the efficiency claim is unsupported.

Watch

Extended reading notes

Core claim

The paper's central claim is that seeding Genetic Programming with an LLM-generated, fitness-filtered initial population of Behavior Trees produces high-fitness, task-ready control policies in far fewer evolution generations than the standard GP-BT approach, which starts from random small trees. Under the same fitness function and environment used by the GP-BT baseline, the LLM-GP-BT method reaches optimal fitness in a very few episodes for two different pick-and-place tasks, and it maintains this convergence advantage when actions have nonzero failure probabilities. The method does not rely on any pre-existing good BT example as input; instead, it supplies the LLM with a system message, an image of the environment, and the user's natural-language command, and then validates and filters the LLM's output trees before evolution.

Load-bearing premise

The central claim rests on the fitness function J, taken from the GP-BT baseline, being a faithful proxy for real robot task success, and on comparing only GP evolution generations while leaving LLM inference and regeneration costs out of the efficiency tally.

Editorial extensions

If this is right

Robot task planning can be specified by a natural-language command plus a camera image, with no predefined BT examples, making the pipeline usable in novel environments where ideal plans are unknown.
Filtering LLM-generated BTs by fitness before GP evolution reduces the number of GP episodes needed to reach optimal fitness compared with the random-initialization baseline.
The convergence advantage persists under deterministic and stochastic conditions, including localization, picking, placing, and cube-loss failures, indicating tolerance to action uncertainty.
Even with initial populations reduced to 15 BTs, the hybrid method converges faster than GP-BT with 30 random BTs, suggesting the quality of the seed population matters more than its size.

Reading between the lines

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

The reported speedup counts GP evolution episodes only; the full cost of LLM inference, validation, and regeneration is left out, so an end-to-end wall-clock or API-cost comparison could change the efficiency picture.
The method's advantage likely depends on the LLM producing a reasonably diverse set of acceptable BT skeletons; with a weaker or more hallucination-prone model, the fitness filter may reject most candidates and the speedup could disappear.
The same seed-with-filter-then-evolve recipe could transfer to other structured policy representations, such as finite-state machines or decision trees, wherever a fitness signal is available.
A testable extension: replace the LLM with a single hand-coded near-optimal BT mutated to create a population; if convergence matches LLM-GP-BT, the benefit stems from seed quality rather than language understanding.

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.

Desk Editor's Note

read the letter

Short take: this is an incremental but honest extension of [8], and the paper's own Section V admits the main weakness. The new bit is filtering LLM-generated BTs by fitness before handing them to GP, plus image-based environment input. That is a reasonable engineering idea, and the authors are careful not to claim they avoid all prior issues—they explicitly note that without examples of high-fitness BTs, the LLM alone is not enough.

What I like: the discussion in Section V is candid about the fact that GP-BT starts from random small BTs while LLM-GP-BT starts from tailored, fitness-filtered BTs. That is the central confound, and they name it. They also do not provide any high-fitness example BT as input, which is the right call for a practical scenario. And they use the same fitness function and environment as [6], so the comparison is at least externally anchored.

The soft spots are real. The efficiency claim is not established because episode counts alone ignore LLM inference, validation, and regeneration costs. The experiments have one environment, 10 runs, and no error bars or statistical tests. The image input is never ablated, so we do not know if it helps. No code or data is released. These are not fatal—the method does what it says—but the headline claims in the abstract ('computationally efficient') go beyond the evidence. The stress-test note is right: the faster convergence likely comes mostly from the warm start.

Still, this is not a circular or fabricated result. The fitness function is external, the baseline is the prior work, and the authors are transparent about the asymmetry. That is a lot better than many papers in this area.

Who should read it: people building BT generation pipelines with LLMs, and anyone working on LLM+GP hybrids. It is a useful data point, not a breakthrough. A serious referee could help the authors sharpen the claims and run the right ablations, so I would send it out, but with a clear request for cost accounting, error bars, and an ablation of the image module.

Referee Report

5 major / 5 minor

Summary. The paper presents LLM-GP-BT, a method that combines a multimodal large language model (GPT-4o) with genetic programming (GP) to generate Behavior Trees (BTs) for robot task planning. The LLM produces an initial population of BTs from a natural-language task description and an image of the environment; these BTs are validated for syntactic/contextual correctness, filtered by a fitness threshold, and then refined by GP. The method is evaluated in a simulated office environment against the GP-BT baseline of [6] in two task scenarios, under deterministic and stochastic conditions, and with reduced initial population sizes. The central claims are that LLM-GP-BT reaches high-fitness BTs in far fewer GP episodes than GP-BT and that it remains robust under uncertainty and with smaller initial populations.

Significance. If the efficiency and robustness claims are substantiated, the method would meaningfully reduce the domain expertise and manual effort required for BT-based task planning, which is a current bottleneck for autonomous systems. The paper has several strengths: it uses the same fitness function and environment as the baseline [6], which facilitates comparison; it explicitly avoids supplying high-fitness BT examples, addressing a practical limitation noted in prior work [8]; it reports 10-run averages for each scenario; and it tests reduced initial population sizes, showing graceful degradation. The integration of environment images as input is a plausible way to reduce the user's burden in describing the environment. However, as presented, the experiments do not fully support the headline claims of computational efficiency and robustness under uncertainty, for reasons detailed in the major comments.

major comments (5)

[Section V] The efficiency comparison is confounded by asymmetric starting points. The paper admits that in [6] the initial populations 'comprised randomly generated, small-sized BTs,' while LLM-GP-BT 'generates more complex initial BT populations tailored to the specified tasks.' Consequently, the faster rise to high fitness in Figures 4, 7, and 8 may reflect a warm start from LLM-provided, fitness-filtered BTs rather than a more efficient GP process. To support the claim of 'computationally efficient' made in the abstract and Section VI, the authors should either (a) compare against GP-BT initialized with the same LLM-generated populations, or (b) report total wall-clock time and API/validation/regeneration costs, comparing total resource usage rather than GP episodes alone. As written, the efficiency claim is underdetermined.
[Section IV-B] Figures 4, 7, 8, and 9 present only mean fitness curves with no error bars, confidence intervals, or statistical tests, despite the statement that simulations were run 10 times per scenario. Claims such as 'LLM-GP-BT method achieved the highest fitness level in a very few episode generations' and 'robustness and efficiency in handling environments characterized by increasing levels of uncertainty' require reporting the variance across runs and some significance assessment, especially since LLM generation is stochastic. The authors should include standard deviations or interquartile ranges and, where appropriate, a nonparametric test (e.g., Mann-Whitney U) comparing fitness at matched episode counts.
[Section IV-A, Eq. (1), Tables II and III] The fitness function J in Eq. (1) has a failure-probability term δP, but Table II sets δ=0.0. In Experiment 2, the stochastic conditions vary failure probabilities (Table III), yet it is unclear whether J incorporates these probabilities in any way. If δ remains 0, the reported fitness curves do not reflect task failure probability, weakening the 'robustness under uncertainty' claim. The authors should clarify how J is evaluated in stochastic scenarios (e.g., expected value over multiple stochastic executions) or add complementary metrics such as task success rate over repeated trials.
[Section I and Section IV] The image-input module is listed as a contribution ('We automate the environment-information input process by integrating an image analysis module'), but the experiments do not include an ablation with and without the image input. Without such a comparison, the contribution of the image modality to BT quality or convergence is unvalidated. The authors should either provide an ablation study or temper the claim that the image module 'streamlines' the process.
[Section II-D and Section IV-B] The paper compares LLM-GP-BT only against the GP-BT baseline [6], not against the closest related method [8], which also integrates LLM with GP for BT generation. Since the authors frame their contributions relative to [8] (fitness filtering, avoidance of pre-defined BT examples, and image input), a direct comparison with [8] on the same environment and fitness function is necessary to substantiate the claimed improvement over that method. Without it, the novelty and advantage relative to the most relevant baseline are not empirically demonstrated.

minor comments (5)

[Section IV-A] There is a typo: 'OpanAI' should be 'OpenAI'.
[Throughout] Table references are inconsistent: 'Table 1' and 'Table 2' are used in the text while the captions read 'TABLE I' and 'TABLE II'. Please standardize the citation style.
[Section IV-B] The term 'episodes' is used to mean GP generations; consider using 'generations' consistently, or define 'episodes' at first use.
[Section IV-B, Experiment 3] Figure 9's axes and legend are not described in the text; please clarify what is plotted and how the initial population sizes are represented.
[Section VI] The conclusion overstates the evidence: 'Simulation results confirm its robustness' and 'offers a scalable and efficient solution' go beyond what single-environment, variance-free, GP-episode-only experiments can establish. Please align the conclusion with the actual evidence.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the efficiency comparison uses the external GP-BT baseline [6] with the same fitness function, and the faster-convergence concern is an experimental-validity caveat rather than an equation-level reduction to the paper's own inputs.

full rationale

The paper's core workflow uses an external fitness function J taken from [6] and compares LLM-GP-BT with the GP-BT method of [6] under that same function and environment. The LLM-generated BTs are filtered by J before seeding GP, but no parameter is fitted to the reported outcomes, no fitted quantity is renamed as a prediction, and the final high-fitness BTs are produced by GP evolution rather than being assumed equal to the LLM outputs. Section V openly concedes that the baseline starts from randomly generated small BTs while LLM-GP-BT starts from task-tailored, fitness-filtered initial populations; this makes the episode-count efficiency comparison hard to interpret and omits LLM/validation costs, but that is a fairness or generality limitation, not a case where the claimed result reduces by construction to its inputs. There are no load-bearing self-citations by the present authors, and no uniqueness theorem or ansatz is imported from the authors' prior work. Consequently, no circular step can be quoted and exhibited as an equation-level equivalence or as a fitted parameter renamed as a prediction.

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

The central claim rests on the fitness function inherited from [6], on the validity of the simulated environment, and on the LLM's ability to produce useful BTs from a system message and images. No new entities are invented. The main free parameters are the acceptance fitness threshold (value unreported) and LLM sampling settings.

free parameters (4)

Fitness acceptance threshold = Not reported
Filters LLM-generated BTs before GP; the paper says it can be adjusted according to accuracy requirements but does not give the value used in experiments.
LLM temperature = 1.2
Set to increase diversity of generated BTs; affects the quality and spread of the initial population.
LLM top p = 0.95
Set with temperature to widen token sampling; affects the diversity of generated BTs.
Initial population size = 30 (also 20 and 15)
Chosen for comparison; convergence rate depends on this value, and the paper tests reduced sizes.

assumptions (5)

domain assumption The fitness function J in Equation (1), taken from [6], is a valid measure of how well a BT completes the task and is a proper optimization target.
All comparisons and the acceptance filter rely on this function, but its validity is not questioned or tested.
domain assumption The simulation environment and robot skills are identical to those in [6], so the same GP parameters apply fairly.
The paper states it reused the setup from [6], including the fitness function and GP parameter values, without new validation.
domain assumption GPT-4o, given the system message, environment image, and task command, produces BTs that are semantically meaningful after the node validation step.
The validation module only checks node names and syntax, not whether the tree logic achieves the task.
domain assumption The environment images provide useful information to the LLM and improve generated BTs.
No ablation with and without images is run, so the contribution of the image module is unmeasured.
domain assumption Ten simulation runs are sufficient to support the stated robustness and efficiency conclusions.
Only average-mean values are reported, without variance, confidence intervals, or significance tests.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Automatic Robot Task Planning by Integrating Large Language Model with Genetic Programming." pith.science (2026). https://pith.science/paper/ATIRUD2V

@misc{pith2026250207772,
  author       = {Pith},
  title        = {Pith review of: Automatic Robot Task Planning by Integrating Large Language Model with Genetic Programming},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ATIRUD2V}},
  note         = {Machine review of arXiv:2502.07772}
}

read the original abstract

Accurate task planning is critical for controlling autonomous systems, such as robots, drones, and self-driving vehicles. Behavior Trees (BTs) are considered one of the most prominent control-policy-defining frameworks in task planning, due to their modularity, flexibility, and reusability. Generating reliable and accurate BT-based control policies for robotic systems remains challenging and often requires domain expertise. In this paper, we present the LLM-GP-BT technique that leverages the Large Language Model (LLM) and Genetic Programming (GP) to automate the generation and configuration of BTs. The LLM-GP-BT technique processes robot task commands expressed in human natural language and converts them into accurate and reliable BT-based task plans in a computationally efficient and user-friendly manner. The proposed technique is systematically developed and validated through simulation experiments, demonstrating its potential to streamline task planning for autonomous systems.

Figures

Figures reproduced from arXiv: 2502.07772 by the authors.

**Figure 1.** Example Structure of Behavior Tree. Parallel. The behavior of ticks varies based on the type of control flow node. - Sequence nodes transmit ticks sequentially from left to right and return Success only if all their child nodes return Success. - Fallback nodes also transmit ticks sequentially from left to right but return Success if at least one of their child nodes returns Success. - Parallel nodes send ticks to al… view at source ↗

**Figure 2.** LLM-GP-BT methodology framework. for robotic systems [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Robot environment (from top perspective). [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4: BTs evolution with two different task scenarios. [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]

**Figure 5.** Figure 5: LLM-GP-BT produced optimal fitness BT output for [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]

**Figure 6.** Figure 6: LLM-GP-BT produced optimal fitness BT output for [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]

**Figure 8.** Figure 8: BTs evolution with increasing levels of uncertainty. [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]

**Figure 9.** Figure 9: BTs evolution with decreased initial populations in LLM [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

32 extracted references · 16 canonical work pages

[8]

A. V . Gonzalez, L. M. Caba ˜nas, M. Dalmau-Moreno, and N. Garcia, ”Boosting robot behavior generation with large language models and genetic programming,” in Proc. 2nd Workshop on Mobile Manipula- tion and Embodied Intelligence at ICRA 2024, 2024

work page 2024
[6]

Learning Behavior Trees with Genetic Programming in Unpredictable Environments,

M. Iovino, J. Styrud, P. Falco, and C. Smith, “Learning Behavior Trees with Genetic Programming in Unpredictable Environments,” in Proc. ICRA, pp. 4591–4597, 2021

work page 2021
[1]

Colledanchise and P

M. Colledanchise and P. ¨Ogren, Behavior Trees in Robotics and AI: An Introduction. CRC Press, July 2018

work page 2018
[2]

A survey of Behavior Trees in robotics and AI,

M. Iovino, E. Scukins, J. Styrud, P. ¨Ogren, and C. Smith, “A survey of Behavior Trees in robotics and AI,” Robotics and Autonomous Systems, vol. 154, p. 104096, Apr. 2022

work page 2022
[3]

Autonomous Acquisition of Behavior trees for robot control,

B. Banerjee, “Autonomous Acquisition of Behavior trees for robot control,” in Proc. IROS, Oct. 2018

work page 2018
[4]

Learning behavior trees from demonstration,

K. French, S. Wu, T. Pan, Z. Zhou, and O. C. Jenkins, “Learning behavior trees from demonstration,” in Proc. ICRA, pp. 7791–7797, 2019

work page 2019
[5]

Learning Action Conditions for Automatic Behavior Tree Generation from Human Demonstrations,

L. Scherf, K. Fr ¨ohlich, and D. Koert, “Learning Action Conditions for Automatic Behavior Tree Generation from Human Demonstrations,” Companion of the 2024 ACM/IEEE International Conference on Human-Robot Interaction, pp. 950–954, Mar. 2024

work page 2024
[7]

A Study on Training and Developing Large Language Models for Behavior Tree Generation

Li, F., Wang, X., Li, B., Wu, Y ., Wang, Y ., and Yi, X. A Study on Training and Developing Large Language Models for Behavior Tree Generation. ArXiv, abs/2401.08089, 2024

arXiv 2024

Show all 32 references

[9]

Cao and C

Y . Cao and C. S. G. Lee, ”Robot behavior-tree-based task generation with large language models,” ArXiv, vol. abs/2302.12927, 2023

2023 arXiv
[10]

Lykov, et al., ”LLM-MARS: Large language model for behavior tree generation and NLP-enhanced dialogue in multi-agent robot systems,” ArXiv, vol

A. Lykov, et al., ”LLM-MARS: Large language model for behavior tree generation and NLP-enhanced dialogue in multi-agent robot systems,” ArXiv, vol. abs/2312.09348, 2023

2023 arXiv
[11]

H. Zhou, Y . Lin, L. Yan, J. Zhu, and H. Min, ”LLM-BT: Performing robotic adaptive tasks based on large language models and behavior trees,” 2024 IEEE International Conference on Robotics and Automa- tion (ICRA), 2024, pp. 16655–16661

2024
[12]

Tagliamonte, D

C. Tagliamonte, D. Maccaline, G. LeMasurier, and H. A. Yanco, ”A generalizable architecture for explaining robot failures using behav- ior trees and large language models,” in Companion of the 2024 ACM/IEEE International Conference on Human-Robot Interaction (HRI ’24), Boulder...

2024
[13]

R. Izzo, G. Bardaro, and M. Matteucci, ”BTGenBot: Behavior tree generation for robotic tasks with lightweight LLMs,” in Proc. IROS, Oct. 2024, pp. 9684–9690

2024
[14]

Styrud, M

J. Styrud, M. Iovino, M. Norrl ¨of, M. Bj ¨orkman, and C. Smith, ”Auto- matic behavior tree expansion with LLMs for robotic manipulation,” arXiv preprint arXiv:2409.13356, 2024

2024 arXiv
[16]

Chen, et al., ”HBTP: Heuristic behavior tree planning with large language model reasoning,” arXiv preprint arXiv:2406.00965, 2024

X. Chen, et al., ”HBTP: Heuristic behavior tree planning with large language model reasoning,” arXiv preprint arXiv:2406.00965, 2024

2024 arXiv
[17]

Chen, et al., ”Integrating intent understanding and optimal behavior planning for behavior tree generation from human instructions,” in Proc

X. Chen, et al., ”Integrating intent understanding and optimal behavior planning for behavior tree generation from human instructions,” in Proc. IJCAI, Jeju, Korea, 2024, Art. no. 755

2024
[18]

Ahmad, J

F. Ahmad, J. Styrud, and V . Krueger, ”Addressing failures in robotics using vision-based language models (VLMs) and behavior trees (BT),” arXiv preprint arXiv:2411.01568, 2024

2024 arXiv
[19]

N. Wake, A. Kanehira, J. Takamatsu, K. Sasabuchi, and K. Ikeuchi, ”VLM-driven behavior tree for context-aware task planning,” arXiv preprint arXiv:2501.03968, 2025

2025 arXiv
[20]

Foundations of Genetic Programming,

W. B. Langdon and R. Poli, “Foundations of Genetic Programming,” Springer Science and Business Media, 2013

2013
[21]

W. B. Langdon, R. Poli, N. F. McPhee, and J. R. Koza, ”Genetic pro- gramming: An introduction and tutorial, with a survey of techniques and applications,” Computational Intelligence: A Compendium, pp. 927–1028, 2008. Springer

2008
[22]

M. C. Sinclair and S. H. Shami, ”Evolving simple software agents: Comparing genetic algorithm and genetic programming performance,” in Proc. 2nd Int. Conf. Genetic Algorithms in Engineering Systems: Innovations and Applications, 1997, pp. 421–426

1997
[23]

Naveed, A

H. Naveed, A. U. Khan, S. Qiu, M. Saqib, S. Anwar, M. Usman, N. Akhtar, N. Barnes, and A. Mian, ”A comprehensive overview of large language models,” arXiv preprint arXiv:2307.06435, 2023

2023 arXiv
[24]

W. X. Zhao, K. Zhou, J. Li, T. Tang, et al., ”A survey of large language models,” arXiv preprint arXiv:2303.18223, 2023

2023 arXiv
[25]

Chang, X

Y . Chang, X. Wang, J. Wang, Y . Wu, L. Yang, K. Zhu, H. Chen, X. Yi, C. Wang, Y . Wang, et al., ”A survey on evaluation of large language models,” ACM Transactions on Intelligent Systems and Technology, vol. 15, no. 3, pp. 1–45, 2024

2024
[26]

J. Wei, Y . Tay, R. Bommasani, C. Raffel, et al., ”Emergent abilities of large language models,” arXiv preprint arXiv:2206.07682, 2022

2022 arXiv
[27]

Minaee, T

S. Minaee, T. Mikolov, N. Nikzad, M. Chenaghlu, R. Socher, X. Amatriain, and J. Gao, ”Large language models: A survey,” arXiv preprint arXiv:2402.06196, 2024

2024 arXiv
[28]

Achiam, S

J. Achiam, S. Adler, S. Agarwal, L. Ahmad, I. Akkaya, F. L. Aleman, D. Almeida, J. Altenschmidt, S. Altman, S. Anadkat, et al. ., ”GPT-4 technical report,” arXiv preprint arXiv:2303.08774, 2023

2023 arXiv
[29]

Touvron, L

H. Touvron, L. Martin, et al. , ”Llama 2: Open foundation and fine-tuned chat models,” arXiv e-prints, Jul. 2023, Art. no. arXiv:2307.09288

2023 arXiv
[30]

Georgiev, V

Gemini Team, P. Georgiev, V . I. Lei, R. Burnell, et al. , ”Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context,” arXiv e-prints, Mar. 2024, Art. no. arXiv:2403.05530

2024 arXiv
[31]

Liu, et al

A. Liu, et al. , ”Deepseek-v3 technical report,” arXiv preprint arXiv:2412.19437, 2024

2024 arXiv
[32]

F. Zeng, W. Gan, Y . Wang, N. Liu, and P. S. Yu, ”Large language models for robotics: A survey,” arXiv preprint arXiv:2311.07226, 2023

2023
[33]

[Online]

OpenAI, ”ChatGPT,” OpenAI. [Online]. Available: https://openai.com/

Pith tools

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

[1] [8]

A. V . Gonzalez, L. M. Caba ˜nas, M. Dalmau-Moreno, and N. Garcia, ”Boosting robot behavior generation with large language models and genetic programming,” in Proc. 2nd Workshop on Mobile Manipula- tion and Embodied Intelligence at ICRA 2024, 2024

work page 2024

[2] [6]

Learning Behavior Trees with Genetic Programming in Unpredictable Environments,

M. Iovino, J. Styrud, P. Falco, and C. Smith, “Learning Behavior Trees with Genetic Programming in Unpredictable Environments,” in Proc. ICRA, pp. 4591–4597, 2021

work page 2021

[3] [1]

Colledanchise and P

M. Colledanchise and P. ¨Ogren, Behavior Trees in Robotics and AI: An Introduction. CRC Press, July 2018

work page 2018

[4] [2]

A survey of Behavior Trees in robotics and AI,

M. Iovino, E. Scukins, J. Styrud, P. ¨Ogren, and C. Smith, “A survey of Behavior Trees in robotics and AI,” Robotics and Autonomous Systems, vol. 154, p. 104096, Apr. 2022

work page 2022

[5] [3]

Autonomous Acquisition of Behavior trees for robot control,

B. Banerjee, “Autonomous Acquisition of Behavior trees for robot control,” in Proc. IROS, Oct. 2018

work page 2018

[6] [4]

Learning behavior trees from demonstration,

K. French, S. Wu, T. Pan, Z. Zhou, and O. C. Jenkins, “Learning behavior trees from demonstration,” in Proc. ICRA, pp. 7791–7797, 2019

work page 2019

[7] [5]

Learning Action Conditions for Automatic Behavior Tree Generation from Human Demonstrations,

L. Scherf, K. Fr ¨ohlich, and D. Koert, “Learning Action Conditions for Automatic Behavior Tree Generation from Human Demonstrations,” Companion of the 2024 ACM/IEEE International Conference on Human-Robot Interaction, pp. 950–954, Mar. 2024

work page 2024

[8] [7]

A Study on Training and Developing Large Language Models for Behavior Tree Generation

Li, F., Wang, X., Li, B., Wu, Y ., Wang, Y ., and Yi, X. A Study on Training and Developing Large Language Models for Behavior Tree Generation. ArXiv, abs/2401.08089, 2024

arXiv 2024