A Multi-Chain-of-Thought Prompting Framework for S...

A Multi-Chain-of-Thought Prompting Framework for StarCraft II Micromanagement with Large Language Models
First Author1[0000-1111-2222-3333] and Second Author2[1111-2222-3333-4444]
1 Princeton University, Princeton NJ 08544, USA
2 Springer Heidelberg, Tiergartenstr. 17, 69121 Heidelberg, Germany
[email protected]
Abstract. The abstract should summarize the contents of the paper in short terms, i.e. 150-250 words.
Keywords: First Keyword, Second Keyword, Third Keyword.
1 First Section
1.1 A Subsection Sample
Please note that the first paragraph of a section or subsection is not indented. The first paragraphs that follows a table, figure, equation etc. does not have an indent, either.
Subsequent paragraphs, however, are indeFig. 1. A figure caption is always placed below the illustration. Short captions are centered, while long ones are justi-fied. The macro button chooses the correct format automatically.nted.Fig. 1
Sample Heading (Third Level). Only two levels of headings should be numbered. Lower level headings remain unnumbered; they are formatted as run-in headings.
Sample Heading (Forth Level). The contribution should contain no more than four levels of headings. The following Table 1 gives a summary of all heading lev-els.Table 1. Table captions should be placed above the tables.
Table 1. Table captions should be placed above the tables.
Heading level Example Font size and style
Title (centered) Lecture Notes 14 point, bold
1st-level heading 1 Introduction 12 point, bold
2nd-level heading 2.1 Printing Area 10 point, bold
3rd-level heading Run-in Heading in Bold. Text follows 10 point, bold
4th-level heading Lowest Level Heading. Text follows 10 point, italic
Displayed equations are centered and set on a separate line.
x + y = z (1)
Please try to avoid rasterized images for line-art diagrams and schemas. Whenever possible, use vector graphics instead (see Fig. 1).

Fig. 1. A figure caption is always placed below the illustration. Short captions are centered, while long ones are justified. The macro button chooses the correct format automatically.
For citations of references, we prefer the use of square brackets and consecutive numbers. Citations using labels or the author/year convention are also acceptable. The following bibliography provides a sample reference list with entries for journal articles [1], an LNCS chapter [2], a book [3], proceedings without editors [4], as well as a URL [5].
References

1. Author, F.: Article title. Journal 2(5), 99–110 (2016).
2. Author, F., Author, S.: Title of a proceedings paper. In: Editor, F., Editor, S. (eds.) CONFERENCE 2016, LNCS, vol. 9999, pp. 1–13. Springer, Heidelberg (2016).
3. Author, F., Author, S., Author, T.: Book title. 2nd edn. Publisher, Location (1999).
4. Author, F.: Contribution title. In: 9th International Proceedings on Proceedings, pp. 1–2. Publisher, Location (2010).
5. LNCS Homepage, http://www.springer.com/lncs, last accessed 2016/11/21.
   请你理解上述投稿要求,下面我会把我的投稿内容给你,请你帮助审核

检查有无逻辑问题\重复问题\格式问题\缩写问题等
A Multi-Chain-of-Thought Prompting Framework for StarCraft II Micromanagement with Large Language Models
Yanan Ni 1 Runnan Qi^1, Xuhua Huang^1, and Second Author2
1 College of Systems Engineering, National University of Defense Technology, Changsha 410073, China
[email protected]
Abstract. With the rapid advancement of multimodal large language models (LLMs), enabling fine-grained unit control in complex real-time strategy (RTS) games has become a key challenge. This paper proposes MCoT‑SC2, a multi-Chain-of-Thought prompting-driven micro-control framework for StarCraft II that requires no additional training. By leveraging structured prompts, the framework achieves unified perception and tactical reasoning over both image and text observations. MCoT‑SC2 constructs parallel reasoning paths—aggressive, conservative, and balanced—and selects the optimal strategy through a self-evaluation mechanism. In a high-difficulty StarCraft II scenario, the method achieves a 55% win rate under zero-shot conditions, significantly outperforming non-chain and single-chain baselines. Experimental results demonstrate that MCoT‑SC2 substantially improves strategic diversity, micro-control stability, and interpretability, offering a promising solution for building general-purpose language-based agents.
Keywords: Large Language Models; Multi-Chain-of-Thought Prompting; StarCraft II; Fine-Grained Control; Real-Time Strategy Games.
Introduction
StarCraft II (SC2) is a real-time strategy game with complex terrain and asymmetric unit types, widely used as a benchmark for multi-agent reinforcement learning (MARL) and adversarial planning. AlphaStar, trained with large-scale reinforcement learning, reached Grandmaster level in SC2, underscoring the environment’s research value [1]. The rapid progress of large language models (LLMs) such as ChatGPT and LLaMA [2–3], together with multimodal systems like GPT-4o [4], has sparked interest in language-driven game control by leveraging their high-level reasoning capabilities. Early attempts—TextStarCraft II [5] and SwarmBrain [6]—focused on macro-strategy generation, while LLM-PySC2 [7] provided a multimodal interface combining screen images with structured text, laying the groundwork for LLM-based RTS agents.
Despite these advances, micro-level control—requiring fine-grained actions in rapidly changing battles—remains under-explored due to limited visual grounding, coarse action spaces, and the absence of structured reasoning [5–7]. We therefore present MCoT-SC2, a prompt-only framework that steers an LLM to produce three parallel tactical chains (aggressive, balanced, conservative) and selects the best via self-evaluation, enabling zero-shot, interpretable decisions. In the challenging “1 Colossus vs 32 Zerglings” scenario on LLM-PySC2, MCoT-SC2 attains a 55 % win rate at 1 Hz control—15 percentage points above the baseline—demonstrating its promise for RTS micromanagement and paving the way toward general-purpose LLM controllers.
Related Work
LLMs for Control in RTS Games
On the StarCraft II (SC2) platform, AlphaStar achieved Grandmaster-level performance through deep reinforcement learning (MARL), solidifying SC2’s role as a benchmark for complex adversarial environments [1]. With the emergence of large language models (LLMs) such as ChatGPT and LLaMA [2–3], a new paradigm of language-based decision-making has gained traction. TextStarCraft II was the first to apply LLMs for high-level strategy planning in SC2 but was limited to macro-level commands and could not handle fine-grained control tasks [5]. SwarmBrain introduced a hybrid architecture combining a macro LLM and a micro ReflexNet, but the LLM lacked access to visual information, limiting multimodal integration [6]. LLM-PySC2 extended this direction by exposing both image and structured observation data to LLMs, creating a foundation for multimodal control, but lacked fine-grained action templates and efficient prompting mechanisms [7].
Multimodal Prompting and Situation Awareness
Multimodal models such as GPT-4o have demonstrated strong capabilities in visual-text reasoning tasks [4]. In the domain of game control, frameworks like VARP (Vision-Action Role-Playing) for Black Myth: Wukong [8] and Cradle [9] significantly improved performance in mid- to low-speed scenarios by combining screen captures with interface-level text prompting. Although LLM-PySC2 supports both image and textual input, it lacks structured prompting templates to guide the model in leveraging coordinate, cooldown, and legal action information. A generalizable “screenshot-text-action” prompting scheme for real-time strategy games is still absent.
Chain-of-Thought Reasoning
Chain-of-thought (CoT) prompting has been shown to enhance multi-step reasoning in LLMs by decomposing complex problems into explicit intermediate steps [10]. Variants such as self-consistent CoT [11], Tree-of-Thought (ToT) [12], and Multimodal-CoT [13] further improve performance in logic reasoning, visual question answering, and scientific inference. Surveys have suggested that these techniques hold promise for real-time strategy (RTS) decision-making scenarios [14]. However, existing CoT research is mostly confined to offline or symbolic reasoning tasks and has yet to address two key challenges in RTS settings: (1) how to generate structured, executable control actions from multimodal input; and (2) how to perform parallel reasoning and self-evaluation at a pace of 1 Hz or higher, yielding a single executable decision per step.
Method
Framework Overview
We propose a micro-control framework driven by Multi-Chain-of-Thought Prompting (MCoT-Prompt) for unit-level decision-making in StarCraft II. At the core of this method is a structured prompting system designed to guide large language models (LLMs) to generate multiple parallel strategic reasoning chains based on multimodal observations and to autonomously evaluate and select actions.

Fig. 1. Decision process of LLM-PySC2 under the MCoT prompting framework
The prompt system consists of the following three key components:
System Prompt: Specifies the agent role, task objectives, output format, and reasoning templates for three strategic styles (conservative, balanced, aggressive). It also enumerates valid action types and parameter ranges.
Example Input: Provides a sample observation pair (structured text + RGB image) along with its formatted prompt input to help the model understand context and input structure.
Example Output: Demonstrates three complete chains of reasoning, the self-evaluation process, and the final action format, offering the model an explicit template for both content and structure.
As illustrated in the above Fig. 1, at each control step, the model receives multimodal inputs consisting of structured textual observations and an RGB screen image, which are passed into the observation portion of the MCoT-Prompt. Combined with system-level task definitions and demonstration examples, the LLM concurrently generates three reasoning paths of different tactical styles. It then performs self-evaluation to select the best option and outputs a final executable action sequence.
Multi-Chain-of-Thought Reasoning and Self-Evaluated Decision Making
In each decision cycle t, MCoT-SC2 takes multimodal observations provided by LLM-PySC2 as input and generates three parallel reasoning chains with distinct tactical preferences. A self-evaluation mechanism then selects the most promising strategy. The input consists of two modalities: the visual observation I_t and structured state information O_t. Here, I_t refers to an RGB screenshot of the current frame, encoded via Base64 and injected as an image token into the LLM. The structured observation O_t includes unit positions, health values, weapon cooldowns, previous actions, and available commands—serialized into a text-based state sequence compatible with LLM input.
Using a unified prompt template, the pair (I_t,O_t ) is embedded into a formatted input sequence, prompting the LLM to concurrently generate multiple reasoning chains:
C_k={〖"step" 〗1^k,…,〖"step" 〗6^k }, k∈{"A","B","C"} (1)
where C_A, C_B, and C_C correspond to aggressive, balanced, and conservative tactical styles, respectively. Each chain follows a fixed six-step reasoning framework, covering environment analysis, threat assessment, cooldown check, action sequencing, target selection, and final instruction synthesis. The output is rendered as structured natural language containing action tags such as <Move_Screen(...)> and <Attack_Unit(...)>.Upon completing all three reasoning chains, the system triggers a self-evaluation phase. Instead of applying a numerical scoring function, the LLM performs a qualitative comparison based on its internal understanding of task goals, generating narrative assessments for each chain:
E={(C_k,Δ_k )∣k∈{"A" ,"B" ,"C" }} (2)
where Δ_k denotes the textual evaluation of chain C_k, typically involving considerations of spatial safety, enemy proximity, and skill availability. Based on these narratives, the model identifies the most appropriate strategy under current conditions:
C^⋆=arg max┬k "NarrativePreference" (Δ_k ) (3)
Finally, the system extracts the <Actions> segment from the end of the selected chain C^⋆ as the executable output:
A_t="ExtractActions" (C^⋆ )  (4)
This multi-chain, self-evaluated mechanism enhances both decision diversity and interpretability, while maintaining full compatibility with open-ended LLMs through prompt-only control.
Multimodal Prompt Construction and Environment Interaction
In each decision cycle, MCoT-SC2 constructs a structured input sequence through a unified multimodal prompting process, guiding the large language model to perform multi-chain reasoning. The prompt consists of four key components: a System Prompt, Example Input, Example Output, and real-time match observations that include both visual and textual data. The visual input is an RGB screenshot of the current frame, encoded in Base64 format and injected as an image token. The textual component contains structured information such as unit states, game time, resource counts, weapon cooldowns, and legal actions.
All components are encapsulated into a multi-turn message format compatible with GPT-based LLMs, labeled using standard roles—system, user, and assistant. This structure ensures that the model can accurately distinguish between instruction, input, and reference content within the prompt sequence.
The detailed prompt construction procedure is outlined in Table 1. The function SC2_PROMPT receives the current textual observation o_t, system prompt spr, example input p"in" , example output p"out" , and the current frame image img, and sequentially injects them into a message queue MsgSeq. This message sequence is then used as the full input to the language model, triggering multi-chain reasoning and subsequent action generation.
Table 1 Multimodal Prompt Construction Process Integrating Multi-Chain Reasoning
Input：ot: Textual observation (units, resources, game time, etc.)；spr: System prompt；pIn: Example input；po: Example output (expected action format)；img: Real-time game screenshot (Base64-encoded)
Output：MsgSeq: Multimodal message sequence for LLM reasoning
Function SC2_PROMPT(ot, spr, pIn, po, img)
MsgSeq←∅
MsgSeq.append(spr, role=“system”)
MsgSeq.append(pIn, role=“user”)
MsgSeq.append(po, role=“assistant”)
MsgSeq.append(img, role=“user”)
MsgSeq.append(ot, role=“user”)
Return MsgSeq
end Function
Experimental Setup
Experimental Environment and Task Configuration
All experiments in this study are conducted on our custom-built LLM-PySC2 platform. Built upon DeepMind’s original PySC2 library, the platform extends support for a full action space and multimodal observation interfaces. It captures RGB game frames at a frequency of 1 Hz and overlays a 256×256 screen coordinate grid (with auxiliary lines every 32 pixels). In addition, it provides structured textual observations, including unit coordinates, health status, cooldown timers, and legal action lists. The system prompt explicitly specifies that the LLM may directly output fine-grained instructions such as <Move_Screen([x,y])> and <Attack_Unit(tag)>, which are automatically parsed into low-level PySC2 API calls, forming a closed-loop control system of observation, reasoning, and execution.

Fig. 2. StarCraft II Battle Scene Featuring High-Ground and Low-Ground Terrain
To evaluate model performance under dynamic RTS conditions, we design a representative test scenario: “1 Colossus vs 32 Zerglings” Fig. 2). The Colossus is a long-range, high-damage unit, while Zerglings are numerous, fast-moving melee attackers. This asymmetric setup demands real-time terrain exploitation, path planning, and rapid decision-making. The task is formalized as a discrete-time multimodal decision problem, where each state at time ttt is defined as:
S_t=(I_t,O_t) (5)
Each step allows up to three commands grounded in pixel-level control:
A_t={a_1,a_2 },a_i∈{"Move_Screen","Attack_Unit"} (6)
with coordinates in [0,256)^2. The prompt follows a unified structure with two components: (1) a Multi-Chain-of-Thought (MCoT) reasoning template for generating aggressive, conservative, and balanced strategies, and (2) auxiliary priors describing map layout and unit constraints. The LLM then outputs the final actions via:
A_t="LLM" (S_t,〖"Prompt" 〗"MCoT" ) (7)
This task presents three core challenges: (1) multimodal fusion, requiring joint processing of images and structured text; (2) large action space, involving discrete control over a 256×256 grid; and (3) interpretable reasoning, where action chains must be logically sound and analyzable.
Evaluation Metrics
To comprehensively assess the control capability of MCoT‑SC2 in StarCraft II micro-management tasks, we adopt five core metrics covering tactical effectiveness, unit-level output efficiency, engagement duration, and survival performance of key units.
Win Rate (W) measures the overall success of the model and is defined as the ratio of the number of victories N"win" to the total number of games N_"total" , i.e., W=N_"win" /N_"total" . Average Kills (E_"avg" ) quantifies offensive efficiency by computing the average number of enemy units eliminated per game, calculated as E_"avg" =1/N_"total" ∑(i=1)^(N"total" )▒E_i , where E_i denotes the kill count in the i-th game.
To capture temporal dynamics across outcomes, we introduce Time in Wins (T_"win" ) and Time in Failures (T_"lose" ). The former is computed as T_"win" =1/N_"win" ∑(i=1)^(N"win" )▒t_i^"win" , while the latter is defined as T_"lose" =1/N_"fail" ∑(j=1)^(N"fail" )▒t_j^"fail" , with N_"fail" =N_"total" -N_"win" .
Health Ratio in Wins (H_"win" ) evaluates the remaining hitpoints of the Colossus in successful matches, serving as a proxy for survivability and control precision. It is calculated as H_"win" =1/N_"win" ∑(i=1)^(N"win" )▒((HP_i)/(HP_"max" )×100%) , where HP_i denotes the final health of the Colossus in the i-th win, and HP_"max" is the unit's maximum health.
Results and Analysis
Overall Performance and Ablation Study
To evaluate the overall control effectiveness of MCoT‑SC2 in high-dynamic micro-control tasks, we conduct comparative experiments in the "1 Colossus vs. 32 Zerglings" scenario in StarCraft II, benchmarking three different strategy frameworks across five core metrics: Win Rate (W), Average Kills (E_"avg" ), Time in Wins (T_"win" ), Time in Failures (T_"lose" ), and Health Ratio in Wins (H_"win" ).
The three compared methods include: Baseline, which employs the original LLM‑PySC2 prompt without chain-of-thought reasoning or spatial structural guidance; Single-CoT, which introduces a single chain-of-thought reasoning flow but lacks parallel strategy branches and self-evaluation; and the proposed MCoT‑SC2, which incorporates three stylistic reasoning chains, structured prompting templates, and an automatic self-evaluation mechanism.
Table 2. Performance comparison of three strategies on micro-control tasks
Setting W (%) E_"avg" T_"win" (s) T_"lose" (s) H_"win" (%)
Baseline 0 16.5 0 8.75 0
Single-CoT 40 24.9 20.25 15 29.7
MCoT‑SC2 55 26.4 50.91 40 26
As shown in Table 2, MCoT‑SC2 outperforms the baselines across most metrics. In terms of win rate, the Baseline fails to achieve any wins (0%), while Single-CoT reaches 40%, and MCoT‑SC2 further improves to 55%, indicating the significant contribution of multi-chain reasoning and self-evaluation mechanisms to strategy quality. For average kills, MCoT‑SC2 achieves 26.4, outperforming both Baseline (16.5) and Single-CoT (24.9), suggesting enhanced offensive efficiency.
Moreover, MCoT‑SC2 demonstrates stronger defensive resilience and adaptive capability in losing games, with an average failure duration of 40 seconds, notably longer than Baseline (8.75 s) and Single-CoT (15 s). Although the health ratio of the Colossus in winning games under MCoT‑SC2 (26%) is slightly lower than Single-CoT (29.7%), it remains significantly better than Baseline (0%), reflecting the framework's ability to balance offensive output with survival control.
In summary, MCoT‑SC2 achieves superior overall performance in micro-control tasks, exhibiting improved robustness, and upper-limit control capability. These results validate the effectiveness of multi-Chain-of-Thought prompting and structured input strategies in enhancing decision-making quality under complex real-time environments.
Computational Resources and Reasoning Overhead
To evaluate the overall efficiency and expressive capacity of MCoT SC2, we conduct a comparative analysis of three control strategies within the “1 Colossus vs 32 Zerglings” micro-control task, all implemented on the LLM PySC2 platform: baseline prompting, single-chain reasoning (Single-CoT), and the proposed multi-chain reasoning structure (MCoT SC2). All methods operate under a unified 1 Hz control frequency, executing one sense–reason–act loop per second, ensuring temporal consistency for fair comparison. The number of API calls reflects the duration of control cycles and indirectly measures unit survival time, while token counts characterize the complexity and density of linguistic interactions per decision step.
As shown in Table 3, MCoT SC2 significantly prolongs unit survivability, with an average of 44.5 calls per match, and produces a much higher volume of textual output, with an average of 39,486 output tokens. Table 4 further shows that its output-to-input token ratio reaches 23.5%, surpassing Single-CoT (20.4%) and Baseline (5.33%), indicating higher linguistic compression efficiency and stronger tactical expressiveness. Although MCoT SC2 incurs an average inference cost of $1.43 per match (calculated based on the OpenAI GPT 4o pricing scheme at$0.005 per 1k input tokens and $0.015 per 1k output tokens), the resulting content exhibits superior causal logic, clear instruction structure, and self-explanatory reasoning—making it well-suited for constructing high-quality micro-control corpora and behavior-tracking modules in fine-grained tactical scenarios.
Table 3. Resource Usage per Match Across Control Strategies (Mean ± SD)
Method Calls Input Tokens Output Tokens Cost (USD)
Baseline 8.65 ± 0.49 28,868 ± 1,578 1,541 ± 93 0.17
Single-CoT 18.5 ± 5.9 39,748 ± 10,915 8,117 ± 2,708 0.32
Multi-CoT 44.5 ± 19.3 168,304± 67,283 39,486 ± 17,139 1.43
Table 4. Average Token Usage and Language Efficiency per API Interaction across Strategies
Method Input per Call Output per Call Output/Input Ratio
Baseline 3,338 ± 182 178 ± 11 5.33 ± 0.20
Single-CoT 2,149 ± 590 439 ± 146 20.4 ± 1.6
Multi-CoT 3,782 ± 1,513 887 ± 386 23.5 ± 0.8

Behavioral Analysis and Chain-of-Thought Diagnosis
To further examine the benefits of the multi-chain reasoning mechanism, this section analyzes a representative execution segment from the Single-CoT strategy during a 4-second combat window (16–20 seconds).Fig. 3 illustrates the map state and action sequences generated across four consecutive decision cycles.

Fig. 3. Action trajectory and command output of the Single-CoT strategy from 16–22s
As shown in the figure, the model repeatedly issues the same movement command <Move_Screen([180,160])> across all four timesteps, without any adjustment or compensation despite dynamic changes in enemy positions, unit status, and surrounding terrain. This fixed-path behavior reflects a clear lack of trajectory diversity and adaptive strategy adjustment, with the following issues:
The model fails to adjust its retreat direction based on damage received or flanking angles, persistently selecting a single point (e.g., [180,160]) as the movement target. As a result, the unit is frequently intercepted or surrounded and cannot effectively escape from danger zones. While the output superficially alternates between "move + attack" and "attack + move" cycles, it does not adapt the path to reflect enemy pressure angles or map boundary constraints—indicating insufficient flexibility in the decision plan.
Overall, although single-chain reasoning achieves basic sequential control, it generates highly redundant trajectories and lacks adaptability. In fast-paced combat scenarios, this often leads to motion stagnation and directional mismatch, weakening the unit's survivability. These findings validate the necessity of a multi-chain structure: by generating diverse candidate paths and selecting the best plan through internal self-evaluation, MCoT‑SC2 significantly improves behavioral diversity and path rationality, demonstrating superior adaptability and robustness in high-dynamic micro-control tasks.
Conclusion and Future Work
Summary
MCoT-SC2 is a prompt-only framework that equips large language models (LLMs) with fine-grained micromanagement skills in complex real-time strategy games. A unified multimodal prompt fuses screen images and structured text, drives three parallel reasoning chains—aggressive, balanced, defensive—and picks the best via self-evaluation, requiring no further training. In the high-tempo “1 Colossus vs 32 Zerglings” scenario of StarCraft II, MCoT-SC2 attains a 55 % win rate, outperforming baselines with no reasoning or single-chain reasoning. Results confirm that multi-chain prompting boosts strategy diversity, control stability, and interpretability under spatial pressure, offering a practical path toward trustworthy LLM-based agents.
Limitations
Despite its promising performance and generalizability, MCoT‑SC2 still has several limitations. The inference process relies on the GPT‑4o API, and its response time is limited by model latency, making it unsuitable for high-frequency real-time control scenarios. The prompt structure currently depends on manual design and rule-based formatting, which introduces maintenance and scalability challenges. In terms of evaluation scope, the method has only been tested in single-unit and single-map settings, and its applicability to multi-agent cooperation, mixed-unit composition, or large-scale battlefield contexts remains unverified.
Future Work
Future research will focus on optimizing the model structure, improving reasoning efficiency, and expanding task generality. One direction is to compress prompt templates and prune reasoning chains to reduce computational overhead and enhance real-time responsiveness. On the tactical level, we aim to extend the framework to support multi-unit coordination and heterogeneous unit control for greater generalization. Another promising avenue is integrating LLM-based strategic reasoning with lightweight reinforcement learning (RL) controllers to form a hybrid decision-making architecture that enables fine-grained execution and adaptive planning in complex RTS environments.
References
Vinyals, O., Babuschkin, I., Czarnecki, W.M., et al.: Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature 575(7782), 350–354 (2019).
OpenAI: ChatGPT: optimizing language models for dialogue. https://openai.com/blog/chatgpt, last accessed February 27, 2025.
Touvron, H., et al.: LLaMA: open and efficient foundation language models. arXiv:2302.13971 (2023). https://arxiv.org/abs/2302.13971, last accessed February 27, 2025.
OpenAI: GPT-4o. https://openai.com/index/hello-gpt-4o/, last accessed May 20, 2025 (2024).
MA W, MI Q, ZENG Y, et al. Large language models play starcraft ii: Benchmarks and a chain of summarization approach [J]. Advances in Neural Information Processing Systems, 2025, 37: 133386-133442.
Hao, X., Jiang, W., Zuo, F., et al.: SwarmBrain: embodied agent for real-time strategy game StarCraft II via large language models. arXiv:2401.17749 (2024). https://arxiv.org/abs/2401.17749, last accessed February 27, 2025.
Li, Z., Ni, Y., Qi, R., et al.: LLM-PySC2: StarCraft II learning environment for large language models. arXiv:2411.05348 (2024). https://arxiv.org/abs/2411.05348, last accessed February 27, 2025.
Chen, P., Bu, P., Song, J., et al.: Can VLMs play action role-playing games? Take Black Myth: Wukong as a case study. arXiv:2409.12889 (2024). https://arxiv.org/abs/2409.12889, last accessed February 24, 2025.
Tan, W., Zhang, W., Xu, X., et al.: Cradle: empowering foundation agents towards general computer control. arXiv:2403.03186 (2024). https://arxiv.org/abs/2403.03186, last accessed February 23, 2025.
Wei, X., Wang, Y., Zou, H., et al.: Chain-of-thought prompting elicits reasoning in large language models. In: Advances in Neural Information Processing Systems (NeurIPS 2022).
Wang, P., Li, D., Wu, Q., et al.: Self-consistency improves chain-of-thought reasoning in language models. In: Proceedings of the International Conference on Learning Representations (ICLR 2023).
Yao, S., Zhao, M., Yu, Z., et al.: Tree of thoughts: deliberate problem solving with large language models. arXiv:2305.10601 (2023). https://arxiv.org/abs/2305.10601, last accessed February 27, 2025.
Zhang, T., Chen, H., Li, P., et al.: Multimodal chain-of-thought reasoning in language models[J]. TMLR, 2024.
Chu, X., Liang, X., Yu, Y., et al.: Navigate through enigmatic labyrinth: a survey of chain-of-thought reasoning—advances, frontiers and future. In: Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL 2024).

针对各处的问题,详细和原文对比,告诉我如何修改.