EvoCurr: Self-evolving Curriculum with Behavior Code Generation for Complex Decision-making

Jian Zhao; Weiyu Ma; Wenhui Zhu; Yang Cheng; Yue Deng; Zilai Wang

REVIEW 4 major objections 4 minor 1 cited by

EvoCurr: Self-evolving Curriculum with Behavior Code Generation for Complex Decision-making

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

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

Pith's one-line read EvoCurr claims that an inference-time, self-generated curriculum of StarCraft II micro-battles lets a code-writing LLM solve a final battle that direct one-shot code generation cannot solve reliably.

desk verdict Useful integration of LLM-driven curriculum design with behavior-code generation, but the paper's central comparative claim is unsupported because the promised direct-solver baseline is missing and success rests on one of five paths. read the letter →

arxiv 2508.09586 v2 pith:X5DW6WPY submitted 2025-08-13 cs.AI

Yang Cheng , Zilai Wang , Weiyu Ma , Wenhui Zhu , Yue Deng , Jian Zhao This is my paper

classification cs.AI

keywords curriculumlearningLLMagentsdecisiontreecodeStarCraftIIself-evolvinginference-timeadaptationmicro-managementgeneration

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 proposes EvoCurr, a two-LLM loop for hard decision-making tasks. One LLM designs a sequence of easier StarCraft II micro-battles, and another LLM writes executable Python decision-tree code to play each battle, carrying the previous tree forward as a template. A 67% win-rate threshold decides whether the next task is harder or easier, so the curriculum is generated on the fly rather than hand-designed. The central claim is that this self-made curriculum lets the solver LLM assemble a policy for a complex final engagement, whereas asking it to write the same final policy directly is unreliable. In five autonomous runs, one run reached complete mastery of the full task, which the paper reads as evidence that the curriculum loop, not one-shot code generation, is what makes the task solvable.

What carries the argument

The load-bearing mechanism is the closed-loop curriculum. A curriculum-designer LLM proposes task configurations (unit counts, abilities, map, objectives, difficulty level); a solver LLM turns each configuration into a decision tree in a planner-coder-critic loop; environment evaluation returns a win rate; and the designer uses threshold crossings to decide whether to escalate or ease. The decision tree itself is the memory: all learned behavior lives in its branches, and each new curriculum modifies the preserved tree rather than restarting from scratch.

What would settle it

Run EvoCurr on the same final task but present the intermediate curricula in scrambled or reversed order, with the same total number of code-generation attempts; if success persists, adaptive ordering is not doing the work. Alternatively, check whether branches from early stages actually execute in later stages—if the preserved template is largely overwritten, transfer is not the mechanism.

Watch

Extended reading notes

Core claim

EvoCurr's central claim is that the hard part of complex decision-making is not the final code but the path to it. The framework pairs a curriculum-designer LLM with a code-writing solver LLM: the designer starts from a simplified version of the target task, the solver emits decision-tree code, and after simulated combat the designer receives the win rate and either escalates or eases the next task. The current decision tree is preserved and extended at each stage. On the paper's Terran-versus-Protoss micro-management benchmark, one of five autonomous curriculum paths completed the full final task with a 100% win rate in the final stage, after passing the 67% threshold at every earlier stage

Load-bearing premise

The load-bearing premise is that decision-tree code from early curriculum stages survives and remains useful when new units, abilities, and enemy compositions are added, so preserving the previous tree as a template composes into a final working policy.

Editorial extensions

If this is right

If EvoCurr is right, inference-time curriculum design can replace manual curriculum engineering for LLM agents in any domain where tasks can be ordered by difficulty.
The decision-tree representation gives an audit trail: each stage's behavior is explicit code, so debugging, verification, and partial reuse are built into the loop.
The adaptive easing mechanism means a failed task does not reset progress; the designer steps back and reuses the latest successful tree, which is what lets one of five paths survive a mid-curriculum failure.
The same loop should transfer to other structured reasoning or program-synthesis problems, since it only requires a difficulty-ordered task space and a scalar performance signal.

Reading between the lines

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

A direct test of the transfer assumption would shuffle or reverse the intermediate curricula while holding the code-generation budget fixed; if success persists, the gradual ordering is not the cause. The paper does not run this control.
The 67% win-rate threshold is reported over multiple runs, but the number of rollouts is not quantified; in a stochastic simulator, threshold crossings could be partly noise, so the framework's reliability would sharpen with variance reporting.
The paper itself notes in its discussion that a single solver agent applies fine control to some unit types and coarse control to others, and proposes assigning each unit type its own specialist agent; that division of labor is a testable extension of the central claim.
The one-in-five success rate suggests curriculum generation is a stochastic search; treating curriculum paths as a population and selecting among them is a natural next step the paper leaves implicit.

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

The framework is the real thing: a two-agent inference-time loop where a curriculum LLM adjusts task difficulty from win-rate feedback and a solver LLM writes executable python-sc2 decision trees through a planner-coder-critic cycle. That combination is not in the cited prior work, and the paper is honestly engineered—algorithms are concrete, you can see the actual code, and they report five full curriculum paths including one successful solve. The integration of known components is legitimate, and the fact that they show failures as well as successes suggests they are not cherry-picking.

The problem is that the abstract's claim is 'significantly improves task success rates and solution efficiency compared to direct-solving baselines,' and the paper never shows the baseline. Section 4.1 says they compare against direct generation, but no baseline result appears anywhere in Section 4. We only learn that EvoCurr solved the final task once in five runs. With one success, you cannot tell whether the curriculum loop helped or whether the underlying code-generation LLM would have solved it directly, or just got lucky on that path. The stress-test note has this right. Also, the 67% stage thresholds are reported without the number of games or confidence intervals, so 'consistent' success is not quantifiable. The transfer assumption—preserving the decision tree as a template for later stages—is plausible but never isolated; several failed paths could stem from template transfer failure rather than curriculum design failure.

The paper itself flags another limitation in Section 5: a single-agent coder biases toward certain unit types under limited context. That is honest but does not fix the missing comparison. Minor points: novelty is moderate (recognizable components, new integration), and no code or data are released, which is a real gap for an empirical systems paper.

Who gets value from this: anyone working on LLM agents and curriculum learning, or StarCraft II bot scripting. It is a useful existence proof that an LLM curriculum loop can, at least in one run, build up a complicated decision-tree policy. But as a published claim of 'significant improvement,' it falls short.

I would not cite it yet. It does deserve a serious referee rather than a desk reject, because the framework is coherent, the description is clear, and the flaws are fixable. The right ask is: rerun with a real direct-generation baseline, report per-run win rates and sample sizes, add at least a second scenario, and release the code. With that, it could become a solid paper. As is, I would reject.

Referee Report

4 major / 4 minor

Summary. The paper proposes EvoCurr, a two-LLM closed-loop framework for complex decision-making. A curriculum designer LLM generates progressively harder StarCraft II micro-management tasks, while a solver LLM produces executable python-sc2 decision-tree code; the solver's win rate feeds back into the curriculum, which adapts difficulty until the final task is solved. The main claims are that EvoCurr significantly improves task success rates and solution efficiency over direct-solving baselines, and that the curriculum loop is the driver of success. The experimental section reports five independent curriculum paths (Table 2), of which exactly one (Path 1) reaches the final task, yielding a 20% overall success rate (1/5 paths).

Significance. The idea of using one LLM to generate an adaptive curriculum for another LLM's inference-time code generation is timely and potentially useful for complex, interpretable decision-making. The pseudocode (Algorithms 1–3) and the detailed curriculum tables are valuable for reproducibility of the qualitative setup. If the comparative claim were actually demonstrated, this would be a meaningful contribution to LLM-agent curriculum learning. However, as presented the central empirical claim is unsupported: the promised direct-generation baseline is never reported, the single success out of five paths is far too weak to establish 'significant improvement,' and no confidence intervals or simulation counts accompany the win rates. The significance of the framework is therefore not currently established.

major comments (4)

[§4.1 vs §4.4] The setup states 'We compare EvoCurr against a direct generation baseline' (§4.1), but no baseline result appears in §4.4 or Table 2. The abstract's claim of 'significantly improves task success rates and solution efficiency compared to direct-solving baselines' is therefore unsupported. With only one successful path (1/5), the observed outcome could be due to the solver LLM's one-shot ability or chance. The authors must report the baseline's success count, win rates, and efficiency metrics, or remove the comparative claim.
[§4.2/§4.4] Win-rate thresholds are reported as 67% or 100% without stating the number of simulation runs per curriculum stage or any confidence interval. The phrase 'across multiple simulation runs' is never quantified. This is load-bearing: a 67% success rate over, say, three runs is not the same as over 100 runs, and 1/5 path-level success cannot support 'significantly improves.' Please provide per-stage trial counts, intervals, or raw counts.
[§4.4] The claimed 'solution efficiency' is never defined or measured. The text reports only path outcomes and stage-level win rates; no metric for efficiency—such as number of LLM calls, wall-clock time, code size, or attempts to reach the final task—appears anywhere. Thus the second half of the abstract's headline claim is not testable.
[§3.1 and Algorithm 1] The paper attributes success to the self-evolving curriculum, but it never isolates the curriculum from the code-refinement loop. Algorithm 1 preserves the previous decision tree as a template and iteratively improves it (§3.1, lines 10–11), and Algorithm 3 already contains a planner–coder–critic refinement loop. Without a baseline that uses the same iterative template refinement but with a fixed, non-adaptive curriculum, the contribution of the adaptive curriculum is confounded. This should be tested or explicitly acknowledged as untested.

minor comments (4)

[Figure 3 caption] The caption says 'The green points are the terminal nodes, red points represents failing settings and the green points are success curricula.' The repeated 'green' is presumably a typo; likely one of the two should be a different color.
[References] In §2, the text cites 'LLM-SMAC [10]', but reference [10] is titled 'SMAC-R1: The Emergence of Intelligence in Decision-Making Tasks.' Please align the citation label with the reference title.
[§3.2 Algorithm Notation] The notation block lists L_cd and L_cr (critique LLM), but Algorithms 2 and 3 only use L_c and generic Plan/Code/Critique operations. Either remove unused notation or use it consistently in the pseudocode.
[Reproducibility] The appendix provides example code snippets, but there is no statement about releasing the full code, prompts, or evaluation harness. Given the empirical nature of the paper, a code/data availability statement would aid reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: EvoCurr is an empirical closed-loop method and no claimed prediction reduces to its inputs.

full rationale

The paper contains no fitted parameters, no derived equations, and no prediction that is equivalent to an input by construction. The central claim is empirical: a curriculum-generation LLM proposes tasks, a solver LLM generates decision-tree code, and the win-rate signal is used as feedback to adjust difficulty. Using the same success metric to drive curriculum adaptation is closed-loop control, not circular derivation. The only self-citations (e.g., [10], [11], [24], [25]) appear in related-work and architecture-inspiration contexts; none is load-bearing for the main result. The architecture is said to be 'inspired by LLM-SMAC [10]', but the experimental claim does not rest on that citation's validity. The paper explicitly reports a 20% success rate (1 of 5 paths) and acknowledges limitations, which further indicates the experiment is not manufactured to match a predetermined outcome. The absence of reported direct-baseline numbers is a significant evidence/completeness concern, but it is not circularity: a missing comparison does not make the claimed improvement equivalent to its inputs. No circular step can be identified, so the score is 0.

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

The central claim depends on hand-chosen thresholds, an unspecified evaluation budget, and the assumption that decision-tree skills transfer across curricula. No new physical or mathematical entities are introduced.

free parameters (4)

success threshold theta_s = 0.67 win rate
Section 4.1 sets 67% win rate as the success threshold; it controls when a curriculum stage advances and when the final task is considered solved.
curriculum progression threshold theta = 0.67 (same as theta_s in experiments)
Algorithm 2 uses r > theta to decide 'increase' vs 'adjust'; no calibration or sensitivity analysis is reported.
evaluation runs per curriculum = unspecified
Win rates are computed over 'multiple simulation runs' but the number is never stated, so the stability of the 67% threshold is unknown.
max attempts M and max iterations N = unspecified
Algorithm 3 and Algorithm 1 depend on these caps; they influence whether a failed path reflects the method or the budget.

assumptions (5)

domain assumption Decision-tree code transfers from easier curricula to harder ones without retraining.
Section 3.1 says the evolved decision tree is preserved as a template for subsequent iterations; the staged method relies on this transfer.
domain assumption The 67% win rate over multiple runs is a valid measure of mastery for a curriculum stage.
Section 4.1 states the threshold but gives no justification; curriculum progression and final success both hinge on it.
domain assumption The curriculum LLM can autonomously design valid, reachable task sequences toward the final task.
Algorithm 2 delegates difficulty adjustment to the LLM and only validates that C' is within the target specification; no reachability or monotonicity guarantee exists.
domain assumption Handcrafted enemy scripts mirror human-level tactical patterns.
Section 4.1 describes scripted opponents that 'mirror human-level gameplay patterns'; this makes the benchmark meaningful as a complex decision-making test.
domain assumption LLM prior knowledge of python-sc2 plus a critic loop is sufficient to produce correct executable code.
Section 3.1 notes LLMs hallucinate nonexistent API functions; the framework depends on critique and retry to converge.

how reviews work

0 comments

Cite this review

Pith. "Pith review of EvoCurr: Self-evolving Curriculum with Behavior Code Generation for Complex Decision-making." pith.science (2026). https://pith.science/paper/X5DW6WPY

@misc{pith2026250809586,
  author       = {Pith},
  title        = {Pith review of: EvoCurr: Self-evolving Curriculum with Behavior Code Generation for Complex Decision-making},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/X5DW6WPY}},
  note         = {Machine review of arXiv:2508.09586}
}

read the original abstract

Large Language Models (LLMs) have demonstrated remarkable capabilities across diverse domains, including programming, planning, and decision-making. However, their performance often degrades when faced with highly complex problem instances that require deep reasoning over long horizons. In such cases, direct problem-solving approaches can lead to inefficiency or failure due to the lack of structured intermediate guidance. To address this, we propose a novel self-evolve framework, EvoCurr, in which a dedicated curriculum-generation LLM constructs a sequence of problem instances with gradually increasing difficulty, tailored to the solver LLM's learning progress. The curriculum dynamically adapts easing challenges when the solver struggles and escalating them when success is consistent, thus maintaining an optimal learning trajectory. This approach enables the solver LLM, implemented as a code-generation model producing Python decision-tree scripts, to progressively acquire the skills needed for complex decision-making tasks. Experimental results on challenging decision-making benchmarks show that our method significantly improves task success rates and solution efficiency compared to direct-solving baselines. These findings suggest that LLM-driven curriculum learning holds strong potential for enhancing automated reasoning in real-world, high-complexity domains.

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

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

Decoupled Travel Planning with Behavior Forest
cs.LG 2026-04 unverdicted novelty 6.0 of 10

Behavior Forest decouples multi-constraint travel planning into parallel behavior trees with LLM nodes and global coordination, yielding 6.67% and 11.82% gains over prior methods on two benchmarks.

Reference graph

Works this paper leans on

54 extracted references · 27 canonical work pages · cited by 1 Pith paper

[1]

Philip J. Ball, Jakob Bauer, Frank Belletti, Bethanie Brownfield, Ariel Ephrat, Shlomi Fruchter, Agrim Gupta, Kristian Holsheimer, Aleksander Holynski, Jiri Hron, Christos Kaplanis, Marjorie Limont, Matt McGill, Yanko Oliveira, Jack Parker-Holder, Frank Perbet, Guy Scully, Jeremy Shar, Stephen Spencer, Omer Tov, Ruben Villegas, Emma Wang, Jessica Yung, Ci...

work page 2025
[2]

Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. 2009. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning. ACM, 41–48

work page 2009
[3]

Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. Advances in Neural Information Processing Systems 33 (2020), 1877–1901

work page 2020
[4]

Jake Bruce, Michael Dennis, Ashley Edwards, Jack Parker-Holder, Yuge Shi, Edward Hughes, Matthew Lai, Aditi Mavalankar, Richie Steigerwald, Chris Apps, Yusuf Aytar, Sarah Bechtle, Feryal Behbahani, Stephanie Chan, Nicolas Heess, Lucy Gonzalez, Simon Osindero, Sherjil Ozair, Scott Reed, Jingwei Zhang, Konrad Zolna, Jeff Clune, Nando de Freitas, Satinder Si...

arXiv 2024
[5]

Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Li, Scott Lundberg, Harsha Nori, et al

work page
[6]

Haoxuan Che, Xuanhua He, Quande Liu, Cheng Jin, and Hao Chen

work page
[7]

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021)

arXiv 2021
[8]

Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav

Show all 54 references

[9]

Decart Team, Julian Quevedo, Quinn McIntyre, Spruce Campbell, Xinlei Chen, and Robert Wachen. 2024. Oasis: A Universe in a Transformer. https://oasis- model.github.io/

2024
[10]

Yue Deng, Weiyu Ma, Yuxin Fan, Ruyi Song, Yin Zhang, Haifeng Zhang, and Jian Zhao. 2025. SMAC-R1: The Emergence of Intelligence in Decision-Making Tasks. arXiv:2410.16024 [cs.AI] https://arxiv.org/abs/2410.16024

2025 arXiv
[11]

Yue Deng, Yan Yu, Weiyu Ma, Zirui Wang, Wenhui Zhu, Jian Zhao, and Yin Zhang
[12]

Chrisantha Fernando, Dylan Banarse, Henryk Michalewski, Simon Osindero, and Tim Rocktäschel. 2023. Promptbreeder: Self-Referential Self-Improvement Via Prompt Evolution. arXiv:2309.16797 [cs.CL] https://arxiv.org/abs/2309.16797

2023 arXiv
[13]

Alex Graves, Marc G Bellemare, Jacob Menick, Rémi Munos, and Koray Kavukcuoglu. 2017. Automated curriculum learning for neural networks. In Proceedings of the 34th International Conference on Machine Learning . PMLR, 1311–1320

2017
[14]

Junliang Guo, Yang Ye, Tianyu He, Haoyu Wu, Yushu Jiang, Tim Pearce, and Jiang Bian. 2025. MineWorld: a Real-Time and Open-Source Interactive World Model on Minecraft. arXiv:2504.08388 [cs.CV] https://arxiv.org/abs/2504.08388

2025 arXiv
[15]

arXiv:2412.17707 [cs.AI] https://arxiv.org/abs/2412.17707

SMAC-Hard: Enabling Mixed Opponent Strategy Script and Self-play on SMAC. arXiv:2412.17707 [cs.AI] https://arxiv.org/abs/2412.17707

arXiv
[16]

Chengpeng Hu, Yunlong Zhao, and Jialin Liu. 2024. Game Generation via Large Language Models. arXiv:2404.08706 [cs.AI] https://arxiv.org/abs/2404.08706

2024 arXiv
[17]

Pu Hua, Minghuan Liu, Annabella Macaluso, Yunfeng Lin, Weinan Zhang, Huazhe Xu, and Lirui Wang. 2024. GenSim2: Scaling Robot Data Generation with Multi- modal and Reasoning LLMs. arXiv:2410.03645 [cs.RO] https://arxiv.org/abs/ 2410.03645

2024 arXiv
[18]

Ruozi Huang, Xipeng Wu, Hongsheng Yu, Zhong Fan, Haobo Fu, QIANG FU, and Yang Wei. 2023. A Robust and Opponent-Aware League Training Method for StarCraft II. In Thirty-seventh Conference on Neural Information Processing Systems

2023
[19]

Lei Han, Jiechao Xiong, Peng Sun, Xinghai Sun, Meng Fang, Qingwei Guo, Qiaobo Chen, Tengfei Shi, Hongsheng Yu, Xipeng Wu, et al. 2020. Tstarbot-x: An open- sourced and comprehensive study for efficient league training in starcraft ii full game. arXiv preprint arXiv:2011.13729 (2020)

2020 arXiv
[20]

Zongyuan Li, Yanan Ni, Runnan Qi, Lumin Jiang, Chang Lu, Xiaojie Xu, Xiangbei Liu, Pengfei Li, Yunzheng Guo, Zhe Ma, Huanyu Li, Hui Wu, Xian Guo, Kuihua Huang, and Xuebo Zhang. 2025. LLM-PySC2: Starcraft II learning environment for Large Language Models. arXiv:2411.05348 [cs.A...

2025 arXiv
[21]

Ruo-Ze Liu, Haifeng Guo, Xiaozhong Ji, Yang Yu, Zhen-Jia Pang, Zitai Xiao, Yuzhou Wu, and Tong Lu. 2021. Efficient reinforcement learning for starcraft by abstract forward models and transfer learning. IEEE Transactions on Games 14, 2 (2021), 294–307

2021
[22]

Ruo-Ze Liu, Zhen-Jia Pang, Zhou-Yu Meng, Wenhai Wang, Yang Yu, and Tong Lu. 2022. On efficient reinforcement learning for full-length game of starcraft ii. Journal of Artificial Intelligence Research 75 (2022), 213–260

2022
[23]

Yujia Li, Maxwell Nye, Jacob Andreas, Jasmijn Bastings, Shruti Bhosale, James Bradbury, Jacob Austin, Greg Brockman, Trevor Cai, Ciprian Chelba, et al. 2022. Competition-level code generation with AlphaCode. Science 378, 6624 (2022), 1092–1097

2022
[24]

Weiyu Ma, Yuqian Fu, Zecheng Zhang, Bernard Ghanem, and Guohao Li. 2025. AVA: Attentive VLM Agent for Mastering StarCraft II. arXiv:2503.05383 [cs.AI] https://arxiv.org/abs/2503.05383

2025 arXiv
[25]

Weiyu Ma, Qirui Mi, Yongcheng Zeng, Xue Yan, Yuqiao Wu, Runji Lin, Haifeng Zhang, and Jun Wang. 2024. Large Language Models Play StarCraft II: Bench- marks and A Chain of Summarization Approach. arXiv:2312.11865 [cs.AI] https://arxiv.org/abs/2312.11865

2024 arXiv
[26]

Michael Mathieu, Sherjil Ozair, Srivatsan Srinivasan, Caglar Gulcehre, Shangtong Zhang, Ray Jiang, Tom Le Paine, Konrad Zolna, Richard Powell, Julian Schrit- twieser, et al. 2021. Starcraft ii unplugged: Large scale offline reinforcement learning. In Deep RL Workshop NeurIPS 2021

2021
[27]

Ruo-Ze Liu, Wenhai Wang, Yanjie Shen, Zhiqi Li, Yang Yu, and Tong Lu. 2021. An Introduction of mini-AlphaStar. arXiv preprint arXiv:2104.06890 (2021)

2021 arXiv
[28]

OpenAI. 2023. GPT-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

2023 arXiv
[29]

Jack Parker-Holder, Philip Ball, Jake Bruce, Vibhavari Dasagi, Kristian Hol- sheimer, Christos Kaplanis, Alexandre Moufarek, Guy Scully, Jeremy Shar, Jimmy Shi, Stephen Spencer, Jessica Yung, Michael Dennis, Sultan Kenjeyev, Shangbang Long, Vlad Mnih, Harris Chan, Maxime Gazea...

2024
[30]

Raphaël Portelas, Cédric Colas, Lionel Weng, Katja Hofmann, and Pierre-Yves Oudeyer. 2020. Automatic curriculum learning for deep RL: A short survey.arXiv preprint arXiv:2003.04664 (2020)

2020 arXiv
[31]

Sanmit Narvekar, Bei Peng, Matteo Leonetti, Jivko Sinapov, Matthew E Taylor, and Peter Stone. 2020. Curriculum learning for reinforcement learning domains: A framework and survey. Journal of Machine Learning Research 21, 181 (2020), 1–50

2020
[32]

Yu Shang, Yu Li, Keyu Zhao, Likai Ma, Jiahe Liu, Fengli Xu, and Yong Li
[33]

Haotian Sun, Yuchen Zhuang, Lingkai Kong, Bo Dai, and Chao Zhang
[34]

Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, An- drew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. 2019. Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature 575, 7782 (2019), 350–354

2019
[35]

Zehan Qi, Xiao Liu, Iat Long Iong, Hanyu Lai, Xueqiao Sun, Wenyi Zhao, Yu Yang, Xinyue Yang, Jiadai Sun, Shuntian Yao, Tianjie Zhang, Wei Xu, Jie Tang, and Yuxiao Dong. 2025. WebRL: Training LLM Web Agents via Self-Evolving Online Curriculum Reinforcement Learning. arXiv:2411....

2025 arXiv
[36]

Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voyager: An Open-Ended Embodied Agent with Large Language Models.arXiv preprint arXiv: Arxiv-2305.16291(2023)

2023 arXiv
[37]

arXiv:2410.06153 [cs.CL] https://arxiv.org/abs/2410.06153

AgentSquare: Automatic LLM Agent Search in Modular Design Space. arXiv:2410.06153 [cs.CL] https://arxiv.org/abs/2410.06153

arXiv
[38]

Xiangjun Wang, Junxiao Song, Penghui Qi, Peng Peng, Zhenkun Tang, Wei Zhang, Weimin Li, Xiongjun Pi, Jujie He, Chao Gao, et al. 2021. SCC: An efficient deep reinforcement learning agent mastering the game of StarCraft II. In International conference on machine learning . PMLR,...

2021
[39]

arXiv:2305.16653 [cs.CL] https://arxiv.org/abs/2305.16653

AdaPlanner: Adaptive Planning from Feedback with Language Models. arXiv:2305.16653 [cs.CL] https://arxiv.org/abs/2305.16653

arXiv
[40]

Nicholas Waytowich, Sean L Barton, Vernon Lawhern, Ethan Stump, and Garrett Warnell. 2019. Grounding natural language commands to StarCraft II game states for narration-guided reinforcement learning. InArtificial intelligence and machine learning for multi-domain operations ap...

2019
[41]

Oriol Vinyals, Timo Ewalds, Sergey Bartunov, Petko Georgiev, Alexander Sasha Vezhnevets, Michelle Yeo, Alireza Makhzani, Heinrich Küttler, John Agapiou, Julian Schrittwieser, et al. 2017. Starcraft ii: A new challenge for reinforcement learning. arXiv preprint arXiv:1708.04782 (2017)

2017 arXiv
[42]

Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D Goodman. 2022. STaR: Boot- strapping reasoning with reasoning. InAdvances in Neural Information Processing Systems, Vol. 35. 15398–15411

2022
[43]

Lirui Wang, Yiyang Ling, Zhecheng Yuan, Mohit Shridhar, Chen Bao, Yuzhe Qin, Bailin Wang, Huazhe Xu, and Xiaolong Wang. 2024. GenSim: Generating Robotic Simulation Tasks via Large Language Models. arXiv:2310.01361 [cs.LG] https://arxiv.org/abs/2310.01361

2024 arXiv
[44]

Liu, Hong Wang, Jian Zhao, and Yang Wang

Chen Zhang, Qiang He, Zhou Yuan, Elvis S. Liu, Hong Wang, Jian Zhao, and Yang Wang. 2024. Advancing DRL Agents in Commercial Fighting Games: Training, Integration, and Agent-Human Alignment. arXiv:2406.01103 [cs.AI] https://arxiv.org/abs/2406.01103

2024 arXiv
[45]

Zihan Wang, Kangrui Wang, Qineng Wang, Pingyue Zhang, Linjie Li, Zhengyuan Yang, Xing Jin, Kefan Yu, Minh Nhat Nguyen, Licheng Liu, Eli Gottlieb, Yiping Lu, Kyunghyun Cho, Jiajun Wu, Li Fei-Fei, Lijuan Wang, Yejin Choi, and Manling Li. 2025. RAGEN: Understanding Self-Evolution...

2025 arXiv
[46]

Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, Bingnan Zheng, Bang Liu, Yuyu Luo, and Chenglin Wu. 2025. AFlow: Automating Agentic Workflow Generation. arXiv:2410.10762 [cs.AI] https://arxiv.o...

2025 arXiv
[47]

Abhay Zala, Jaemin Cho, Han Lin, Jaehong Yoon, and Mohit Bansal. 2024. EnvGen: Generating and Adapting Environments via LLMs for Training Embodied Agents. arXiv:2403.12014 [cs.CL] https://arxiv.org/abs/2403.12014

2024 arXiv
[49]

Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman. 2022. STaR: Bootstrapping Reasoning With Reasoning. arXiv:2203.14465 [cs.LG] https: //arxiv.org/abs/2203.14465

2022 arXiv
[51]

Chen Zhang, Huan Hu, Yuan Zhou, Xu Wang, and Elvis S. Liu. 2025. HIFAS: A Hybrid Interactive FPS Agent System for Large Game Maps. IEEE Transactions on Games (2025), 1–13. https://doi.org/10.1109/TG.2025.3567869

2025
[53]

Yifei Zhou, Sergey Levine, Jason Weston, Xian Li, and Sainbayar Sukhbaatar
[54]

Marine Micro Bot - 5v2 Marines vs Zealots!

Self-Challenging Language Model Agents. arXiv:2506.01716 [cs.AI] https://arxiv.org/abs/2506.01716 A Appendix: Introduction to StarCraft II StarCraft II is a real-time strategy game developed by Blizzard Entertainment that has become one of the most challenging and strategicall...

2010 arXiv
[2023]

arXiv preprint arXiv:2303.12712 (2023)

Sparks of artificial general intelligence: Early experiments with GPT-4. arXiv preprint arXiv:2303.12712 (2023)

2023 arXiv
[2024]

arXiv:2411.00769 [cs.CV] https://arxiv.org/abs/2411.00769

GameGen-X: Interactive Open-world Game Video Generation. arXiv:2411.00769 [cs.CV] https://arxiv.org/abs/2411.00769

arXiv
[2025]

arXiv:2504.19413 [cs.CL] https://arxiv.org/abs/2504.19413

Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv:2504.19413 [cs.CL] https://arxiv.org/abs/2504.19413

arXiv

Pith tools

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

[1] [1]

Philip J. Ball, Jakob Bauer, Frank Belletti, Bethanie Brownfield, Ariel Ephrat, Shlomi Fruchter, Agrim Gupta, Kristian Holsheimer, Aleksander Holynski, Jiri Hron, Christos Kaplanis, Marjorie Limont, Matt McGill, Yanko Oliveira, Jack Parker-Holder, Frank Perbet, Guy Scully, Jeremy Shar, Stephen Spencer, Omer Tov, Ruben Villegas, Emma Wang, Jessica Yung, Ci...

work page 2025

[2] [2]

Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. 2009. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning. ACM, 41–48

work page 2009

[3] [3]

Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. Advances in Neural Information Processing Systems 33 (2020), 1877–1901

work page 2020

[4] [4]

Jake Bruce, Michael Dennis, Ashley Edwards, Jack Parker-Holder, Yuge Shi, Edward Hughes, Matthew Lai, Aditi Mavalankar, Richie Steigerwald, Chris Apps, Yusuf Aytar, Sarah Bechtle, Feryal Behbahani, Stephanie Chan, Nicolas Heess, Lucy Gonzalez, Simon Osindero, Sherjil Ozair, Scott Reed, Jingwei Zhang, Konrad Zolna, Jeff Clune, Nando de Freitas, Satinder Si...

arXiv 2024

[5] [5]

Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Li, Scott Lundberg, Harsha Nori, et al

work page

[6] [6]

Haoxuan Che, Xuanhua He, Quande Liu, Cheng Jin, and Hao Chen

work page

[7] [7]

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021)

arXiv 2021

[8] [8]

Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav