Paper deep dive
DynaGraph: Lightweight Multi-Model Interaction Framework via Dynamic Topological Reconfiguration
Yanxing Guo, Zihao Zheng, Fangzhou Wu, Ling Liang, Lin Bao, Zongwei Wang, Yimao Cai
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 7/8/2026, 10:07:07 PM
Summary
DynaGraph is a lightweight multi-model interaction framework designed for complex reasoning tasks that addresses computational redundancy and static topology limitations. It employs dynamic topological reconfiguration by multiplexing time-division PEFT adapters over a shared base model, maintaining a constant GPU memory footprint. An Evaluator component continuously monitors execution confidence to trigger hierarchical self-healing mechanisms, specifically Fine-grained Patching for localized data gaps and Subgraph Reconstruction for severe logical ruptures. Experiments demonstrate that the 8B-scale DynaGraph approximates the reasoning capabilities of 72B monolithic models while significantly reducing latency and token consumption.
Entities (12)
Relation Signals (14)
DynaGraph β evaluateson β MATH
confidence 96% Β· Experiments on StrategyQA, MATH, and FinQA demonstrate our 8B model closely approximates the reasoning capabilities
DynaGraph β evaluateson β FinQA
confidence 96% Β· Experiments on StrategyQA, MATH, and FinQA demonstrate our 8B model closely approximates the reasoning capabilities
DynaGraph β evaluateson β StrategyQA
confidence 96% Β· Experiments on StrategyQA, MATH, and FinQA demonstrate our 8B model closely approximates the reasoning capabilities
DynaGraph β contains β Evaluator
confidence 95% Β· At the routing level, the Evaluator continuously monitors execution confidence to trigger hierarchical self-healing
DynaGraph β uses β PEFT Adapters
confidence 94% Β· At the execution level, DynaGraph multiplexes time-division PEFT adapters over a shared base model
DynaGraph β utilizes β Shared Base Model
confidence 92% Β· multiplexes time-division PEFT adapters over a shared base model, enabling both full system training and inference deployment
Evaluator β triggers β Fine-grained Patching
confidence 90% Β· trigger hierarchical self-healing: Fine-grained Patching for localized data gaps
Evaluator β triggers β
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Tackling complex reasoning tasks typically relies on massive monolithic LLMs, which suffer from severe computational redundancy. While task decomposition through structured pipelines or multi-agent collaborations offers an alternative, these approaches inevitably fall into a critical dilemma: predefined static topologies are highly vulnerable to cascading errors, whereas unconstrained dynamic agents suffer from trajectory divergence and unpredictable memory bloat. To address this, we present DynaGraph, a lightweight multi-model framework driven by dynamic topological reconfiguration. At the execution level, DynaGraph multiplexes time-division PEFT adapters over a shared base model, enabling both full system training and inference deployment on a single consumer-grade GPU. At the routing level, the Evaluator continuously monitors execution confidence to trigger hierarchical self-healing: Fine-grained Patching for localized data gaps and Subgraph Reconstruction for severe logical ruptures. Experiments on StrategyQA, MATH, and FinQA demonstrate our 8B model closely approximates the reasoning capabilities of a 72B monolithic model (e.g., 87.6% on StrategyQA, 82.7% on MATH). Furthermore, it reduces latency by up to 68.1% and token consumption by 68.6% compared to unconstrained dynamic architectures.
Tags
Links
- Source: https://arxiv.org/abs/2605.29511v2
- Canonical: https://arxiv.org/abs/2605.29511v2
Trouble viewing inline? Open PDF directly β
Full Text
42,888 characters extracted from source content.
Expand or collapse full text
DynaGraph: Lightweight Multi-Model Interaction Framework via Dynamic Topological Reconfiguration Yanxing Guo 1,β , Zihao Zheng 1,β , Fangzhou Wu 2 , Ling Liang 1,3,β , Lin Bao 1,3,4 , Zongwei Wang 1,3,5 , Yimao Cai 1,3,β 1 Peking University, 2 Nanjing University, 3 Beijing Advanced Innovation Center for Integrated Circuits, 4 Beijing University of Posts and Telecommunications, 5 Yanxin Co. Ltd. Abstract Tackling complex reasoning tasks typically relies on massive monolithic LLMs, which suffer from severe computational redundancy. While task decomposition through structured pipelines or multi-agent collaborations offers an alternative, these approaches inevitably fall into a critical dilemma: predefined static topolo- gies are highly vulnerable to cascading errors, whereas unconstrained dynamic agents suffer from trajectory divergence and unpredictable memory bloat. To address this, we present DynaGraph, a lightweight multi-model frame- work driven by dynamic topological reconfig- uration. At the execution level, DynaGraph multiplexes time-division PEFT adapters over a shared base model, enabling both full sys- tem training and inference deployment on a sin- gle consumer-grade GPU. At the routing level, the Evaluator continuously monitors execution confidence to trigger hierarchical self-healing: Fine-grained Patching for localized data gaps and Subgraph Reconstruction for severe logical ruptures. Experiments on StrategyQA, MATH, and FinQA demonstrate our 8B model closely approximates the reasoning capabilities of a 72B monolithic model (e.g., 87.6% on Strate- gyQA, 82.7% on MATH). Furthermore, it re- duces latency by up to 68.1% and token con- sumption by 68.6% compared to unconstrained dynamic architectures. 1 Introduction In recent years, LLMs have demonstrated unprece- dented capabilities in the field of natural language processing (Dubey et al., 2024). However, as technology advances, the application scenarios of LLMs have expanded to complex tasks requiring deep logical deduction, such as multi-hop ques- tion answering, mathematical reasoning, and finan- cial risk analysis (Yang et al., 2018; Hendrycks β means equal contribution. β indicates the corresponding author. et al., 2021; Wu et al., 2023). Currently, solving such tasks typically relies on extremely large-scale monolithic models, such as GPT-4 (estimated 1.8T parameters) (OpenAI et al., 2023), Claude 3.5 Son- net, or Llama 3-70B (Dubey et al., 2024). Unfortu- nately, relying on a single massive model to handle all segments within a task pipeline not only intro- duces severe computational redundancy but also limits the systemβs flexibility for modular expan- sion of specific capabilities. To mitigate the limitations of monolithic mod- els on complex tasks, existing solutions primarily focus on augmenting the single-model paradigm. Prompting techniques like CoT (Wei et al., 2022b) and ToT (Yao et al., 2023) guide intermediate rea- soning, while RAG (Asai et al., 2024) integrates ex- ternal knowledge. Alternatively, MoE (Jiang et al., 2024) scales capacity via sparse activation. How- ever, these methods face architectural bottlenecks. Despite heuristic pruning, prompt-based paradigms operate within predefined, rigid topologies lacking reactive runtime self-healing, making them vulner- able to cascading failures from localized anoma- lies. Meanwhile, MoE remains a highly coupled system demanding steep memory overhead, which prevents independent modular hot updates. Consequently, decomposing tasks into multi- agent systems has emerged as an alternative (Hong et al., 2024). However, current collaborative frame- works struggle to balance controllability and flex- ibility, typically falling into a dilemma between two extremes: 1) Static DAG Pipelines: These offer predictable overheads but lack reactive re- covery mechanisms. Localized errors inevitably accumulate along the task chain, leading to se- vere cascading failures (Zhu et al., 2025). 2) Un- constrained Dynamic Reflection: Autoregressive agents exhibit high autonomy but are prone to tra- jectory divergence and meta-cognitive hallucina- tions (Huang et al., 2024; Lu et al., 2026). Their re- peated trial-and-error leads to unpredictable compu- 1 arXiv:2605.29511v2 [cs.MA] 29 May 2026 tational costs and severe GPU memory bloat. Thus, developing a collaborative system that achieves convergent, efficient self-correction under a strictly controlled budget remains a critical challenge. To address these challenges, we present Dyna- Graph, a lightweight multi-model system with dy- namic topological reconfiguration. The framework shifts from static task scheduling to adaptive topo- logical evolution via a real-time feedback loop. At the execution layer, DynaGraph multiplexes LoRA adapters over a shared backbone, maintain- ing a constantO(1)GPU memory footprint re- gardless of expert pool size. At the control layer, the Evaluator monitors real-time execution con- fidence, instantly halting flawed reasoning steps. Based on error severity, it adaptively triggers hi- erarchical interventions: Fine-grained Patching to suture localized information gaps, or Subgraph Re- construction to truncate and regenerate severely corrupted branches. This paradigm endows the sys- tem with robust self-healing, ensuring trajectory convergence under strict operational budgets. In summary, our contributions are three-fold: β’Lightweight Architecture: DynaGraph mul- tiplexes time-division PEFT adapters over a shared base model.This bounds the peak memory footprint to 16.6 GB, enabling complex multi-model inference on a single consumer-grade GPU. β’Adaptive Topological Self-Healing: A state- aware reconfiguration mechanism balances execution structure and autonomy. By dy- namically deploying Fine-grained Patching to suture localized data gaps and Subgraph Re- construction to truncate and regenerate fatally corrupted logic branches, the system guaran- tees reasoning convergence while halting cas- cading errors. β’Efficiency and Performance Breakthrough: Our 8B-scale DynaGraph achieves superior performance (e.g., 87.6% on StrategyQA, 82.7% on MATH), closely approximating 72B massive models. Compared to unconstrained dynamic architectures like Reflexion, it re- duces token consumption and latency by up to 68.6% and 68.1%. 2 Background 2.1 Large Language Models Large Language Models (LLMs) (e.g., Gem- ini (Team et al., 2023) and Qwen (Yang et al., 2025)) exhibit remarkable capabilities across do- mains like mathematical reasoning (Cobbe et al., 2021) and commonsense question answering (Tal- mor et al., 2019), propelled by scaling laws (Ka- plan et al., 2020) and emergent abilities (Wei et al., 2022a). However, monolithic LLMs often struggle with complex multi-domain tasks. To address this, models are frequently fine-tuned on specialized datasets. For instance, domain-specific fine-tuning in financial (Wu et al., 2023), biomedical (Lee et al., 2020), and legal (Chalkidis et al., 2020) fields yields superior specialized performance without sacrificing general capabilities. These successes inspire the use of parameter-efficient fine-tuning (PEFT) methods, such as prompt tuning (Li et al., 2025) and LoRA (Hu et al., 2022), for efficient domain adaptation. 2.2 Model Interaction 2.2.1 Single-Model-Based Interaction To enhance reasoning within a single-model paradigm, techniques like Chain-of-Thought (CoT) (Wei et al., 2022b), zero-shot trig- gers (Kojima et al., 2022), and task-breakdown prompts (Zhou et al., 2023) guide intermediate logi- cal deductions. Furthermore, Retrieval-Augmented Generation (RAG) (Lewis et al., 2020) mitigates hallucinations by grounding outputs in external corpora. Nevertheless, single-model approaches remain vulnerable to biased prompts (Turpin et al., 2023), error accumulation in long inference chains (Lu et al., 2026), and retrieval-generation misalignment (Huang et al., 2025), limiting their efficacy on complex tasks. 2.2.2 Multi-Model-Based Interaction Multi-model interactions overcome single-model bottlenecks by decomposing tasks across dis- tinct reasoning modules. Frameworks like Tree of Thoughts (Yao et al., 2023) and Graph of Thoughts (Besta et al., 2024) organize reason- ing into structured topologies suitable for branch- ing and backtracking. Concurrently, Mixture-of- Experts (MoE) architectures enhance efficiency and accuracy by routing inputs to relevant ex- perts (Zheng et al., 2025), especially when incorpo- rating fine-grained specialization (Dai et al., 2024) and instruction-tuning (Shen et al., 2024). Despite their effectiveness, existing multi-model frameworks construct static topologies that can- not adapt to real-time execution states and lack autonomous self-repair mechanisms. DynaGraph 2 User Queryν Graph (Topology) Planner Evaluator Executor (Graph Generation) Orchestrator ν ν½ οΌaοΌMacro Architecture (Uncertainty & Exception) Suspend Signal Initial Plan ν° ννννννν ν Global Artifacts Repository ν’ Contexts(ν ) State Feedback (ν ν² ) Node Payloads(ν) οΌbοΌException Handling and Reconstruct Mechanism ( Domain Experts ) Execution & Halt ν¬ ννν ν¬ ννννν ν¬ νννν Suspended Node Truncated Discard (Exception Flag) . . . ν=ν ν=ν ν ν ν ν ν ν ν ν ν ν ν ν ν ν ν ν output payload (Confidence) ν ν =ν ν ,ν ν ,ν ν ν νβΆ ν ν βν,ν ν ν βν,ν ν ν =ν ννν ν <ν ν νΌ ν β₯ν ν νννννν-ννννννν ννννννννννν Fine-grained Patching Insert auxiliary node to suture localized logic / data gap. Subgraph Reconstruction ν=ν(ν¨) ν=ν(ν©) ν ν ν ν ν ν ν ν ν ν ν ν ν ν ν ν Truncate failed branch and regenerate alternative subgraph. ν ννννν ν ν ν ν Feedback ν ν² =ν ν ,ν ν ,ν ν ν¬ ννν ν¬ ννννν ν¬ νννν (Factual Retrieval) (Logical Deduction) β ν΄ ν¬ =ν¬ ννν ,ν¬ ννννν ,ν¬ νννν ( Expression) New Node Graph Topology(ν ν½ ) ν ν Figure 1: Macro architecture and dynamic topology evolution of DynaGraph. (a) Macro Architecture illustrating component interactions. (b) Exception Handling and Reconstruct Mechanism through dynamic node insertion and branch replacement. directly addresses these limitations by introducing dynamic topological reconstruction, pushing multi- model interaction into a resilient, adaptive frontier. 3 Method 3.1 Task Formulation and System Overview 3.1.1 Formalization of Task and DAG In complex reasoning scenarios, task resolution requires collaborative routing among specialized modules, which we define as the model interaction topology. This paradigm decomposes instructions into a graph where nodes represent expert execu- tions and edges denote contextual dependencies. We propose this to overcome the inherent limi- tations of existing frameworks: static pipelines are highly vulnerable to cascading errors, while un- constrained dynamic agents suffer from trajectory divergence. To balance structured execution with self-healing capabilities, we introduce a dynamic topological reconfiguration mechanism. This al- lows the system to monitor real-time states and topologically physically restructure the graph to repair logical ruptures and data gaps. To formalize this dynamic orchestration, given a user queryQ, an Orchestrator invokes a Planner to generate an initial task execution graphG (0) = (V (0) ,E (0) ). Unlike static pipelines, our graph topology evolves dynamically with the execution state, defined at time step t asG (t) = (V (t) ,E (t) ). Each vertexv i β V (t) represents a sub-task node. To decouple heterogeneous expert capabil- ities, we formalize the vertex as Eq.(1), where E Ο i β β¦ E = E rag ,E logic ,E expr denotes the assigned domain expert,q i represents the local in- struction context, andP i = v j | (v j ,v i ) β E (t) is the set of prerequisite parent nodes. Directed edgese j,i β E (t) define the logic flow. Nodev i is triggered once all prerequisite nodes inP i were execute successfully and passed their contexts. v i =β¨E Ο i ,q i ,P i β©.(1) To systematically record all expert execution out- puts, we introduce a structured state spaceS. Upon completing its computation, the output state of the assigned expertE Ο i at nodev i is encapsulated into a standardized feedback tuple, as shown in Eq.(2). F i =β¨o i ,ΞΎ i ,c i β©.(2) whereo i is the structured output of the correspond- ing expert. The Exception FlagΞΎ i β 0, 1indi- cates irrecoverable errors (e.g., format deviations or logical ruptures), andc i β [0, 1]represents the expertβs normalized confidence score. 3.1.2 System Overview To address aforementioned problems, we propose DynaGraph framework. As illustrated in Fig. 1 (a), our Framework decouples complex task resolution into four canonical phases: Planning, Execution, Evaluation, and Reconstruction. Upon receiving a user queryQ, the central Orchestrator prompts the Planner to generate an initial task graph. Fig. 1 (a) further visualizes the strict module- isolation principle: heterogeneous experts (E Ο i β β¦ E ) never communicate directly; instead, all in- termediate contexts, graph topologies, and node payloads flow through the Global Artifacts Repos- itoryS. As experts return state feedbackF i , the Evaluator monitors the execution stream to quan- tify uncertainty and detect exceptions. If lethal 3 ν ν (Expr) ν ν (Logic)ν ν (Logic) ν ν [OK] ν ν [OK] ν ν,ννννν [OK] ν ν [ERP] ν ν [OK] ν ν (RAG) ν ν [OK] Planner (Patch Decision) Evaluator Check Phase β‘ Execution + Fine-grained Patch Phase β’ConvergePhase β Planning Phase β£Final Answer Evaluator Status: [CONTINUE] Final Answer : ν=β ν ν Final Topology (Execution Summary) Node Roles (Planning Annotation) Evaluator/Planner (Control)Patched/Recovered Node (OK)Failed Node (ERR)Normal Node (OK) ν ν [ERP] ν ν [OK] Trigger PAUSE. β«ν ν : identity recalled. β«ν ν : initial attempt failed (self-check mismatch). β«ν ν, ννννν : refined solution recovered. β«ν ν : alternative case solved. β«ν ν : aggregated and selected minimum. ν ν (RAG) ν ν (Logic) ν ν (Expr) ν ν (Logic) ν΅νν ν νΉννν/ν»ννν ννβν=νν+ν βνν=ν β ν= ν ν Recalls the identity ν¨=ν©βν¨ = ν© νν ν¨ =βν© Solve ννβν=νν+ν. Aggregate solutions from ν ν and ν ν ,compare, and pick the minimum. Solve ννβν=β(νν+ν). ν ν, ννννν [OK] ννβν=νν+ν βννβνν=ν+ν βνν=ν β ν= ν ν ν ν [OK] ννβν=βνν+ν βννβν=βννβν βνν=βν β ν=β ν ν Insert ν ν, ννννν . Refined Prompt/Guidance: Move terms, Simplify, divide, verify by substitution. ν¨=ν©βν¨ = ν© νν ν¨ =βν© Inputs from predecessors: ν ν,ννννν = ν ν ,ν ν =β ν ν Compare: β ν ν < ν ν Minimum solution: ν ννν =β ν ν Check νΌ ν ,ν ν ννν ν ν=ν,ν=ν.ν ν ν <ν ν A Concrete Execution Example on: Finding the Minimum Solution of |ννβν|=|νν+ν| Figure 2: A concrete execution example of DynaGraph. The Evaluator halts execution upon detecting anomalies at node v 2 ; a dynamically inserted patch node subsequently recovers the corrupted state to ensure convergence. Time-multiplexed Execution with PEFT-based Context Switching DAG Execution Order GPU VRAM (At runtime) ν ν Execute ν ν (ν¬ ννν ) Shared Base Model νΎ ν (Frozen) ν«νΎ ννν = ν ν ν¨ ννν ν© ννν Unload Load ν ν Execute ν ν ( ν¬ ννννν ) Shared Base Model νΎ ν (Frozen) ν«νΎ ννννν = ν ν ν¨ ννννν ν© ννννν Unload Load ν ν Execute ν ν (ν¬ νννν ) Shared Base Model νΎ ν (Frozen) ν«νΎ νννν = ν ν ν¨ νννν ν© νννν Unload Load . . . Shared Base Model νΎ ν (Frozen) ν«νΎ νννν = ν ν ν¨ νννν ν© νννν Unload Load Planner (ν¬ νννν ) Figure 3: Time-multiplexed Execution with PEFT-based Context Switching: The system maintains a frozen shared base model (W 0 ) and dynamically loads task-specific LoRA adapters (e.g., A rag B rag ) via PEFT anomalies or high uncertainties exceed thresholds, the Evaluator issues a suspension signal (I (t) suspend ), returning control to the Orchestrator. As illustrated in Fig. 1 (b), the Planner then executes hierarchical topological reconfiguration: 1) fine-grained patch- ing for localized data errors or gaps (e.g., erroneous intermediate calculations or unretrieved factual en- tities), or 2) subgraph reconstruction to truncate and regenerate failed branches. Fig. 2 illustrates a life cycle on finding the mini- mum solution of|5xβ1| =|3x+2|. Phaseβ : The Planner generates a DAG with nodesv 1 through v 4 . Phaseβ‘: Afterv 1 succeeds, the Evaluator detects a calculation error atv 2 and triggers sus- pension. The Planner inserts a patch nodev 2,patch to recalculate the faulty nodes. Phaseβ’: The cor- rected state fromv 2,patch propagates downstream alongside the valid sibling output to the aggrega- tion nodev 3 . Phaseβ£: The system emits the final topology and answer, validating that the system can autonomously and dynamically repair faults. 3.2 Domain-Specific Expert Design 3.2.1 Structured State Feedback of Experts Given that each expert is tailored for a distinct function, their structured outputs vary accordingly. Therefore, we formally define these specific struc- tures below. This framework constructs an expert poolβ¦ E =E rag ,E logic ,E expr characterized by functional orthogonality. Upon termination, each nodev i returns a standardized state feedback tuple F i = β¨o i ,ΞΎ i ,c i β©to the Orchestrator. The specific variables for each expert are constrained as follows: β Factual Retrieval ExpertE rag : Dedicated to open-domain factual verification. Its outputo i = β¨A,K,Cβ© comprises the assertion setA, external evidenceK, and citation provenanceC. Confidence c i measures evidence reliability. If retrieval fails or cannot support assertions, ΞΎ i = 1. β‘Logical Deduction ExpertE logic : Dedicated to closed-domain logical verification. Its output o i = β¨H,Vβ©comprises the reasoning historyH and boolean verification resultsV. Confidencec i measures logical self-consistency. Upon localized verification failure, ΞΎ i = 1. β’Expression ExpertE expr : Dedicated to lin- guistic fidelity. Its outputo i = β¨D,Uβ©contains the generated draftDand unsupported statements U. Confidencec i measures semantic fidelity. For severe formatting deviations, ΞΎ i = 1. In practice, the confidence scorec i β [0, 1]is derived via verbalized self-calibration, prompting 4 Topology Criticβ Execution Trajectory ν (Generated Graph) Final Answer Score β(ν,ν) 1) Task Completeness Ground Truth vs. Teacher Model (Outcome Judge) ν½ νννν Gate βν,ν (One-vote Veto) 2) Action Legality Legality Checker (Cycle / Mismatch Detection) β β β ν° ννν Penalty = νlog ( ) ν + ν½ ν + νΈνΌ 3) System Overhead Cost Counter Nodes ν½ ν Recon. νΌ νΊ νννν Composite Reward ν‘ν νν½ νννν ,ν° ννν ,νΊ νννν Figure 4: Topology Critic: The execution trajectory Οis evaluated by a composite reward functionR(Ο ) considering task accuracy/completeness, topological le- gality, and system overhead. experts to explicitly quantify their certainty. The exception flagΞΎ i β 0, 1triggers deterministi- cally if the expert self-reports anomalies or fails structured parsing. 3.2.2 Context Switching for Low-Memory Usage To address GPU memory bottlenecks, we imple- ment PEFT based time-division scheduling. For a frozen base modelW 0 β R dΓk , we train low- rank matricesA Ο β R dΓr andB Ο β R rΓk (r βͺ min(d,k)) for each system moduleΟ β E plan ,E rag ,E logic ,E expr . As illustrated in Fig. 3, during a specific module Οβs execution, the active weightsΞΈ active dynami- cally incorporate the incremental weights βW Ο : ΞΈ active = W 0 + βW Ο = W 0 + Ξ± r (A Ο B Ο ). (3) whereΞ±is a scaling coefficient. Fig 3 depicts an example of time-division multiplexing timeline: as the DAG execution order advances from the Plan- ner (Ο = E plan ) tov 3 (Ο = E expr ) and onward, the system atomically unloads the previous LoRA adapter and loads the next. So, at any single time step, the GPU memory contains only the frozen backbone W 0 plus one active adapter slice. LetM(Β·)denote the GPU memory footprint function. The systemβs peak GPU memory is strictly bounded by Eq. (4). M peak =M(W 0 ) + max Ο M(A Ο ) +M(B Ο ). (4) Sinceris minimal,M(A Ο )+M(B Ο )is negligible. This mathematically guarantees anO(1)redundant GPU memory complexity regardless of the scaling of both the expert pool and the planning policies. 3.3 Exception Handling and Reconstruction Mechanism To endow the system with topological plasticity, we introduce a continuous monitoring mechanism that detects intermediate anomalies and dynamically restructures the reasoning graph to self-heal. We define the global uncertaintyU t across com- mitted nodesV (t) exec to measure the aggregate execu- tion instability and the cumulative risk of reasoning divergence, as shown in Eq. (5). U t = 1β 1 |V (t) exec | X v j βV (t) exec c j .(5) To prevent error propagation, we define the suspen- sion indicator functionI (t) suspend to govern when the system trigger reconstruction. OnceI (t) suspend = 1, the Evaluator halts downstream scheduling and ini- tiates the reconfiguration process, shown in Eq.(6). I (t) suspend = ο£±     ο£²     ο£³ 1, βv j βV (t) exec , ΞΎ j = 1 1, βv j βV (t) exec , c j < Ο c 1, U t β₯ Ο u 0, otherwise (6) whereΟ u defines the global uncertainty tolerance andΟ c denotes the minimum single-node confi- dence threshold. As illustrated in Fig. 1 (b), the topologi- cal transformation operatorTyieldsG (t+1) = T (G (t) ,F err ) via two distinct execution paths: β Fine-grained Patching Operator: Repairs localized deficiencies triggered by irrecoverable node errors or confidence floor breaches. As de- picted in Fig. 1 (b), upon detecting a lethal failure (ΞΎ i = 1) or a single-node confidence floor viola- tion (c j < Ο c ) at intermediate nodev i , the Planner dynamically instantiates an auxiliary patch node v i,patch based on the anomalous nodeβs local con- text, thereby suturing localized breakpoints. β‘ Subgraph Reconstruction Operator: Recti- fies macroscopic deviations. If a fine-grained patch 5 Query ν ν¨ (Candidate A) Sample Multiple Trajectories (Policy ν ννν ) βν΅ ν ν (Chosen) =ν ν¨ DPO Loss Critic ν‘ν ν¨ Score ν‘ν ν¨ Threshold Filter: ν«ν‘=ν‘ν ν¨ βν‘ν ν© β₯ν ν ν (Rejected) =ν ν© . . . . . . Critic ν‘ν ν© ν ν© (Candidate B) . . . . . . Implicit Rewards: ν ν½ν ν ,ν ν½ν ν Objective: ννν ν ν ννν Score ν‘ν ν© . . . . . . Figure 5: Preference Pair Construction & DPO Optimization: Candidate trajectories are sampled and ranked by the Critic to construct preference pairs, which are then used to optimize the central Planner via DPO. fails, or the global uncertainty exceeds the toler- ance threshold (U t β₯ Ο u ), the system truncates all downstream branches from the failed node and re- places them with a freshly generated subgraphG sub . This discards the corrupted execution state rather than allowing error propagation. To prevent infinite recursive reconstruction, we impose an operational budget constraint. LetΞ·be the cumulative reconstruction count andβ¦ max the permissible threshold, as shown in Eq. (7). Ξ· = t X k=1 I (k) suspend β€ β¦ max .(7) OnceΞ·reachesβ¦ max , the system terminates dy- namic reconstruction and invokes a fallback mech- anism, guaranteeing computational convergence in worst-case scenarios. 3.4 Critic Guided Central Model Training 3.4.1 Critic Establishment and Evaluation Dimensions To train the Planner, we introduce a Topology Critic Crit(Β·)to map generated trajectories into learnable reward signals. As shown in Fig. 4,Crit(Β·)eval- uates discrete trajectoriesΟusing a composite re- ward functionR(Ο ) across three dimensions: Task CompletionΞ¦ task :Evaluated by a Teacher Model. For deterministic tasks, it strictly weights ground-truth matching. For open-ended scenarios, it assesses the ratio of valid propositions in draft Dsupported by evidenceK, heavily penalizing hallucinationsU . Action LegalityI leg :Acts as a strict gating con- straint. Cyclic dependencies or mismatched expert assignments forcibly nullify the trajectory score. System OverheadS cost : Imposes a sub-linear penalty on total node count|V Ο |and reconstruction occurrences Ξ· to suppress redundant paths. The composite reward is formally defined as Eq.(8), whereΞ»scales the overhead penalty and Ξ³balances the reconstruction contribution weight. This equation utilizes a one-vote veto gating mecha- nism and a logarithmic penalty to permit reasonable expansion while restricting redundancy. R(Ο ) = Y v i βΟ I leg (v i ) ! Β· Ξ¦ task (Ο ) β λ· log 1 +|V Ο | + Ξ³Ξ· . (8) 3.4.2 Critic-Guided Direct Preference Optimization We employ Direct Preference Optimization (DPO) to fine-tune the low-rank adapter matrices of the central PlannerΟ ΞΈ , bypassing unstable reward model training. As illustrated in Fig. 5, given a queryx, we sample candidate trajectories using a reference pol- icyΟ ref and score them viaR(Ο ). Fig. 5 details the pipeline for constructing preference pairs. For a given queryx, the reference policyΟ ref gener- ates several candidate trajectories, which theCrit(Β·) then scores. For each valid pair, the higher-scoring trajectory is designated as Chosen (Ο w ), and the lower-scoring one as Rejected (Ο l ). To filter evalu- ation noise, a sample pair is incorporated into the preference datasetD =(x (i) ,Ο (i) w ,Ο (i) l ) N i=1 only if the reward differential satisfies a margin thresh- oldβR β₯ Ξ΅. Based on the Bradley-Terry model, the implicit reward function is defined as Eq. (9), r ΞΈ (Ο|x) = Ξ² log Ο ΞΈ (Ο|x) Ο ref (Ο|x) ,(9) whereΞ²controls the KL divergence penalty. The fi- nal DPO loss minimizes the negative log-likelihood like Eq. (10) and Ο(Β·) means the logistic function. L DPO (Ο ΞΈ ;Ο ref ) = β E (x,Ο w ,Ο l )βΌD h logΟ r ΞΈ (Ο w |x)β r ΞΈ (Ο l |x) i . (10) 6 Table 1: Main Experimental Results on Heterogeneous Cognitive Tasks. We report task accuracy (Acc, %), token consumption alongside estimated compute (#Tok / TFLOPs), and average end-to-end latency (Lat., seconds). Bold indicates the best performance among models in the 8B parameter class, andunderlinedenotes the second best (the 72B large model is excluded from this ranking). Method / Architecture StrategyQA (Open-domain)MATH (Deduction)FinQA (Heterogeneous)GPU DRAM Acc (β) #Tok / TFLOPs (β) Lat. (β)Acc (β) #Tok / TFLOPs (β) Lat. (β)Acc (β) #Tok / TFLOPs (β) Lat. (β)Usage (GB) Static Monolithic Baselines (8B Class) Standard Prompting65.2210 / 3.42.545.5350 / 5.64.255.0420 / 6.74.816.5 Standard CoT78.4650 / 10.48.065.41,020 / 16.311.870.51,260 / 20.214.916.5 Standard ToT85.83,400 / 54.439.580.05,430 / 86.967.680.76,930 / 110.976.316.5 Self-Consistency (k=5)83.31,700 / 27.219.878.22,730 / 43.734.476.43,490 / 55.838.416.5 Unconstrained Dynamic Agents (8B Class) ReAct84.52,480 / 39.730.577.64,310 / 69.050.076.25,080 / 81.359.516.5 Reflexion86.23,890 / 62.244.580.56,160 / 98.676.478.87,690 / 123.086.916.5 Multi-Agent (3Γ 8B)84.01,520 / 24.317.579.42,470 / 39.529.577.62,780 / 44.534.3> 49.5 High-Resource Large Model Reference Qwen-2-72B-Instruct92.5800 / 115.210.589.21,440 / 207.416.486.11,640 / 236.220.6> 145.0 DynaGraph (Ours, 8B)87.61,220 / 19.515.382.72,170 / 34.724.482.52,480 / 39.730.216.6 (O(1)) 4 Experiments 4.1 Experimental Setup We evaluate DynaGraph on three datasets: (1) StrategyQA (Geva et al., 2021) for open-domain multi-hop fact retrieval; (2) MATH (Hendrycks et al., 2021) for long-horizon logical deduction and topological resilience; and (3) FinQA (Chen et al., 2021) for cross-modal multi-expert orchestration. Using DeepSeek-8B as the shared base model with LoRA-parameterized experts, all experiments run on a single RTX 5090 (32GB) GPU to validate the O(1) spatial complexity. We compare against representative 8B architec- tures. Static Monolithic Baselines include Standard Prompting (zero-shot), CoT (Wei et al., 2022b) (intermediate reasoning), Self-Consistency (k = 5) (Wang et al., 2022) (majority voting over CoT paths), and ToT (Yao et al., 2023) (tree search over reasoning branches). Unconstrained Dynamic Agents comprise ReAct (Yao et al., 2022) (heuristic trial-and-error), Reflexion (Shinn et al., 2023) (Re- Act with textual error-reflection), and Multi-Agent (3Γ 8B) (collaboration lacking dynamic memory optimization). Finally, Qwen-2-72B-Instruct (Yang et al., 2024) serves as the 72B High-Resource Ref- erence to evaluate how closely our 8B system ap- proximates massive-parameter capabilities. Hyperparameters & Metrics. All 8B models share the same DeepSeek-8B bf16 checkpoint (tem- perature=0.7, top-p=0.9) on a single RTX 5090 GPU. Experts utilize LoRA (rank=8,Ξ± = 16, dropout=0.05) with thresholdsΟ c = 0.35and Ο u = 0.45. GPT-5 serves strictly as the offline DPO training teacher. #Tok sums all prompt and completion tokens (including failed/reconstructed trajectories and planning calls). TFLOPs are calcu- lated as2Γ parametersΓ tokens. Latency reflects single-sample, unbatched wall-clock time, factor- ing in aβΌ0.8 s adapter hot-loading overhead. 4.2Main Results: Task Efficacy and Economy 4.2.1 Efficacy and High-Resource Approximation We evaluate DynaGraph across cognitive effi- cacy and resource constraints, utilizing Tab. 1 and Fig. 6 (a). As shown in Tab. 1, DynaGraph achieves 87.6%, 82.7%, and 82.5% on StrategyQA, MATH, and FinQA, respectively, outperforming all 8B baselines. Compared to Self-Consistency (k = 5), it improves average accuracy by approx- imately 5.0%. Notably, on MATH, the 8B Dyna- Graph (82.7%) closely approaches the 72B refer- ence (89.2%), demonstrating that dynamic topo- logical intervention can partially mitigate inherent capability limitations imposed by parameter scale. 4.2.2 Compute and Time Economy Unconstrained dynamic agents and complex tree- search methods suffer severe context redundancy. For instance, Reflexion consumes 7,690 tokens and 86.9 s on FinQA due to lengthy textual self- reflections, while Standard ToT requires up to 6,930 tokens and 76.3 s. DynaGraph replaces lin- guistic reflection with physical-level graph prun- ing. While achieving higher accuracy than Re- flexion (82.5% vs. 78.8% on FinQA), it reduces token consumption by 64.8%β68.6% and latency by 65.2%β68.1% across benchmarks (e.g., FinQA latency drops from 86.9 s to 30.2 s). Furthermore, 7 (b) Intervention Distribution Across Tasks(a) Quantitative Verification of GPU memory Bounds Figure 6: System efficiency and adaptive routing of DynaGraph. (a) Quantitative Verification of GPU Memory Bounds: PEFT multiplexing yields a constantO(1)peak GPU memory footprint. (b) Intervention Distribution Across Tasks: The Controller deploys task-adaptive corrections: StrategyQA predominantly uses Fine-grained patching (85%), while MATH triggers Subgraph Reconstruction (49%) to halt cascading errors. the TFLOPs metric reveals absolute cross-scale ef- ficiency: despite processing comparable or more tokens than the 72B model, 8B DynaGraph incurs only a fraction of its compute . 4.2.3 Space Economy Multi-expert deployment is typically hindered by GPU memory bottlenecks. The static Multi-Agent (3Γ 8B) baseline requires> 49.5GB, posing se- vere OOM risks. In contrast, DynaGraph main- tains a stable peak GPU memory ofβ16.6 GB (Fig. 6 (a)) regardless of expert pool scale, empiri- cally validating theO(1)bound derived in Sec. 3 and confirming consumer-grade deployability. 4.3Ablation Study on Adaptive Interventions 4.3.1 Dynamic Routing Distribution We conduct ablation studies to investigate the dy- namic routing behavior and contextual decision- making capacity of the system. We first evalu- ate whether anomalies are routed adaptively rather than relying on static heuristics. Fig. 6 (b) shows the proportional distribution of fine-grained patch- ing and subgraph reconstruction across tasks. The results show a clear alignment between interven- tion strategy and task-specific error tolerance. On StrategyQA, 85% of anomalies are resolved via lightweight ine-grained Patching, leveragingE rag to append missing facts without disrupting execu- tion. Conversely, on MATH, 59% of anomalies trig- ger Subgraph Reconstruction to prune erroneous branches and halt cascading errors. This confirms that DynaGraph evaluates error costs rather than relying on hard-coded thresholds. Table 2: Ablation Results of Dynamic Intervention Mechanisms. We report task accuracy (Acc, %) and average end-to-end latency (Lat., seconds). Configuration StrategyQAMATH Acc (β) Lat. (β)Acc (β) Lat. (β) w/o Fine-grained Patching86.929.481.235.4 w/o Subgraph Reconstruction78.413.241.516.9 Full DynaGraph (Ours)87.615.382.724.4 4.3.2 Mechanism Ablation To quantify each mechanismβs contribution, we iso- late them in control experiments. Tab. 2 confirms their complementary efficiency-precision bound- aries. Without fine-grained patching, StrategyQA latency escalates from 15.3 s to 29.4 s (+92.2%) as localized gaps force global re-computation, though accuracy remains intact. This highlights patchingβs pivotal role in execution economy. Conversely, re- moving subgraph reconstruction collapses MATH accuracy from 82.7% to 41.5%, as early hallucina- tions corrupt the execution state beyond local repair. This underscores structural reconstructionβs indis- pensability for topological resilience and deductive coherence. 5 Conclusion We propose DynaGraph, a lightweight framework that overcomes the fragility and memory bottle- necks of multi-agent systems. By multiplexing PEFT adapters and employing dynamic topologi- cal reconfiguration, it enables complex inference on a single consumer GPU. Empirically, our 8B model rivals 72B monoliths while drastically re- ducing latency and computational overhead. 8 Limitations While DynaGraph enables efficient self-healing, its time-division multiplexing inherently enforces se- quential expert execution. This bounds VRAM to prevent out-of-memory errors but precludes simul- taneous execution on parallelizable sub-tasks, intro- ducing switching overhead. Furthermore, topolog- ical reconfiguration relies heavily on local expert self-calibration and predefined confidence thresh- olds. Empirically, evaluations are limited to spe- cific English-centric datasets; generalizing to spe- cialized domains (e.g., biomedical or legal) or mor- phologically rich languages requires further explo- ration. Finally, investigating DynaGraphβs scaling laws on massive models (e.g., 70B+) to determine if topological interventions yield diminishing re- turns remains a critical avenue for future work. References Akari Asai, Zeqiu Wu, Yizhong Wang, Avirup Sil, and Hannaneh Hajishirzi. 2024. Self-rag: Learning to retrieve, generate, and critique through self-reflection. In The Twelfth International Conference on Learning Representations. Maciej Besta, Nils Blach, Ales Kubicek, Robert Ger- stenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadom- ski, Piotr Nyczyk, and Torsten Hoefler. 2024. Graph of thoughts: Solving elaborate problems with large language models. Proceedings of the AAAI Confer- ence on Artificial Intelligence, 38(16):17682β17690. Ilias Chalkidis, Manos Fergadiotis, Prodromos Malaka- siotis, Nikolaos Aletras, and Ion Androutsopoulos. 2020. Legal-bert: The muppets straight out of law school. Preprint, arXiv:2010.02559. Zhiyu Chen, Wenhu Chen, Charese Smiley, Sameena Shah, Iana Borova, Dylan Langdon, Reema Moussa, Matt Beane, Ting-Hao Huang, Bryan R Routledge, et al. 2021. Finqa: A dataset of numerical reasoning over financial data. In Proceedings of the 2021 Con- ference on Empirical Methods in Natural Language Processing, pages 3697β3711. Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. Training verifiers to solve math word prob- lems. Preprint, arXiv:2110.14168. Damai Dai, Chengqi Deng, Chenggang Zhao, R. X. Xu, Huazuo Gao, Deli Chen, Jiashi Li, Wangding Zeng, Xingkai Yu, Y. Wu, Zhenda Xie, Y. K. Li, Panpan Huang, Fuli Luo, Chong Ruan, Zhifang Sui, and Wenfeng Liang. 2024. Deepseekmoe: Towards ultimate expert specialization in mixture-of-experts language models. Preprint, arXiv:2401.06066. Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Let- man, Akhil Mathur, Alan Schelten, Amy Yang, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783. Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. 2021. Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9:346β 361. Dan Hendrycks, Collin Burns, Saurav Kadavath, et al. 2021. Measuring mathematical problem solving with the MATH dataset. In NeurIPS. Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven K. S. Yau, Zijian Lin, et al. 2024. Metagpt: Meta programming for a multi-agent col- laborative framework. In The Twelfth International Conference on Learning Representations. Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. Lora: Low-rank adaptation of large language models. Preprint, arXiv:2106.09685. JieHuang,XinyunChen,SwaroopMishra, Huaixiu Steven Zheng, Adams Wei Yu, Xiny- ing Song, and Denny Zhou. 2024. Large language models cannot self-correct reasoning yet. In The Twelfth International Conference on Learning Representations. Lei Huang, Weijiang Yu, Weitao Ma, Weihong Zhong, Zhangyin Feng, Haotian Wang, Qianglong Chen, Weihua Peng, Xiaocheng Feng, Bing Qin, and Ting Liu. 2025. A survey on hallucination in large lan- guage models: Principles, taxonomy, challenges, and open questions. ACM Transactions on Information Systems, 43(2):1β55. Albert Q Jiang, Alexandre Sablayrolles, Antoine Roux, Arthur Mensch, Blanche Savary, Chris Bamford, De- vendra Singh Chaplot, Diego de las Casas, Florian Hanna, Florian Bensch, et al. 2024. Mixtral of ex- perts. arXiv preprint arXiv:2401.04088. Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. 2020. Scaling laws for neural language models. Preprint, arXiv:2001.08361. Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yu- taka Matsuo, and Yusuke Iwasawa. 2022. Large lan- guage models are zero-shot reasoners. Advances in neural information processing systems, 35:22199β 22213. 9 Jinhyuk Lee, Wonjin Yoon, Sungdong Kim, Donghyeon Kim, Sunkyu Kim, Chan Ho So, and Jaewoo Kang. 2020. Biobert: a pre-trained biomedical language representation model for biomedical text mining. Bioinformatics, 36(4):1234β1240. Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Hein- rich KΓΌttler, Mike Lewis, Wen-tau Yih, Tim Rock- tΓ€schel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in neu- ral information processing systems, 33:9459β9474. Zongqian Li, Yixuan Su, and Nigel Collier. 2025. A sur- vey on prompt tuning. Preprint, arXiv:2507.06085. Haolang Lu, Yilian Liu, Jingxin Xu, Guoshun Nan, Yuanlong Yu, Zhican Chen, and Kun Wang. 2026. Auditing meta-cognitive hallucinations in reasoning large language models. Advances in Neural Informa- tion Processing Systems, 38:162500β162543. OpenAI, Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, et al. 2023. Gpt-4 technical report. Preprint, arXiv:2303.08774. Sheng Shen, Le Hou, Yanqi Zhou, Nan Du, Shayne Longpre, Jason Wei, Hyung Won Chung, Barret Zoph, William Fedus, Xinyun Chen, et al. 2024. Mixture-of-experts meets instruction tuning: A win- ning combination for large language models. In In- ternational Conference on Learning Representations, volume 2024, pages 18858β18884. Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Re- flexion: Language agents with verbal reinforcement learning. In Advances in Neural Information Process- ing Systems (NeurIPS), volume 36, pages 8634β8652. Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. 2019. Commonsenseqa: A question answering challenge targeting commonsense knowl- edge. Preprint, arXiv:1811.00937. Gemini Team, Rohan Anil, Sebastian Borgeaud, Jean- Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M. Dai, et al. 2023. Gem- ini: A family of highly capable multimodal models. Preprint, arXiv:2312.11805. Miles Turpin, Julian Michael, Ethan Perez, and Samuel R. Bowman. 2023.Language models donβt always say what they think: Unfaithful ex- planations in chain-of-thought prompting. Preprint, arXiv:2305.04388. Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171. Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. 2022a. Emer- gent abilities of large language models. Preprint, arXiv:2206.07682. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, and Denny Zhou. 2022b. Chain-of-thought prompting elicits reasoning in large language models. Preprint, arXiv:2201.11903. Shijie Wu, Ozan Irsoy, Steven Lu, Vadim Dabravolski, Mark Dredze, Sebastian Gehrmann, Prabhanjan Kam- badur, David Rosenberg, and Gideon Mann. 2023. Bloomberggpt: A large language model for finance. Preprint, arXiv:2303.17564. An Yang, Yang Baosong, Hui Binyuan, Zheng Bo, Yu Bowen, Gao Chang, Li Chengpeng, et al. 2024.Qwen2 technical report.arXiv preprint arXiv:2407.10671. An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayi- heng Liu, Fan Zhou, Fei Huang, et al. 2025. Qwen3 technical report. Preprint, arXiv:2505.09388. Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Ben- gio, William W Cohen, Ruslan Salakhutdinov, and Christopher D Manning. 2018. Hotpotqa: A dataset for diverse, explainable multi-hop question answer- ing. In Proceedings of the 2018 Conference on Em- pirical Methods in Natural Language Processing, pages 2369β2380. Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik Narasimhan. 2023.Tree of thoughts: Deliber- ate problem solving with large language models. Preprint, arXiv:2305.10601. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations (ICLR). Zihao Zheng, Xiuping Cui, Size Zheng, Maoliang Li, Jiayu Chen, Yun Liang, and Xiang Chen. 2025. Dynamo: Runtime switchable quantization for moe with cross-dataset adaptation. arXiv preprint arXiv:2503.21135. Denny Zhou, Nathanael SchΓ€rli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Claire Cui, Olivier Bousquet, Quoc Le, and Ed Chi. 2023. Least-to-most prompting enables complex reasoning in large language models.Preprint, arXiv:2205.10625. Kunlun Zhu, Zijia Liu, et al. 2025. Where llm agents fail and how they can learn from failures. arXiv preprint arXiv:2509.25370. 10