Title: 2506.05936 ArXiv: 2506.05936 DynamicMind: A Tri-Mode Thinking System for Large Language Models DynamicMind: A Tri-Mode Thinking System for Large Language Models Wei Li 1 ∗ , Yanbin Wei 1,2 , Qiushi Huang 1,3 , Jiangyue Yan 1 , Yang Chen 1 , James T. Kwok 2 , Yu Zhang 1 1 Southern University of Science and Technology 2 Hong Kong University of Science and Technology 3 University of Surrey Equal contribution  Corresponding author Abstract Modern large language models (LLMs) often struggle to dynamically adapt their reasoning depth to varying task complexities, leading to suboptimal performance or inefficient resource utilization. To address this, we introduce DynamicMind , a novel tri-mode thinking system. DynamicMind empowers LLMs to autonomously select between Fast, Normal, and Slow thinking modes for zero-shot question answering (ZSQA) tasks through cognitive-inspired prompt engineering. Our framework’s core innovations include: (1) expanding the established dual-process framework of fast and slow thinking into a tri-mode thinking system involving a normal thinking mode to preserve the intrinsic capabilities of LLM; (2) proposing the Thinking Density metric, which aligns computational resource allocation with problem complexity; and (3) developing the Thinking Mode Capacity (TMC) dataset and a lightweight Mind Router to predict the optimal thinking mode. Extensive experiments across diverse mathematical, commonsense, and scientific QA benchmarks demonstrate that DynamicMind achieves superior ZSQA capabilities while establishing an effective trade-off between performance and computational efficiency. We will release our code and model checkpoint as soon as possible. DynamicMind: A Tri-Mode Thinking System for Large Language Models Wei Li 1 ∗ , Yanbin Wei 1,2 † † thanks: Equal contribution , Qiushi Huang 1,3 , Jiangyue Yan 1 , Yang Chen 1 , James T. Kwok 2 , Yu Zhang 1 † † thanks: Corresponding author 1 Southern University of Science and Technology 2 Hong Kong University of Science and Technology 3 University of Surrey 1 Introduction In recent years, chain-of-thought (CoT) prompting techniques have significantly improved the zero-shot question-answering (ZSQA) capabilities of large language models (LLMs) by enabling step-by-step, deliberate reasoning to tackle complex tasks Wei et al. ( 2022 ) . Existing work Guo et al. ( 2025 ) enhances LLMs’ ability to solve complex problems, such as mathematical reasoning, by employing the slow thinking mode through extensive intermediate reasoning processes based on CoT. However, some studies Kojima et al. ( 2022 ); Yuan et al. ( 2024 ) observe that for simpler tasks, like CommonsenseQA, LLMs perform better using the fast thinking mode , which directly provides answers without intermediate reasoning steps, thereby significantly reducing computational costs, as exemplified in Figure 1 . Those observations suggest the viability of employing dual-processing theory Evans ( 1974 ); Tversky and Kahneman ( 1974 ) , drawing from human cognitive research on fast and slow thinking, to enhance the effectiveness and efficiency trade-off of LLM reasoning with the capabilities of fast and slow thinking. Figure 1: Accuracy and efficiency trade-off for adopting fast or slow thinking mode in LLMs. The dashed line represents the ultimately preferred choice mode. Nevertheless, current dual-processing frameworks overlook the intrinsic reasoning capabilities acquired by LLMs during their original training, which we term the normal thinking mode . Typically, LLMs are optimized to operate efficiently in their inherent normal mode, producing quick responses with moderate reasoning suitable for a broad range of tasks. For instance, in the GSM8K benchmark (Cobbe et al., 2021 ) , we observe 80.52% samples are more efficiently addressed by the normal mode than by either fast or slow modes. This is because LLMs already possess a foundational reasoning capability after their original training Liu et al. ( 2024 ) , enabling them to solve a majority of problems without resorting to slow thinking. However, despite its general utility, the normal mode is not universally optimal. It can be less token-efficient than the fast mode for some simple tasks and may lack the profound reasoning capabilities of the slow mode when addressing highly complex problems. LLMs can utilize three thinking modes with unique strengths. The fast mode is token-efficient for simple tasks like CommonsenseQA but may fail on complex problems such as math by favoring knowledge retrieval over computation. The slow mode ensures high accuracy for intricate, deep-reasoning tasks but incurs substantial token consumption, proving to be inefficient for simpler tasks. The normal mode, stemming from original training, seeks a balance between them, yet its inherent token consumption versus thinking depth trade-off is neither explicit nor optimally controlled. Our experimental results reveal that no single mode consistently optimizes both effectiveness and token efficiency across diverse tasks. Therefore, an adaptive system that can dynamically adjust thinking modes based on task complexity is crucial for enhancing the overall reasoning efficiency and versatility of LLMs. To achieve that, in this paper, we introduce DynamicMind , an adaptive framework extending dual-process theory into a tri-mode dynamic thinking system comprising fast, normal , and slow thinking modes for LLMs. The proposed DynamicMind system, guided by a lightweight Mind Router , dynamically adjusts its operational mode based on task complexity, and it features three key innovations. Firstly, we formalize the tri-mode thinking system, delineating the distinct impact of each mode on task performance. Secondly, we propose the Thinking Density , a mathematically grounded metric designed to quantify the trade-off between effectiveness and efficiency across these three thinking modes. Thirdly, we construct the Thinking Mode Capacity (TMC) dataset and develop the Mind Router, a lightweight module responsible of predicting the suitable thinking mode for LLMs. Extensive empirical evaluations across 12 reasoning benchmarks, including mathematical, commonsense, and scientific tasks, demonstrate that DynamicMind effectively achieves an adaptive balance between the performance and efficiency. Furthermore, those advantages are shown to be able to generalize to unseen domains/tasks. Figure 2: Overview of the DynamicMind framework, where the Mind Router guides the LLM Thinker to use the most appropriate thinking mode based on the question. 2 Related Work Fast/Slow Thinking in Cognitive Science. The concept of dual-processing in human cognition, introduced by Evans ( 1974 ) and expanded by Daniel ( 2017 ) , describes two systems: System 1 (fast, intuitive) and System 2 (slow, analytical). This framework has been influential in psychology and social sciences, providing insights into human decision-making Frederick ( 2005 ) . Fast/Slow Thinking of LLMs. LLMs mimic human cognitive systems, with fast thinking aligning with System 1, excelling in quick, intuitive tasks but struggling with complex reasoning (Nye et al., 2021 ) . Slow thinking mirrors System 2, using CoT reasoning to handle complex problems effectively (Chen et al., 2024 ; Qu et al., 2025 ) . Existing methods mainly optimize slow thinking speed, such as compressed reasoning chains (Wang et al., 2023 ) and dynamic token skipping (Pan et al., 2024 ) , often neglecting fast thinking’s potential. Other approaches like Dualformer (Su et al., 2024 ) and RL-based methods (Qu et al., 2025 ) attempt to configure both thinking modes. However, these approaches overlook the model’s inherent task-based trade-off capabilities acquired during origin training. DynamicMind uses a lightweight, trainable Mind Router to dynamically switch a single LLM between fast, normal, and slow thinking modes, enhancing reasoning efficiency without extra training. Efficient Thinking of LLMs. Dual-process thinking enhances cognitive efficiency. Fast thinking is advantageous for simple problems, avoiding overthinking, while slow thinking excels in complex tasks (Chen et al., 2024 ) . Strategies to improve LLM reasoning efficiency include model-centric methods like CoT fine-tuning (Yu et al., 2024 ) and RL frameworks (Shen et al., 2025 ) , but these are computationally intensive. Output-level strategies, such as Best-of-N and Majority Voting (Wu et al., 2025 ) , enhance inference but increase computational costs. Input prompt methods instruct LLMs to operate with constrained token budgets (Han et al., 2024 ) , though consistency challenges remain. Some approaches route queries to different LLMs based on difficulty (Ong et al., 2024 ) , increasing resource demands. 3 Methodology In this section, we present the proposed DynamicMind method. 3.1 Problem Settings Zero-shot question answering (ZSQA) aims to develop a system capable of accurately answering questions without prior exposure to specific question-answer pairs. Unlike traditional QA systems that rely on extensive labeled datasets, ZSQA requires answering new questions based on the established linguistic understanding capabilities and parametric knowledge of models. This poses a significant challenge to the generalizability of existing LLM-based QA systems in handling unseen questions. Table 1: Characteristics of each thinking modes. Thinking Mode Key Attributes Fast Mode ( M f subscript 𝑀 𝑓 M_{f} italic_M start_POSTSUBSCRIPT italic_f end_POSTSUBSCRIPT ) Intuitive, Limited Thinking Depth Normal Mode ( M n subscript 𝑀 𝑛 M_{n} italic_M start_POSTSUBSCRIPT italic_n end_POSTSUBSCRIPT ) Native Capability, Balanced Slow Mode ( M s subscript 𝑀 𝑠 M_{s} italic_M start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT ) Analytical, Low Efficiency Figure 3: Llama model’s average accuracy and token consumption. Figure 4: Qwen model’s average accuracy and token consumption consumption. Figure 5: The distribustion of TMC dataset. 3.2 DynamicMind Framework The DynamicMind framework, illustrated in Figure 2 , introduces a cognitive control system that integrates prompt engineering with dynamic routing. It comprises two core components: (1) the LLM Thinker with tri-mode thinking capabilities, and (2) the Mind Router for adaptive mode selection. Emulating human cognition, the LLM Thinker operates in three distinct modes: • Fast Mode ( M f subscript 𝑀 𝑓 M_{f} italic_M start_POSTSUBSCRIPT italic_f end_POSTSUBSCRIPT ) : Delivers rapid, intuitive responses by limiting cognitive depth, prioritizing speed over thorough reasoning. • Slow Mode ( M s subscript 𝑀 𝑠 M_{s} italic_M start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT ) : Executes deep analytical reasoning for high-quality outputs with increased computational costs. • Normal Mode ( M n subscript 𝑀 𝑛 M_{n} italic_M start_POSTSUBSCRIPT italic_n end_POSTSUBSCRIPT ) : Leverages the LLM’s native capabilities to balance response quality and efficiency. Table 1 summarizes operational characteristics of the three modes. For an input question q 𝑞 q italic_q , the Mind Router dynamically selects a suitable mode m ∈ { M f , M s , M n } 𝑚 subscript 𝑀 𝑓 subscript 𝑀 𝑠 subscript 𝑀 𝑛 m\in\{M_{f},M_{s},M_{n}\} italic_m ∈ { italic_M start_POSTSUBSCRIPT italic_f end_POSTSUBSCRIPT , italic_M start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT , italic_M start_POSTSUBSCRIPT italic_n end_POSTSUBSCRIPT } . Then the LLM Thinker gives an answer to q 𝑞 q italic_q in the selected mode m 𝑚 m italic_m within the zero-shot inference context, ensuring task-appropriate reasoning. 3.3 Tri-Mode Thinking System The three modes ℳ = { M f , M n , M s } ℳ subscript 𝑀 𝑓 subscript 𝑀 𝑛 subscript 𝑀 𝑠 \mathcal{M}=\{M_{f},M_{n},M_{s}\} caligraphic_M = { italic_M start_POSTSUBSCRIPT italic_f end_POSTSUBSCRIPT , italic_M start_POSTSUBSCRIPT italic_n end_POSTSUBSCRIPT , italic_M start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT } are achieved through distinct text templates 𝒯 m subscript 𝒯 𝑚 \mathcal{T}_{m} caligraphic_T start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT that shape the reasoning behavior of the LLM Thinker via explicit instructions. Specifically, for a question q 𝑞 q italic_q , each mode m ∈ ℳ 𝑚 ℳ m\in\mathcal{M} italic_m ∈ caligraphic_M generates an output sequence y = ( y 1 , … , y T ) 𝑦 subscript 𝑦 1 … subscript 𝑦 𝑇 y=(y_{1},\ldots,y_{T}) italic_y = ( italic_y start_POSTSUBSCRIPT 1 end_POSTSUBSCRIPT , … , italic_y start_POSTSUBSCRIPT italic_T end_POSTSUBSCRIPT ) via the following autoregressive process: P m ⁢ ( y | q ) = ∏ t = 1 T P ⁢ ( y t ∣ 𝒯 m ⏟ Mode Prompt ⊕ q ⊕ y < t ; θ ) , subscript 𝑃 𝑚 conditional 𝑦 𝑞 superscript subscript product 𝑡 1 𝑇 𝑃 conditional subscript 𝑦 𝑡 direct-sum subscript ⏟ subscript 𝒯 𝑚 Mode Prompt 𝑞 subscript 𝑦 absent 𝑡 𝜃 P_{m}(y|q)=\prod_{t=1}^{T}P\left(y_{t}\mid\!\underbrace{\mathcal{T}_{m}}_{% \text{Mode Prompt}}\!\oplus q\oplus y_{ Few broad steps. Appendix B Details of the TMC Dataset Construction We designed a dataset construction method to train a high-quality Mind Router. Specifically, we first obtain raw data by evaluating the LLM k 𝑘 k italic_k times on each task data using the fast, normal, and slow thinking modes, respectively. From this raw data, we then filter out task data where the LLM’s accuracy across the three thinking modes is consistently below 80%, as these tasks are considered too difficult for the model. Subsequently, we remove tasks where the average response lengths of the LLM in fast, normal, and slow modes do not satisfy the condition that the response length in fast mode is less than or equal to the length in normal mode, and the length in normal mode is less than or equal to the length in slow mode. This step ensures adherence to the design principles of the three modes. Then, task data with lengths exceeding the maximum sequence length of the MindRouter tokenizer are deleted to ensure that data truncation is not required during MindRouter training. Finally, the think density is calculated using the specified alpha value, and the mode with the highest think density is identified as the optimal mode for the LLM to complete that task. Appendix C Proof of Theorem We here provide the theorem with proof to demonstrate the pareto optimality of ideal dynamic routing. Because of logrithm operation does not influence the relative numerical value, to make the proof concise, we use the logrithm form of thinking density, i.e., E ^ m k ⁢ ( q ) = log ⁢ ( E m k ⁢ ( q ) ) superscript subscript ^ 𝐸 𝑚 𝑘 𝑞 log subscript superscript 𝐸 𝑘 𝑚 𝑞 \hat{E}_{m}^{k}(q)=\text{log}(E^{k}_{m}(q)) over^ start_ARG italic_E end_ARG start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT ( italic_q ) = log ( italic_E start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ) to complete this proof. Theorem 1 (Dynamic Routing Pareto Optimality) . For any question distribution 𝒟 q subscript 𝒟 𝑞 \mathcal{D}_{q} caligraphic_D start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT and tradeoff parameter α > 0 𝛼 0 \alpha>0 italic_α > 0 , the optimal router: R q ∗ = arg ⁡ max m ∈ ℳ ⁡ Acc m k ⁢ ( q ) ⏟ Accuracy + α ⁢ Eff m k ⁢ ( q ) ⏟ Efficiency subscript superscript 𝑅 𝑞 subscript 𝑚 ℳ subscript ⏟ subscript superscript Acc 𝑘 𝑚 𝑞 Accuracy 𝛼 subscript ⏟ subscript superscript Eff 𝑘 𝑚 𝑞 Efficiency R^{*}_{q}=\arg\max_{m\in\mathcal{M}}\underbrace{\text{Acc}^{k}_{m}(q)}_{\text{% Accuracy}}+\alpha\underbrace{\text{Eff}^{k}_{m}(q)}_{\text{Efficiency}} italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT = roman_arg roman_max start_POSTSUBSCRIPT italic_m ∈ caligraphic_M end_POSTSUBSCRIPT under⏟ start_ARG Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) end_ARG start_POSTSUBSCRIPT Accuracy end_POSTSUBSCRIPT + italic_α under⏟ start_ARG Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) end_ARG start_POSTSUBSCRIPT Efficiency end_POSTSUBSCRIPT (6) resides on the Pareto frontier and satisfies: ∀ m ∈ ℳ , { 𝔼 q ⁢ [ Acc R q ∗ k ⁢ ( q ) ] ≥ 𝔼 q ⁢ [ Acc m k ⁢ ( q ) ] 𝔼 q ⁢ [ Eff R q ∗ k ⁢ ( q ) ] ≥ 𝔼 q ⁢ [ Eff m k ⁢ ( q ) ] for-all 𝑚 ℳ cases subscript 𝔼 𝑞 delimited-[] subscript superscript Acc 𝑘 subscript superscript 𝑅 𝑞 𝑞 subscript 𝔼 𝑞 delimited-[] subscript superscript Acc 𝑘 𝑚 𝑞 otherwise subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 subscript superscript 𝑅 𝑞 𝑞 subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 𝑚 𝑞 otherwise \forall m\in\mathcal{M},\ \begin{cases}\mathbb{E}_{q}[\text{Acc}^{k}_{R^{*}_{q% }}(q)]\geq\mathbb{E}_{q}[\text{Acc}^{k}_{m}(q)]\\ \mathbb{E}_{q}[\text{Eff}^{k}_{R^{*}_{q}}(q)]\geq\mathbb{E}_{q}[\text{Eff}^{k}% _{m}(q)]\end{cases} ∀ italic_m ∈ caligraphic_M , { start_ROW start_CELL blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] ≥ blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] end_CELL start_CELL end_CELL end_ROW start_ROW start_CELL blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] ≥ blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] end_CELL start_CELL end_CELL end_ROW (7) with strict inequality when m 𝑚 m italic_m is suboptimal for any q ∈ supp ⁢ ( 𝒟 q ) 𝑞 supp subscript 𝒟 𝑞 q\in\text{supp}(\mathcal{D}_{q}) italic_q ∈ supp ( caligraphic_D start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT ) . Proof. Given E ^ m k ⁢ ( q ) = Acc m k ⁢ ( q ) + α ⁢ Eff m k ⁢ ( q ) subscript superscript ^ 𝐸 𝑘 𝑚 𝑞 subscript superscript Acc 𝑘 𝑚 𝑞 𝛼 subscript superscript Eff 𝑘 𝑚 𝑞 \hat{E}^{k}_{m}(q)=\text{Acc}^{k}_{m}(q)+\alpha\text{Eff}^{k}_{m}(q) over^ start_ARG italic_E end_ARG start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) = Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) + italic_α Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) . For any fixed mode m 𝑚 m italic_m : 𝔼 q ⁢ [ E ^ R q ∗ k ⁢ ( q ) ] subscript 𝔼 𝑞 delimited-[] subscript superscript ^ 𝐸 𝑘 subscript superscript 𝑅 𝑞 𝑞 \displaystyle\mathbb{E}_{q}[\hat{E}^{k}_{R^{*}_{q}}(q)] blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ over^ start_ARG italic_E end_ARG start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] = 𝔼 q ⁢ [ max m ′ ∈ ℳ ⁡ E ^ m ′ k ⁢ ( q ) ] absent subscript 𝔼 𝑞 delimited-[] subscript superscript 𝑚 ′ ℳ subscript superscript ^ 𝐸 𝑘 superscript 𝑚 ′ 𝑞 \displaystyle=\mathbb{E}_{q}\left[\max_{m^{\prime}\in\mathcal{M}}\hat{E}^{k}_{% m^{\prime}}(q)\right] = blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ roman_max start_POSTSUBSCRIPT italic_m start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT ∈ caligraphic_M end_POSTSUBSCRIPT over^ start_ARG italic_E end_ARG start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] ≥ 𝔼 q ⁢ [ E ^ m k ⁢ ( q ) ] (pointwise optimality) absent subscript 𝔼 𝑞 delimited-[] subscript superscript ^ 𝐸 𝑘 𝑚 𝑞 (pointwise optimality) \displaystyle\geq\mathbb{E}_{q}[\hat{E}^{k}_{m}(q)]\quad\text{(pointwise % optimality)} ≥ blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ over^ start_ARG italic_E end_ARG start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] (pointwise optimality) = 𝔼 q ⁢ [ Acc m k ⁢ ( q ) ] + α ⁢ 𝔼 q ⁢ [ Eff m k ⁢ ( q ) ] absent subscript 𝔼 𝑞 delimited-[] subscript superscript Acc 𝑘 𝑚 𝑞 𝛼 subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 𝑚 𝑞 \displaystyle=\mathbb{E}_{q}[\text{Acc}^{k}_{m}(q)]+\alpha\mathbb{E}_{q}[\text% {Eff}^{k}_{m}(q)] = blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] + italic_α blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] Rearranging terms, we have 𝔼 q ⁢ [ Acc R q ∗ k ⁢ ( q ) ] − 𝔼 q ⁢ [ Acc m k ⁢ ( q ) ] ≥ α ⁢ ( 𝔼 q ⁢ [ Eff m k ⁢ ( q ) ] − 𝔼 q ⁢ [ Eff R q ∗ k ⁢ ( q ) ] ) subscript 𝔼 𝑞 delimited-[] superscript subscript Acc subscript superscript 𝑅 𝑞 𝑘 𝑞 subscript 𝔼 𝑞 delimited-[] subscript superscript Acc 𝑘 𝑚 𝑞 𝛼 subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 𝑚 𝑞 subscript 𝔼 𝑞 delimited-[] superscript subscript Eff subscript superscript 𝑅 𝑞 𝑘 𝑞 \mathbb{E}_{q}[\text{Acc}_{R^{*}_{q}}^{k}(q)]-\mathbb{E}_{q}[\text{Acc}^{k}_{m% }(q)]\geq\alpha\left(\mathbb{E}_{q}[\text{Eff}^{k}_{m}(q)]-\mathbb{E}_{q}[% \text{Eff}_{R^{*}_{q}}^{k}(q)]\right) blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT ( italic_q ) ] - blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] ≥ italic_α ( blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] - blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT ( italic_q ) ] ) . If 𝔼 q ⁢ [ Eff R q ∗ k ⁢ ( q ) ] < 𝔼 q ⁢ [ Eff m k ⁢ ( q ) ] subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 subscript superscript 𝑅 𝑞 𝑞 subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 𝑚 𝑞 \mathbb{E}_{q}[\text{Eff}^{k}_{R^{*}_{q}}(q)]<\mathbb{E}_{q}[\text{Eff}^{k}_{m% }(q)] blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] < blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] , the RHS becomes positive, forcing 𝔼 q ⁢ [ Acc R q ∗ k ⁢ ( q ) ] > 𝔼 ⁢ [ Acc m k ⁢ ( q ) ] subscript 𝔼 𝑞 delimited-[] subscript superscript Acc 𝑘 subscript superscript 𝑅 𝑞 𝑞 𝔼 delimited-[] subscript superscript Acc 𝑘 𝑚 𝑞 \mathbb{E}_{q}[\text{Acc}^{k}_{R^{*}_{q}}(q)]>\mathbb{E}[\text{Acc}^{k}_{m}(q)] blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] > blackboard_E [ Acc start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] . Otherwise 𝔼 q ⁢ [ Eff R q ∗ k ⁢ ( q ) ] ≥ 𝔼 q ⁢ [ Eff m k ⁢ ( q ) ] subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 subscript superscript 𝑅 𝑞 𝑞 subscript 𝔼 𝑞 delimited-[] subscript superscript Eff 𝑘 𝑚 𝑞 \mathbb{E}_{q}[\text{Eff}^{k}_{R^{*}_{q}}(q)]\geq\mathbb{E}_{q}[\text{Eff}^{k}% _{m}(q)] blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT end_POSTSUBSCRIPT ( italic_q ) ] ≥ blackboard_E start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT [ Eff start_POSTSUPERSCRIPT italic_k end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_m end_POSTSUBSCRIPT ( italic_q ) ] directly holds. Thus R q ∗ subscript superscript 𝑅 𝑞 R^{*}_{q} italic_R start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_q end_POSTSUBSCRIPT either strictly improves accuracy while matching efficiency, or maintains accuracy while strictly improving efficiency. This establishes Pareto dominance over any fixed mode m 𝑚 m italic_m . ∎ Appendix D Datasets Infomations In this section, we introduce the dataset information used in our experiments. When constructing the TMC dataset, we incorporated mathematical tasks and CommonsenseQA tasks. Therefore, the datasets corresponding to these two task types include: GSM8K (Cobbe et al., 2021 ) and MATH (Hendrycks et al., 2021b ) for mathematical reasoning, as well as Commonsense QA datasets such as BoolQ (Clark et al., 2019 ) , PIQA (Bisk et al., 2020 ) , SIQA (Sap et al., 2019 ) , HellaSwag (Zellers et al., 2019 ) , WinoGrande (Sakaguchi et al., 2021 ) , ARC-e, ARC-c (Clark et al., 2018 ) , and OBQA (Mihaylov et al., 2018 ) . We used the training set portions of these datasets to construct the TMC dataset, and their test set portions served as in-domain datasets for evaluating the LLM’s dynamic thinking capabilities. Additionally, we selected the test sets of various subtasks from two other datasets, MMLU (Hendrycks et al., 2021a ) and ScienceQA (Lu et al., 2022 ) , as out-of-domain datasets to measure the generalization ability of the LLM’s dynamic thinking capabilities. Appendix E Implementation Details. In our experiments, we implement the LLM Thinker using two representative open-source models as backbone: Llama-3.1-8B-Instruct and Qwen-2.5-7B-Instruct, selected for their strong instruction-following capabilities. For the Mind Router, we use DeBERTaV3-base. All experiments are conducted on a single NVIDIA A100 GPU. For the LLM Thinker, we set the temperature to 0.6 and a top-p value of 0.9. Additionally, we impose a token generation limit of 128 tokens for Fast Mode, 2048 tokens for Normal Mode, and 4096 tokens for Slow Mode, with the LLM ceasing generation upon reaching these mode-specific token limits.