Training Methods2026~101 minarXiv:2602.02160

D-CORE: Incentivizing Task Decomposition in Large Reasoning Models for Complex Tool Use

Tool use & function calling Reasoning via RL

score 9Bowen Xu, Shaoyu Wu, Hao Jiang +4alibaba-inc↑ 13★ 11Feb 2, 2026cs.CLhttps://github.com/alibaba/EfficientAI

🎯 Pitch

Large reasoning models get caught in fruitless, verbose reflection loops when facing complex multi-step tasks, wasting massive compute for marginal gains. D-CORE solves this “Lazy Reasoning” by forcing the model to first decompose problems into subtasks via self-distillation, then restoring its creative reflection abilities with a diversity-aware RL stage. The resulting 14B model crushes 70B competitors on tool-use benchmarks, proving that reasoning efficiency, not just scale, is the real bottleneck.

1. Executive Summary

This paper introduces D-CORE (Decomposing tasks and Composing Reasoning processes), a two-stage training framework that addresses “Lazy Reasoning”—the tendency of large reasoning models (LRMs) to generate verbose but ineffective reflection loops instead of structural task decomposition in complex multi-turn tool-use scenarios. Using Qwen3-series models evaluated on BFCLv3 and τ-bench, D-CORE first bootstraps task decomposition capability through self-distillation (having the model decompose queries into subtasks and generate reasoning traces for each, then composing them into structured trajectories), followed by Diversity-Aware GRPO (DA-GRPO) (an entropy-based advantage function that prevents gradient collapse when reward variance approaches zero after self-distillation, restoring reflective reasoning diversity). D-CORE-8B achieves 77.7% accuracy on BFCLv3—surpassing the previous best 8B model by 5.7%—while D-CORE-14B establishes a new state-of-the-art at 79.3%, outperforming 70B models despite being 5× smaller, establishing that test-time reasoning computation can be made substantially more efficient for tool use when task decomposition is explicitly incentivized, though gains remain concentrated on problems within the base model’s capability range.

2. Context and Motivation

The Core Problem: LLMs Hit a Complexity Wall in Tool Use Despite Strong Single-Turn Performance

The paper addresses a specific, empirically observed failure mode in large reasoning models (LRMs): when confronted with complex, multi-step tool-use scenarios—particularly multi-turn interactions where the model must track conversation history, reconcile ambiguous user intent, and coordinate multiple tool calls—current LRMs default to what the authors term "Lazy Reasoning." This manifests as lengthy, repetitive reflection cycles ("Let me check... wait, that's not right... let me reconsider...") that consume substantial inference compute but produce negligible improvement in accuracy. The model burns tokens on what looks like reasoning but fails to engage in the actual structural work needed: breaking the problem into sub-tasks, planning an execution order, and tracking progress across steps.

This is not a general reasoning failure—the same models perform well on single-turn tool use and mathematical reasoning. The problem is specifically about compositional complexity in multi-step tool interactions. When a user says "return my skateboard, garden hose, and backpack from orders A, B, and C, and also cancel pending order D," the model must parse multiple overlapping intents, map each item to the correct order, determine which tool functions to call in what sequence, and handle dependencies where one call's output informs the next. Instead of decomposing this into clear subtasks, the model often falls into trial-and-error loops: calling a function with incomplete arguments, realizing the error, reflecting, trying again, re-reflecting, without ever establishing a coherent plan.

The quantitative severity is striking: Figure 3(b) shows that in multi-turn BFCLv3 tasks, Lazy Reasoning accounts for approximately 45% of incorrect answers from baseline Qwen3-8B. This means nearly half of all failures aren't from fundamental inability—they're from the model's reasoning process being structurally misaligned with the task's demands.

Why This Matters: The Growing Gap Between Reasoning Investment and Tool-Use Returns

This problem is important for three converging reasons:

1. The reasoning-compute paradox in tool use. The broader field has demonstrated that scaling test-time computation through long chain-of-thought reasoning substantially improves performance on math, coding, and single-turn tool use (DeepSeek-R1, o1, ToolRL). However, Section 2.2 (Figure 2) reveals that this trend breaks down for complex tool use: LRMs like Qwen3 lag behind specialized SFT-based models (xLAM2 series) on multi-turn tasks, despite vastly outperforming them on single-turn scenarios. The LRMs consume substantially more tokens—expending significant reasoning compute—but see diminishing or even negative returns. This creates a practical dilemma: if reasoning doesn't scale to complex tool use, the primary mechanism for improving LLM capability is inapplicable to a critical deployment domain.

2. Autonomous agents depend on robust multi-step tool execution. Tool use is not an academic benchmark—it's the foundation of autonomous agent systems that interact with real-world APIs (booking systems, e-commerce platforms, enterprise software). Benchmarks like BFCLv3 (Berkeley Function Calling Leaderboard v3) and τ-bench (simulated retail and airline agent tasks) measure exactly these capabilities. When an agent handles customer service, it must maintain state across turns, parse evolving user requirements, and coordinate multiple backend calls. Lazy Reasoning means the agent either gets stuck in loops (degrading latency and user experience) or makes incorrect tool calls (causing real business impact). The practical stakes are high for any organization deploying LLM-based agents.

3. The limitation reveals a structural gap in current RL-based reasoning training. The paper's analysis in Section 2.3 (Figure 3a) shows that multi-turn reasoning trajectories exhibit a distinct thought-category distribution compared to single-turn or math tasks: minimal task decomposition, excessive reflection. This isn't accidental behavior—it suggests that standard RL training (e.g., GRPO with outcome rewards) reinforces whatever patterns the model stumbles upon, and in complex multi-step scenarios, the first pattern the model discovers is often unproductive reflection rather than structured decomposition. The optimization landscape itself may be the problem: decomposition requires a multi-step planning behavior that is harder to discover through random exploration than reflection, which simply requires noticing inconsistencies and attempting corrections. This raises a fundamental training methodology question: can RL alone teach complex planning, or does it need to be seeded with explicit structural knowledge?

Where Prior Approaches Fall Short

The paper identifies limitations along several axes of existing work:

SFT-based tool-use models overfit and don't generalize. Methods like ToolACE (Liu et al., 2024), APIGen (Liu et al., 2024), xLAM2 (Prabhakar et al., 2025), and Magnet (Yin et al., 2025) construct large-scale supervised datasets of tool-use interactions and fine-tune LLMs on them. These approaches work well on in-distribution tasks—xLAM2-70B achieves 75% on BFCLv3 multi-turn—but Section 4.3 (Table 2) shows they degrade sharply on out-of-distribution benchmarks like ACEBench: xLAM2-32B drops to 13.4% on special-category tasks and 0% on normal ones. The paper attributes this to SFT's fundamental limitation: it memorizes surface patterns rather than learning decomposable reasoning strategies that transfer. When the task format or complexity changes, the model collapses.

RL-based reasoning methods haven't cracked complex tool use. ToolRL (Qian et al., 2025) and Nemotron-N1 (Zhang et al., 2025) applied GRPO and long chain-of-thought training to tool use, showing gains on BFCLv3 single-turn tasks. But Table 1 reveals the critical failure: ToolRL-Qwen3-8B achieves only 26.8% on multi-turn tasks—worse than the base Qwen3-8B at 33.0%. The RL training actually hurts multi-turn performance. The paper's analysis suggests why: GRPO relies on reward variance to compute advantages (Equation 2, $A_{i,t} = \frac{R_i - \text{mean}(\{R_i\}_{i=1}^G)}{\text{std}(\{R_i\}_{i=1}^G)}$ ). When the model is already somewhat competent (producing correct answers with reasonable consistency), the reward variance collapses, advantages approach zero, and the gradient signal vanishes. GRPO can't improve what it can't differentiate.

Decomposition-based prompting works but requires manual intervention. Classical approaches like Decomposed Prompting (Khot et al., 2022) and Least-to-Most Prompting (Zhou et al., 2022) address complex reasoning by having the model first decompose a problem into sub-problems, then solve each sequentially. Section 2.3 (Figure 3d and Appendix A.2.5) shows this is highly effective: manually decomposing multi-turn queries into subtasks enables Qwen3-8B to solve them correctly, reducing token usage by roughly 50% while converting failures to successes. But this requires manual decomposition per query—a human must write the subtask breakdown—which is clearly not scalable to deployment. The capability exists in the model but is latent; it needs to be elicited through training, not prompting.

Stronger-teacher distillation has practical barriers. The standard approach to injecting capabilities would be to use a more capable model (GPT-4, Claude) to generate decomposition trajectories and distill them into the target model via SFT. The paper explicitly rejects this dependency (Section 3.1): "We challenge this reliance on external supervision." This matters for several practical reasons: (a) stronger models may not be available (proprietary API constraints, cost, privacy); (b) the decomposition style of a different model family may not transfer well (distribution shift); and (c) using a teacher fundamentally limits the approach to the teacher's capabilities, preventing self-improvement loops.

No systematic analysis of why LRMs fail at complex tool use. Perhaps most critically, prior work treated multi-turn tool-use failures as generic reasoning failures—solved by more data, better prompts, or larger models—without analyzing the specific cognitive behavior patterns that distinguish successes from failures. This paper's contribution of categorizing thoughts into decomposition, reflection, verification, and deduction (Figure 3a) provides a diagnostic framework that reveals the specific deficiency (lack of decomposition, excess of reflection) and thus points directly to the intervention needed.

How D-CORE Positions Itself

D-CORE is positioned as a training methodology that bridges the gap between two observations:

The model already possesses the capability—when given explicit decomposition structure (manual prompting), it executes correctly, proving the underlying tool-use competency exists.
Standard training cannot elicit this capability—SFT alone produces homogenized reasoning that lacks reflection diversity (Figure 7a, Table 3: self-distillation improves decomposition but suppresses reflection), and RL alone cannot converge because Lazy Reasoning generates insufficient reward variance for gradient-based optimization.

The framework therefore operates in two complementary stages that directly address this tension:

Stage 1 (Self-Distillation): Use the model itself—not a stronger teacher—to generate structured decomposition trajectories by providing it with ground-truth reference trajectories and few-shot examples during the generation phase. The model decomposes queries into subtasks, generates reasoning for each subtask independently, then these are composed into full trajectories and used to fine-tune the model. This injects the structure of task decomposition—teaching the model that it should break problems down and how to do so—without requiring external supervision. The "self" in self-distillation refers to the fact that the same model architecture generates the training data it will learn from.
Stage 2 (DA-GRPO): Address the gradient collapse problem introduced by self-distillation. When the model learns to decompose tasks, its outputs become more consistent and accurate on the training distribution, which paradoxically reduces the reward variance that GRPO needs to compute advantages (Figure 5a: self-distilled model shows near-zero reward std). DA-GRPO replaces the zero advantage with an entropy-based term (Equation 6-7): when the standard advantage falls below a threshold $\zeta$ , the advantage becomes $\min(\alpha \cdot \mathcal{H}_{i,t}^{\text{detach}}, \delta)$ , where $\mathcal{H}_{i,t}^{\text{detach}}$ is the token-level entropy of the policy distribution (detached from gradient computation). This means tokens the model is uncertain about (high entropy) get positive advantages, encouraging the model to continue exploring reflective reasoning patterns rather than collapsing to deterministic, decomposition-only outputs. The "diversity-aware" label refers to this explicit incentive to maintain varied reasoning strategies.

The paper explicitly connects this two-stage design to the behavioral analysis in Section 2.3: task decomposition and reflection are complementary reasoning behaviors, and optimizing for only one (as SFT does) or failing to optimize at all (as naïve GRPO does) produces suboptimal tool use. The two-stage design sequentially addresses each component: first ensure decomposition exists (self-distillation), then ensure reflection isn't lost (DA-GRPO).

In the broader landscape, D-CORE represents a middle path between pure RL (which the paper shows fails for complex tool use) and supervised imitation of stronger models (which introduces dependency and generalization concerns). It's a capability-elicitation framework: the model already knows how to do the task (proved by single-turn performance and prompted decomposition), and D-CORE's job is to make that capability emerge naturally in the model's autonomous reasoning, without external prompting or stronger teachers.

3. Technical Approach

3.1 Reader Orientation

D-CORE is a two-stage training pipeline that first teaches an LRM to autonomously decompose complex tool-use queries into subtasks and execute them sequentially, then restores the model's reflective reasoning diversity through an entropy-augmented reinforcement learning objective. The system solves the "Lazy Reasoning" problem — where LRMs generate verbose but ineffective reflection loops instead of structured task decomposition in multi-turn tool-use scenarios — by first injecting explicit decomposition structure via self-generated training data and then preventing RL gradient collapse through an advantage function that rewards high-entropy tokens when reward variance vanishes.

3.2 Big-Picture Architecture (Diagram in Words)

The D-CORE framework has two sequential stages, each with distinct components:

Stage 1 — Self-Distillation Pipeline:

Task Decomposer: Prompts the base LRM to break a query into subtasks, using ground-truth reference trajectories and few-shot examples as structural guides.
Reasoning Generator: For each subtask, generates reasoning traces and tool calls from the same LRM, handling sequential dependencies iteratively and parallel subtasks simultaneously.
Trajectory Composer: Assembles subtask-level reasoning traces, tool calls, and execution results into complete reasoning trajectories that demonstrate structured decomposition.
SFT Distillation: Fine-tunes the LRM on these composed trajectories, teaching it to produce structured decomposition autonomously.

Stage 2 — Diversity-Aware GRPO (DA-GRPO): 5. Reward Calculator: Scores rollouts using format, structure, key, and value matching rewards (inherited from ToolRL). 6. Entropy Monitor: Tracks token-level entropy of the policy distribution during generation. 7. Advantage Reshaper: Replaces near-zero standard GRPO advantages with an entropy-based term to maintain gradient signal. 8. Policy Updater: Applies PPO-style clipped updates using the reshaped advantages, with optional KL divergence penalty against a reference policy.

Information flows: seed queries + reference trajectories → Task Decomposer produces subtask lists → Reasoning Generator produces per-subtask reasoning + tool calls → Trajectory Composer assembles complete demonstrations → SFT Distillation trains the model to produce structured reasoning → DA-GRPO then samples rollouts from the self-distilled model → Reward Calculator scores them → Entropy Monitor computes per-token entropy → Advantage Reshaper produces non-zero advantages even when reward variance collapses → Policy Updater adjusts model parameters to balance decomposition and reflection.

3.3 Roadmap for the Deep Dive

First, the self-distillation procedure (Section 3.1): how the model generates its own decomposition training data, the three scenarios (sequential, parallel, irrelevant), the composition and verification steps, and why this eliminates the need for a stronger teacher model — this is the mechanism that injects task decomposition capability.
Second, the DA-GRPO objective (Section 3.2): why standard GRPO fails after self-distillation, how entropy-based advantages prevent gradient collapse, the piecewise advantage function, hyperparameter roles (α, δ, ζ), and the formal guarantees — this is the mechanism that preserves reasoning diversity.
Third, the reward function (Appendix A.2): how format, structure, key, and value rewards combine to produce scalar scores per rollout — this is the RL signal that guides both standard and diversity-aware optimization.

3.4 Detailed, Sentence-Based Technical Breakdown

This is a training methodology paper whose core idea is that complex tool-use reasoning requires both structured task decomposition (injected via self-distillation) and reflective diversity (maintained via entropy-aware RL), and that these two capabilities must be cultivated sequentially because optimizing for one alone (SFT for decomposition) eliminates the other (reflection variance), while optimizing for neither (naïve RL) fails to escape unproductive reasoning patterns.

Self-Distillation: Injecting Task Decomposition Without a Stronger Teacher

The central challenge in training an LRM to decompose tasks is the chicken-and-egg problem: you need decomposition-structured training data to teach the model, but you don't have a model that produces decomposition-structured outputs. The standard solution — use a stronger "teacher" model to generate this data — is rejected by the authors for practical reasons (Section 3.1): "We challenge this reliance on external supervision." Their alternative is self-distillation: the model itself generates the structured data, but under controlled prompting conditions that elicit the latent decomposition capability the authors demonstrated exists (via manual decomposition experiments in Section 2.3).

The self-distillation pipeline (Algorithm 1) proceeds through four phases:

Phase 1: Task Decomposition (Line 1 of Algorithm 1)

Given a query $Q$ and comprehensive context $\mathcal{C} = \{P, T, C\}$ where $P$ is the system policy (instructions defining the agent's role and constraints), $T$ is the available tool set (function signatures with parameter descriptions), and $C$ is the conversation history (previous user-assistant-tool interactions), the model is prompted to decompose $Q$ into an ordered list of subtasks:

$\mathcal{S} \leftarrow \text{Decompose}(\mathcal{C}, Q, Y^*, \mathcal{M})$

where $\mathcal{S} = \{s_1, s_2, \dots, s_n\}$ is the sequence of subtask descriptions, $Y^*$ is the ground-truth reference trajectory (the correct sequence of tool calls that solves the query), and $\mathcal{M}$ is the base LRM (Qwen3-8B or 14B).

What this computes: The model produces a structured breakdown of the original query into simpler sub-queries, each corresponding to one logical unit of tool execution. For example, a query "return my skateboard from order A, garden hose from order B, and cancel order C" might decompose into: $s_1$ = "return skateboard from order A", $s_2$ = "return garden hose from order B", $s_3$ = "cancel order C".

Why the reference trajectory $Y^*$ is essential: The paper reports that decomposition success rate when relying only on model capability (no reference trajectory, no few-shot examples) is only 73.8% (Table 6). Adding ground-truth reference trajectories ( $Y^*$ ) raises success rate to 89.1%. Adding few-shot examples on top raises it to 93.2%. The reference trajectory serves as a correctness signal — it ensures the number of subtasks $|\mathcal{S}|$ matches the number of tool calls in $Y^*$ (enforced by line 2 of Algorithm 1: "return $\emptyset$ if $|\mathcal{S}| \neq Y^*$ "). This alignment is critical because the subsequent composition phase assumes a one-to-one correspondence between subtasks and tool executions. A mismatch would produce incoherent training trajectories.

The authors also explore a practical alternative for when ground-truth references are unavailable: using pseudo-labels generated by a stronger model (Qwen3-Max). Table 6 shows this achieves 92.8% success rate, nearly matching ground-truth at 93.2%, bridging "the gap between ideal supervision and practical applicability."

The complete decomposition prompt is provided in Appendix A.3. It includes the system policy, tool definitions, conversation history, query, reference trajectory, and few-shot examples — all structured to guide the model toward producing a numbered list of subtask descriptions.

Phase 2: Reasoning Generation (Lines 3–18 of Algorithm 1)

Given the decomposed subtasks $\mathcal{S}$ , the model generates reasoning processes and corresponding tool calls for each subtask. The generation protocol depends on the task category:

Sequential subtasks (Lines 3–10): When subtask $s_i$ depends on the tool execution result of $s_{i-1}$ , the generation proceeds iteratively:

$\mathcal{I}_0 \leftarrow \text{InitInput}(\mathcal{C})$ $(\mathcal{R}_i, \tau_i) \leftarrow \mathcal{M}(\mathcal{I}_{i-1}, s_i) \quad \text{for } i=1, \ldots, |\mathcal{S}|$ $o_i \leftarrow \text{Execute}(\tau_i)$ $\mathcal{I}_i \leftarrow \text{Update}(\mathcal{I}_{i-1}, \tau_i, o_i)$

where $\mathcal{I}_{i-1}$ is the input context for subtask $i$ , initialized from the original context $\mathcal{C}$ and then augmented with previous tool calls and responses as the loop progresses. For each subtask $i$ , the model receives context $\mathcal{I}_{i-1}$ plus subtask description $s_i$ and produces reasoning $\mathcal{R}_i$ (the thinking block) and tool call $\tau_i$ (the action). The tool call is executed against a simulated environment to produce response $o_i$ , which is then incorporated into the context for the next subtask.

Why iterative processing: this preserves the causal dependency structure of sequential tool use — the model must know what happened in step $i-1$ before it can reason about step $i$ . Without this, the generated reasoning would lack the context-aware adaptation that distinguishes effective agents.

Parallel subtasks (Lines 11–15): When subtasks can execute independently, they are generated simultaneously:

$(\mathcal{R}_i, \tau_i) \leftarrow \mathcal{M}(\mathcal{C}, s_i) \quad \text{for } i=1, \ldots, |\mathcal{S}|$

Each subtask receives the same shared initial context $\mathcal{C}$ — no execution results are fed forward because no dependencies exist between parallel calls. The model reasons about each subtask in isolation, producing independent reasoning traces and tool calls.

Irrelevant subtasks (Lines 16–18): When the query requires no tool use (tool irrelevance scenarios), decomposition is not applicable. Instead, the model is prompted to generate an explanation for why the task cannot be decomposed:

$\mathcal{R} \leftarrow \mathcal{M}(\mathcal{C}, Q)$

The model produces reasoning $\mathcal{R}$ that articulates why no tool call is needed, maintaining the structured reasoning format even for negative cases. This is important for training coverage: the model must learn not only how to decompose but also when decomposition is inappropriate.

Phase 3: Composition (Lines 10, 15, 18 of Algorithm 1)

The per-subtask components must be assembled into complete reasoning trajectories suitable for SFT. The composition procedure varies by scenario:

Sequential composition (Line 10):

$\mathcal{\hat{Y}} \leftarrow \text{Compose}_{\text{seq}}(\{(s_i, \mathcal{R}_i, \tau_i, o_i)\}_{i=1}^{|\mathcal{S}|})$

The outputs are concatenated in execution order: subtask 1 description → subtask 1 reasoning → subtask 1 tool call → subtask 1 execution result → subtask 2 description → subtask 2 reasoning → ... This produces a trajectory that demonstrates the full sequential decomposition pattern — the model sees both the planning (subtask listing) and the execution (step-by-step reasoning with tool interactions).

Parallel composition (Line 15):

$\mathcal{\hat{Y}} \leftarrow \text{Compose}_{\text{par}}(\{(s_i, \mathcal{R}_i, \tau_i)\}_{i=1}^{|\mathcal{S}|})$

For parallel subtasks, the composition organizes reasoning traces and tool calls in parallel blocks, often with a coordinator or aggregator step that synthesizes results. The paper notes that "reflection mechanisms are incorporated in Compose template for parallel and irrelevant scenarios" — meaning the composition intentionally inserts reflection-style reasoning (checking results, verifying consistency) into the template to ensure the training data includes this behavior.

Irrelevant composition (Line 18):

$\mathcal{\hat{Y}} \leftarrow \text{Compose}_{\text{irr}}(\mathcal{R}, Y^*)$

For tool-irrelevant queries, the model's explanation $\mathcal{R}$ is composed with the reference trajectory $Y^*$ (which confirms that no tool call is needed), producing a trajectory that teaches the model to recognize and articulate non-tool scenarios.

Why composition matters: the model is being trained to produce these complete trajectories end-to-end at inference time. The composition stage transforms what was a multi-phase generation process (decompose first, then generate per-subtask) into a single coherent output that the model can learn to replicate via SFT. The composed trajectory is what the model should produce on its own after training — a self-contained reasoning process that begins with decomposition and proceeds through structured execution.

Phase 4: Verification and Distillation (Line 20 of Algorithm 1, Equation 1)

Before accepting a composed trajectory for training, it must pass verification:

$\mathcal{\hat{Y}} \text{ is accepted if } \text{Verify}(\mathcal{\hat{Y}}, Y^*) \text{ else } \emptyset$

The verification step checks that the composed trajectory's final tool calls and results match the ground-truth reference $Y^*$ . Trajectories that fail verification — because of hallucinated tool calls, parameter errors, or logical inconsistencies — are discarded. This ensures the SFT dataset only contains correct demonstrations.

Once the dataset of verified trajectories is constructed, the self-distillation SFT loss is:

$\mathcal{L}_{\text{self-distillation}}(\theta) = -\mathbb{E}\left[\log \pi_\theta(\mathcal{\hat{Y}}_t \mid (\mathcal{C}, Q), \mathcal{\hat{Y}}_{1:t-1})\right]$

where $\theta$ are the LRM parameters, $\pi_\theta(\mathcal{\hat{Y}}_t \mid (\mathcal{C}, Q), \mathcal{\hat{Y}}_{1:t-1})$ is the probability the model assigns to token $\mathcal{\hat{Y}}_t$ given the context $(\mathcal{C}, Q)$ and all previous tokens $\mathcal{\hat{Y}}_{1:t-1}$ in the composed trajectory, and the expectation is taken over the training dataset.

What this computes: the standard next-token prediction loss (categorical cross-entropy) across all tokens in the composed trajectories. The model is trained to maximize the likelihood of generating the exact same reasoning process — including decomposition, per-subtask reasoning, tool calls, and reflections — that was demonstrated in the self-generated data.

Why SFT rather than RL for this stage: SFT provides a strong, unambiguous signal about what the output should look like — a structured decomposition followed by step-by-step execution. RL, by contrast, would need the model to discover this structure through reward-guided exploration, which Section 4.3 shows fails for multi-turn tool use (Table 4: GRPO directly on Qwen3-8B achieves only 26.8% multi-turn accuracy vs. 33.0% for the base model). The explicit demonstration is necessary because the desired behavior — listing subtasks, reasoning about each independently, tracking execution state — is a multi-step pattern that random exploration is unlikely to discover, especially when the alternative (simple reflection loops) produces some correct answers and thus receives non-zero reward.

Design choices and their justifications in self-distillation:

Self-distillation over stronger-teacher distillation: The authors observe that "current LRMs inherently possess the capacity to generate high-quality reasoning trajectories when provided with explicit structural guidance" (Section 3.1). By using the same model architecture for both generation and learning, there is no distribution shift between the training data style and the model's own generation tendencies. A GPT-4 teacher might produce decomposition patterns that a Qwen3 model cannot replicate, creating a capability gap that SFT cannot close.
Ground-truth reference in decomposition prompt: Providing $Y^*$ during the generation phase (but not during training — the model learns to produce decomposition without seeing $Y^*$ at test time) acts as a correctness filter. It ensures the subtask count matches the expected tool call count, preventing the model from generating incoherent training data. This is a form of "weak supervision" — using ground truth during data generation but not during model inference.
Per-subtask generation rather than end-to-end generation: Generating reasoning for each subtask independently (especially for parallel subtasks) ensures that the reasoning is focused and relevant. If the model were asked to reason about all subtasks simultaneously, the resulting trajectory might conflate reasoning across subtasks, producing the kind of tangled reflection loops D-CORE aims to eliminate.
Edit-distance-based pairing is NOT used: Unlike the revision model training in the reference paper (which paired incorrect and correct answers by edit distance), D-CORE generates subtask-level reasoning directly from scratch for each subtask. The pairing here is between the subtask description and the model's fresh reasoning, not between incorrect and correct attempts.

Diversity-Aware GRPO: Preventing Gradient Collapse After Self-Distillation

Self-distillation successfully teaches the model to decompose tasks, but it introduces a new problem: reasoning homogenization. Figure 7(a) shows that after self-distillation, the proportion of task decomposition thoughts increases substantially while reflection thoughts decrease. The model becomes good at structured planning but loses the ability to engage in the reflective, self-correcting reasoning that characterizes effective LRMs.

More critically, this homogenization causes gradient collapse in standard GRPO. The paper provides a quantitative diagnosis:

The gradient collapse mechanism (Equations 2–4, Figures 5a and 12–13):

Standard GRPO computes advantages from within-group reward statistics. For a group of $G$ rollouts:

$A_{i,t} = \frac{R_i - \text{mean}(\{R_i\}_{i=1}^G)}{\text{std}(\{R_i\}_{i=1}^G)}$

where $R_i$ is the scalar reward for rollout $i$ , $\text{mean}(\{R_i\}_{i=1}^G)$ is the average reward across the $G$ rollouts in the group, and $\text{std}(\{R_i\}_{i=1}^G)$ is the standard deviation.

The policy gradient for GRPO (omitting the clipping term for clarity) is:

$\nabla_\theta \mathcal{J}_{\text{GRPO}} = \frac{1}{G}\left(\sum_{(i,t)}\frac{1}{|y_i|} r_{i,t}(\theta) A_{i,t} \nabla_\theta \log \pi_\theta(y_{i,t} \mid x_i, y_{i,<t})\right)$

where $r_{i,t}(\theta) = \frac{\pi_\theta(y_{i,t} \mid x_i, y_{i,<t})}{\pi_{\text{old}}(y_{i,t} \mid x_i, y_{i,<t})}$ is the importance sampling ratio, $|y_i|$ is the length (number of tokens) of rollout $i$ , and $\pi_\theta$ and $\pi_{\text{old}}$ are the current and old policy distributions, respectively.

What this computes: for each token position $(i,t)$ in every rollout, the gradient contribution is the product of three terms: (1) the importance sampling ratio $r_{i,t}(\theta)$ (how much more likely the current policy makes this token vs. the old policy — clips extreme changes), (2) the normalized advantage $A_{i,t}$ (was this rollout better or worse than the group average, scaled by group variability), and (3) the score function $\nabla_\theta \log \pi_\theta(y_{i,t} \mid \dots)$ (direction in parameter space that increases probability of this token). The sum is averaged over all tokens and rollouts.

Why this form: the score function estimator is the standard REINFORCE gradient, with $r_{i,t}(\theta)$ correcting for off-policy sampling (PPO-style clipping bounds how far $\pi_\theta$ can diverge from $\pi_{\text{old}}$ ). The advantage normalization by standard deviation adapts the step size to reward scale — when rewards have high variance, advantages shrink, preventing large destructive updates; when variance is low, advantages grow, enabling precise optimization.

The collapse: After self-distillation, the model becomes highly consistent — most rollouts produce the same (correct) tool calls, yielding identical rewards. Figure 5(a) shows the reward standard deviation drops to near zero (the "SD" curve). When $\text{std}(\{R_i\}_{i=1}^G) \approx 0$ , all advantages $A_{i,t} \approx 0$ (even if rewards are high, the differences between them vanish), causing $\nabla_\theta \mathcal{J}_{\text{GRPO}} \approx 0$ . No learning occurs — the model is stuck at whatever reasoning pattern self-distillation produced.

Why RL after SFT is necessary despite this problem: Table 4 shows that self-distillation alone achieves 57.5% on BFCLv3 multi-turn, but adding GRPO (once the collapse is resolved) raises this to 67.4% — a gain of 9.9 percentage points. The SFT model can decompose but lacks reflective self-correction; RL is needed to add that capability back. The challenge is how to do RL when SFT has eliminated the reward variance the algorithm requires.

The DA-GRPO solution (Equations 6–10):

DA-GRPO replaces the standard advantage $A_{i,t}$ with a modified advantage $\hat{A}_{i,t}$ that incorporates token-level entropy when standard advantages vanish:

$\hat{A}_{i,t} = \begin{cases} \psi(\mathcal{H}_{i,t}) & \text{if } A_{i,t} < \zeta, \\ A_{i,t} & \text{otherwise}, \end{cases}$

where $\zeta$ is a small constant for numerical stability (the paper suggests $\zeta = 10^{-8}$ ), $A_{i,t}$ is the standard GRPO advantage from Equation (2), and $\psi(\mathcal{H}_{i,t})$ is an entropy-based advantage term:

$\psi(\mathcal{H}_{i,t}) = \min({\alpha} \cdot {\mathcal{H}^{\text{detach}}_{i,t}}, \delta)$

where $\alpha$ is a scaling coefficient controlling how strongly entropy influences advantages (swept across $\alpha \in \{0.01, 0.1, 0.4, 1.0\}$ in experiments), $\delta$ bounds the maximum entropy advantage to prevent it from dominating the standard advantage signal, and $\mathcal{H}^{\text{detach}}_{i,t}$ is the token-level entropy of the policy distribution, detached from gradient computation:

$\mathcal{H}^{\text{detach}}_{i,t} = -\sum_{v \in \mathcal{V}} \pi_\theta(v \mid x_i, y_{i,<t}) \log \pi_\theta(v \mid x_i, y_{i,<t})$

where $\mathcal{V}$ is the token vocabulary, $\pi_\theta(v \mid x_i, y_{i,<t})$ is the policy probability of token $v$ at position $t$ in rollout $i$ given the context, and the sum runs over all tokens in the vocabulary.

What $\mathcal{H}_{i,t}$ computes: the Shannon entropy of the model's output distribution at token position $t$ . If the model is highly confident (assigns probability near 1 to one token and near 0 to all others), entropy is low (near 0). If the model is uncertain (spreads probability across many tokens), entropy is high. The "detach" notation means this entropy is computed and stored as a constant during backpropagation — it does not contribute gradients back to the policy parameters. It serves purely as a scalar coefficient in the advantage.

What the piecewise $\hat{A}_{i,t}$ computes: when the standard advantage vanishes ( $A_{i,t} < \zeta \approx 0$ ), the effective advantage becomes proportional to the model's uncertainty at that token position. High-entropy tokens (which the model is uncertain about) receive positive advantages, encouraging the policy to learn from them. Low-entropy tokens (which the model is confident about) receive near-zero advantages, providing no update signal. When the standard advantage is non-zero (the model is still producing variable rewards), the entropy term is ignored and standard GRPO behavior is preserved.

Why this form: the key insight is that when reward variance collapses, the information about which tokens matter shifts from reward statistics to model uncertainty. High-entropy tokens are precisely the ones the model isn't sure about — they represent decision points where exploration is needed. The $\min(\cdot, \delta)$ clipping prevents entropy advantages from growing unbounded (entropy can theoretically be up to $\log|\mathcal{V}|$ , which for a vocabulary of 100k+ tokens would be very large). The authors select $\delta = 0.5$ for most experiments and $\delta = 1.0$ for the highest-entropy variant.

The complete DA-GRPO objective (Equation 9) is:

$\mathcal{J}_{\text{DA-GRPO}}(\theta) = \mathbb{E}[\min(r_{i,t}(\theta)\hat{A}_{i,t}, \text{clip}(r_{i,t}(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_{i,t}) - \lambda \mathbb{D}_{\text{KL}}[\pi_\theta \mid\mid \pi_{\text{ref}}]]$

where $r_{i,t}(\theta)$ is the importance sampling ratio (Equation 5), $\text{clip}(\cdot, 1-\epsilon, 1+\epsilon)$ bounds the ratio to prevent too-large policy updates (standard PPO clipping with $\epsilon = 0.2$ ), $\lambda$ is the KL penalty coefficient (set to 0.001), and $\mathbb{D}_{\text{KL}}[\pi_\theta \mid \mid \pi_{\text{ref}}]$ is the KL divergence between the current policy $\pi_\theta$ and a reference policy $\pi_{\text{ref}}$ (the self-distilled model).

The resulting policy gradient (Equation 13) decomposes into two components:

$\nabla_\theta \mathcal{J}_{\text{DA-GRPO}} = \underbrace{\nabla_\theta \mathcal{J}_{\text{GRPO}}}_{\text{Standard GRPO}} + \underbrace{\frac{1}{G} \sum_{(i,t) \in \mathcal{T}_{=0}} \frac{1}{|y_i|} r_{i,t}(\theta) \psi(\mathcal{H}_{i,t}) \nabla_\theta \log \pi_\theta(y_{i,t} \mid x_i, y_{i,<t})}_{\text{Entropy Advantage Term}}$

where $\mathcal{T}_{=0} = \{(i,t) : \hat{A}_{i,t} = 0\}$ is the set of token positions where the standard advantage vanished (Equation 12), and $\mathcal{T}_{\neq 0}$ is the complement set where standard advantages remained non-zero.

What this gradient computes: for token positions where standard GRPO would produce zero gradient (because $A_{i,t} \approx 0$ ), DA-GRPO adds an additional gradient term proportional to $\psi(\mathcal{H}_{i,t})$ . Tokens with high entropy receive strong positive gradients (encouraging the model to increase their probability). Tokens with low entropy receive weak gradients (minimal update). The result is a gradient signal even when all rollouts have identical rewards — the model is pushed toward exploring uncertain tokens rather than stalling.

Formal guarantees (Theorems 3.1 and 3.2):

The paper provides two theoretical results that characterize DA-GRPO's behavior.

Theorem 3.1 (Prevention of Learning Stagnation): Let $\mathcal{T}_{=0} \neq \emptyset$ be the set of positions where $A_{i,t} = 0$ . If there exists $(i,t) \in \mathcal{T}_{=0}$ such that:

$r_{i,t}(\theta) \neq 0$ (the importance sampling ratio is non-zero — the current policy has not completely diverged from the old policy)
$\psi(\mathcal{H}_{i,t}) > 0$ (the policy is not degenerate — it doesn't assign probability 1 to a single token)

Then $\|\nabla_\theta \mathcal{J}_{\text{DA-GRPO}}\| > 0$ , ensuring continued learning. The proof (Appendix A.7) shows that even when all standard advantages are zero, the entropy advantage term provides a non-zero gradient as long as the policy distribution is not completely deterministic. This guarantees that DA-GRPO cannot get stuck in the way standard GRPO does after self-distillation.

Theorem 3.2 (Entropy Reduction Property): When $A_{i,t} = 0$ for some token position $(i,t)$ , DA-GRPO encourages the generation of high-entropy tokens by reducing their entropy. Specifically, the gradient contribution at position $(i,t)$ is proportional to $\psi(\mathcal{H}_{i,t})$ , where $\mathcal{H}_{i,t} = -\log \pi_{\theta_{\text{old}}}(y_{i,t} \mid x_i, y_{i,<t})$ — the negative log-likelihood of the sampled token under the old policy. Tokens with higher $\mathcal{H}_{i,t}$ (i.e., tokens the old policy was less likely to generate) receive stronger positive gradients, making them more likely under the new policy. This "reducing their entropy" means the model becomes more confident about previously uncertain tokens — it learns to generate them reliably.

Why this is important: standard entropy regularization would increase the entropy of the entire distribution (making the model more uniform). DA-GRPO does the opposite for specific sampled tokens — it selectively increases their probability, making the model more deterministic about tokens it was previously uncertain about. This is a form of targeted exploration consolidation: the model explores uncertain decision points, and when it finds good tokens, DA-GRPO locks them in by increasing their probability.

Hyperparameter roles and selection:

$\alpha$ (entropy scaling coefficient): Controls how strongly high-entropy tokens are rewarded. Swept across $\{0.01, 0.1, 0.4, 1.0\}$ . Table 3 shows $\alpha = 0.1$ achieves the best average score (57.6%). Lower values ( $\alpha = 0.01$ ) provide insufficient diversity incentive; higher values ( $\alpha = 1.0$ ) introduce excessive entropy that "confuses rewards" — the entropy advantage overwhelms the standard reward signal, leading to exploration collapse (Figure 6: $\alpha=1.0$ shows lower reward despite high reflection tokens).
$\delta$ (entropy advantage bound): Caps the maximum entropy advantage. Set to 0.5 for $\alpha \in \{0.01, 0.1, 0.4\}$ and to 1.0 for $\alpha = 1.0$ . The bound prevents entropy-based advantages from dominating when entropy is very high, maintaining a balance with standard reward signals.
$\zeta$ (numerical stability threshold): Set to $10^{-8}$ . This is a purely numerical parameter — advantages below this threshold are treated as exactly zero. It prevents floating-point artifacts from creating spurious gradient signals.

Selection rationale: The authors select $\alpha = 0.1$ as "the best balance between exploration and exploitation" based on Table 3 results. At this value, DA-GRPO achieves +11.4% over the Qwen3-8B baseline on BFCLv3 average accuracy while maintaining the highest τ-bench airline accuracy (44.4%). The qualitative case study in Appendix A.5 confirms this balance: at $\alpha = 0.1$ , the model successfully identifies both items to return (correct reasoning); at $\alpha = 1.0$ , excessive entropy advantages cause the model to insert unnecessary "wait," "but," and "however" tokens that derail task execution (incorrect reasoning).

Training dynamics (Figure 6):

The paper provides learning curves comparing GRPO to DA-GRPO at different $\alpha$ values. Over training steps:

Reward: GRPO shows a moderate increase then plateaus. DA-GRPO with $\alpha = 0.1$ achieves the highest final reward, exceeding GRPO. DA-GRPO with $\alpha = 1.0$ shows lower reward despite higher reflection token counts — the excessive entropy injects noise that harms task performance.
Reflection tokens: DA-GRPO consistently produces more reflection tokens than GRPO, with the count increasing as $\alpha$ grows. This confirms that entropy-based advantages successfully restore reflective reasoning that self-distillation suppressed. The $\alpha = 0.1$ variant achieves a middle ground — more reflection than GRPO but less than the $\alpha = 1.0$ variant that over-explores.

The training hyperparameters (Appendix A.6): DA-GRPO uses verl version 0.5.0 on 8×80G A100 GPUs. Advantage clipping ratios (adv clip ratio low, adv clip ratio high, and adv clip ratio) are set to 0.2. KL divergence is disabled in reward calculation (use kl in reward=False) with kl coef = 0.0, but KL loss is enabled in the actor (use kl loss=True) with coefficient 0.001 and loss type 'low var kl'. Maximum prompt length is 8,192 tokens, maximum response length is 4,096 tokens. Actor rollout uses temperature 1.0, top p 1.0, top k -1 (vLLM rollout), and validation top p 0.7. Both Qwen3-8B and Qwen3-14B models are trained with $\alpha = 0.1$ and $\sigma = 0.5$ ( $\sigma$ here is $\delta$ in the notation of Section 3.2) for 3 epochs. Training time is 11 hours for 8B and 17 hours for 14B.

Reward Function (Appendix A.2, Equations 16–18)

Both standard GRPO and DA-GRPO use the same four-component reward function inherited from ToolRL (Qian et al., 2025). For each rollout, the scalar reward $R_i$ is the sum of four binary or fractional matching scores:

$R_{\text{format}} = \mathbb{1}(\texttt{" thinking}\backslash\texttt{n"}.*\texttt{"}\backslash\texttt{n response}\backslash\texttt{n}\backslash\texttt{n"})$

where $\mathbb{1}$ is the indicator function (1 if the pattern matches, 0 otherwise). This reward checks that the model's output contains the proper thinking/response tag structure required for LRM evaluation.

$R_{\text{struct}} = \mathbb{1}(\mathcal{N}_G = \mathcal{N}_P)$

where $\mathcal{N}_G$ is the set of tool names in the generated output and $\mathcal{N}_P$ is the set of tool names in the reference (ground-truth) trajectory. This reward is 1 if the model called exactly the right tools (regardless of parameter values) and 0 otherwise. It enforces correct tool selection at the function level.

$R_{\text{key}} = \frac{1}{|\mathcal{K}|} \sum_{j=1}^{|\mathcal{K}|} \mathbb{1}(\mathcal{K}_j^G = \mathcal{K}_j^P)$

where $\mathcal{K}$ is the set of parameter names for the selected tools, $\mathcal{K}_j^G$ is the $j$ -th parameter name generated, and $\mathcal{K}_j^P$ is the $j$ -th reference parameter name. This reward is the fraction of parameter names that exactly match — partial credit for getting some parameters right even if others are wrong.

$R_{\text{value}} = \frac{1}{|\mathcal{K}|} \sum_{j=1}^{|\mathcal{K}|} \frac{1}{|\mathcal{V}_j|} \sum_{k=1}^{|\mathcal{V}_j|} \mathbb{1}(\mathcal{V}^G_j[k] = \mathcal{V}^P_j[k])$

where $\mathcal{V}_j$ is the set of values for parameter $j$ (parameters can have multiple values, e.g., item_ids=["5753502325", "9851293632"]), $\mathcal{V}^G_j[k]$ is the $k$ -th generated value, and $\mathcal{V}^P_j[k]$ is the $k$ -th reference value. This reward is the fraction of parameter values that exactly match — it provides fine-grained credit for partially correct arguments.

The total reward is the sum:

$R_i = R_{\text{format}} + R_{\text{struct}} + R_{\text{key}} + R_{\text{value}}$

What this computes: a reward between 0 and 4 (each component is at most 1). A rollout that uses the correct format, calls exactly the right tools with exactly the right parameter names and values gets $R_i = 4$ . Most rollouts receive partial credit — correct tool selection but wrong values scores $R_{\text{struct}} + R_{\text{key}}$ plus fractional $R_{\text{value}}$ .

Why this multi-component form: the four components provide a curriculum-like reward shaping. Format matching is the easiest (the model quickly learns to output correct tags). Structure matching guides tool selection. Key and value matching provide progressive credit for parameter accuracy. Without this decomposition, the reward would be binary (all correct or 0), providing extremely sparse signal for RL — especially in complex multi-turn scenarios where getting everything right in one rollout is rare. The partial credit from key and value matching ensures the model gets some positive signal even from partially correct attempts, preventing complete gradient starvation.

Why the exact-match indicator rather than a similarity metric: tool calls require precise parameter values — "paypal_3024827" is correct; "paypal_3024828" might fail silently or produce catastrophic downstream effects. A soft similarity metric (e.g., edit distance) would reward near-misses that are actually disastrous in tool execution. Exact matching enforces the precision that production tool use demands.

4. Key Insights and Innovations

Innovation 1: Identifying "Lazy Reasoning" as a Specific Cognitive-Pattern Failure Mode, Not a Generic Performance Gap

The paper's most distinctive contribution is not a training method but a diagnostic concept: the characterization of "Lazy Reasoning" as the specific failure signature of LRMs in complex tool use. Prior work treated multi-turn tool-use failures as generic reasoning deficiencies — solved by more data, larger models, or better prompts — without analyzing what the model is actually doing when it fails. The authors show that the model is not failing silently or producing random outputs; it is engaging in a highly systematic but counterproductive behavior: producing extensive reflection cycles ("Let me check... wait, that's wrong... let me reconsider...") while almost entirely omitting task decomposition (breaking the problem into sub-goals). This is documented quantitatively in Figure 3(a), which categorizes thoughts into decomposition, reflection, verification, and deduction, revealing that multi-turn reasoning trajectories are dominated by reflection (excessive) and nearly devoid of decomposition, while math and single-turn tool-use trajectories show a more balanced distribution with substantial decomposition.

What makes this a conceptual advance rather than an observation is that it reframes the problem from capability to behavior. The paper does not claim the model can't decompose tasks — it proves the model doesn't, and that this is a learned behavioral pattern rather than a fundamental limitation. The evidence is the manual decomposition experiment in Section 2.3 and Appendix A.2.5: when the same Qwen3-8B model that fails on multi-turn queries is given explicitly decomposed subtasks (via human-written decomposition prompts), it solves them correctly, reducing token usage by roughly 50% while converting failures to successes. The capability exists latently; the model's default reasoning strategy (acquired through standard RL training) simply fails to access it.

This diagnostic framing is significant because it changes the intervention target. If the problem were insufficient capability, the solution would be more pretraining, more parameters, or more data. If the problem were insufficient exploration, the solution would be stronger RL exploration incentives. But if the problem is a maladaptive reasoning habit — the model has learned that reflection loops are an acceptable substitute for planning — then the solution is to explicitly teach the alternative behavior pattern. This is precisely what D-CORE does: self-distillation injects structured decomposition into the model's behavioral repertoire, and DA-GRPO ensures that this new behavior doesn't crowd out useful reflection. The diagnostic concept of Lazy Reasoning is what makes this intervention principled rather than heuristic — it explains why the two-stage design is necessary and what each stage must accomplish.

Critically, the paper also establishes that Lazy Reasoning is not peculiar to one model or dataset. Appendix A.2.4 explicitly states "all LRMs have Lazy Reasoning" — it is detectable whenever a model shows low accuracy and extensive ineffective reflection. The filtering experiments in Appendix A.2.2 (Figure 10) confirm this pattern across Qwen3-8B and Qwen3-32B, and across BFCLv3 and τ-bench tasks. This universality positions Lazy Reasoning as a general diagnostic category for evaluating LRM tool-use reasoning, analogous to how "hallucination" became a diagnostic category for factuality failures. Future work on LRM tool use can now ask: "does this model exhibit Lazy Reasoning on this task?" rather than just "what is the accuracy?"

Innovation 2: The Self-Distillation Strategy — Capability Elicitation Without a Stronger Teacher

The paper makes a methodological contribution that challenges a dominant assumption in LLM training: that injecting complex behavioral patterns requires either (a) human demonstration data, (b) a stronger teacher model, or (c) discovery through reinforcement learning exploration. D-CORE's self-distillation stage demonstrates a fourth option: the model can generate its own structured training data when provided with correctness constraints during generation, even though it cannot produce that structure autonomously at inference time.

The standard approach in prior work for injecting planning or decomposition into LLMs has been either:

Stronger-teacher distillation (Huang et al., 2022; Schick et al., 2023): use GPT-4 or Claude to generate structured reasoning traces, then fine-tune a smaller model on them. The paper explicitly rejects this dependency.
RL discovery (ToolRL, DeepSeek-R1): run GRPO with outcome rewards and hope the model discovers decomposition through exploration. Section 4.3 and Table 4 show this fails for multi-turn tool use.
Manual decomposition prompting (Khot et al., 2022; Zhou et al., 2022): have humans write subtask breakdowns per query. Effective but not scalable.

D-CORE's self-distillation occupies a distinct position: it uses the model's latent decomposition capability (proved to exist via manual prompting experiments) but elicits it during data generation by providing the ground-truth reference trajectory $Y^*$ as a structural guide. The model sees $Y^*$ during the decomposition generation phase (prompted with it alongside the query) but never during inference after training — the SFT teaches the model to produce decomposition without seeing the reference. Table 6 quantifies the dependence: decomposition success rate is only 73.8% without reference trajectories, rises to 89.1% with ground-truth references, and reaches 93.2% with both references and few-shot examples. The reference trajectory acts as a "scaffold" that enables the model to access a capability it possesses but cannot autonomously deploy.

What makes this intellectually distinctive is the separation of generation-time capability from inference-time capability. The field typically assumes that if a model can produce behavior X with certain inputs, it "has" capability X. D-CORE exploits the fact that a model can produce behavior X under carefully controlled prompting conditions (with ground-truth as a guide) even when it cannot produce X autonomously, and that training on the prompted outputs transfers the prompted behavior to autonomous generation. This is not standard knowledge distillation (the teacher and student are the same model) and not standard SFT (the training data is generated by the model itself, not collected from an external source). It is a form of self-scaffolding: using correctness constraints to help the model generate training data that demonstrates a behavior it will later learn to produce unaided.

This matters beyond tool use. Any domain where a desired reasoning pattern is latent but not spontaneously expressed — formal proof structure in theorem proving, structured diagnosis in medical reasoning, planning in embodied agents — could potentially use the same self-distillation paradigm. The key requirement is that (a) the model actually possesses the underlying capability (proved by prompted performance) and (b) a correctness signal exists to guide generation (ground-truth references, pseudo-labels from stronger models, or verifiable constraints).

The paper also demonstrates a practical weakening of this requirement: Table 6 shows that pseudo-labels from a stronger model (Qwen3-Max) achieve 92.8% decomposition success rate, nearly matching ground-truth at 93.2%. This means self-distillation works even when ground-truth references are unavailable, as long as a somewhat stronger model can provide approximate structural guidance. The "self" in self-distillation therefore has a spectrum: from pure self-generation (73.8%) to pseudo-label-guided (92.8%) to ground-truth-guided (93.2%). The framework accommodates varying levels of external supervision without requiring a full stronger-teacher distillation pipeline.

Innovation 3: Entropy-Based Advantage Reshaping as a Mechanism for Balancing Competing RL Objectives

The paper's DA-GRPO algorithm addresses a specific and previously underappreciated problem in RL fine-tuning of LLMs: capability homogenization causing gradient collapse. The standard approach to combining SFT and RL is to SFT first (inject desired behavior), then RL (refine and optimize). But the paper demonstrates that this sequence can create a trap: SFT makes the model so consistent that RL's primary optimization signal — reward variance — vanishes. This is not a general RL instability problem; it is a problem specifically created by successful SFT.

Prior work on RL for LLMs (GRPO, PPO) has focused on issues like reward hacking, KL divergence management, and exploration-exploitation balance. The gradient collapse from reward variance reduction is a distinct failure mode that only becomes apparent when RL follows a highly effective SFT stage — a scenario that is becoming increasingly common as SFT methods improve. The paper's contribution is not just the DA-GRPO solution but the identification and formal characterization of this failure mode (Figure 5a, Appendix Figures 12-13, Equations 2-4). The analysis shows that when self-distillation produces rollouts with mean reward ~3 and standard deviation ~0, the standard GRPO advantage normalization (Equation 2) produces advantages clustered at zero, causing the gradient (Equation 4) to vanish entirely.

DA-GRPO's entropy-based advantage (Equations 6-8) is a principled response: instead of trying to artificially inflate reward variance (which would require making the model worse), it finds gradient signal in a different source — model uncertainty. High-entropy tokens are decision points where the model is unsure, and regardless of whether all rollouts have the same reward, those uncertain tokens are where exploration should happen. The piecewise advantage function (Equation 6) cleanly separates the two regimes: when standard advantages exist (the model produces variable outcomes), use them normally; when they vanish, switch to entropy-based advantages. This preserves the standard GRPO behavior where it works and provides an alternative signal where it doesn't.

What makes this conceptually novel is the repurposing of entropy from a regularization term to an advantage signal. Standard entropy regularization (common in RL and policy gradient methods) adds an entropy bonus to the reward to encourage exploration — the policy is rewarded for being uncertain. DA-GRPO uses entropy in the advantage to create a gradient signal when the reward-based signal collapses — the policy's gradient is scaled by its uncertainty. The difference is subtle but important: entropy regularization pushes the policy toward uniform distributions (maximum entropy), while DA-GRPO (as proven in Theorem 3.2) reduces the entropy of high-entropy tokens by selectively increasing their probability. The model doesn't become more random; it becomes more confident about previously uncertain decisions. This is exploration consolidation, not exploration encouragement.

The theoretical guarantees (Theorems 3.1 and 3.2) elevate this from a heuristic trick to a justified algorithm. Theorem 3.1 proves that DA-GRPO cannot experience complete gradient collapse as long as the policy is non-degenerate — a guarantee standard GRPO cannot provide after SFT. Theorem 3.2 characterizes precisely what DA-GRPO optimizes when standard advantages vanish: it preferentially increases the probability of tokens the old policy was uncertain about, making the model more deterministic about its exploration discoveries.

The empirical validation (Table 3, Figure 6) confirms the mechanism works as designed. DA-GRPO with moderate entropy scaling ( $\alpha = 0.1$ ) restores reflective reasoning (Figure 7a shows reflection proportion increases after DA-GRPO) and improves multi-turn accuracy by 9.9 percentage points over self-distillation alone (Table 4). Importantly, the $\alpha$ hyperparameter sweep reveals the expected tradeoff: too little entropy ( $\alpha = 0.01$ ) provides insufficient diversity; too much ( $\alpha = 1.0$ ) causes the entropy signal to overwhelm the reward signal, leading to exploration collapse where the model generates excessive "wait," "but," and "however" tokens (Appendix A.5 case study). This non-monotonic relationship between entropy scaling and performance validates the paper's claim that DA-GRPO balances two competing objectives — task decomposition accuracy and reflective reasoning diversity — rather than simply injecting noise.

Innovation 4: Empirical Proof That Task Decomposition Can Be Learned from Self-Generated Data and Transferred to Unseen Complexities

While the paper's primary contribution is methodological (D-CORE), it also contributes a significant empirical finding: trajectories generated by the self-distillation procedure are sufficiently rich to teach decomposition to entirely different model architectures, and the learned decomposition generalizes to out-of-distribution benchmarks. This finding has two components.

First, transferability across architectures. Table 5 shows that SFT on Llama3.1-8B and Qwen2.5-14B using D-CORE trajectories (generated by Qwen3-8B) produces models that dramatically outperform those trained on DeepSeek-R1 trajectories. On BFCLv3 overall, D-CORE-Llama3.1-8B achieves 63.7% vs. 27.8% for DS-R1-Llama3.1-8B; on τ-bench, 36.0% vs. 19.0%. The same pattern holds for Qwen2.5-14B: 70.5% vs. 47.9% on BFCLv3, 41.5% vs. 18.2% on τ-bench. This is notable because DeepSeek-R1 is a general-purpose reasoning model with strong performance on math and coding, yet its reasoning trajectories are far less effective for teaching tool-use decomposition than D-CORE's specially constructed ones. The finding confirms that task decomposition is a teachable reasoning skill that can be packaged into training data and transferred across architectures — it is not an emergent property specific to certain models or training recipes.

Second, out-of-distribution generalization. Table 2 evaluates D-CORE on three benchmarks not seen during training: τ²-Bench (dual-control environments with shared world states), ACEBench (complex system and user prompts as stress tests), and BFCLv4-Agentic (new scenarios for web-search and memory). The results are consistent across domains and difficulty levels. On ACEBench normal, D-CORE-8B achieves 78.7% vs. 75.3% for Qwen3-8B and 5.3% for xLAM2-70B (which collapses on out-of-distribution tasks despite being 8.75× larger). On BFCLv4-Agentic web-based tasks, D-CORE-8B reaches 36.0% vs. 16.0% for the base model. On τ²-Bench telecom (a domain not in training), D-CORE-14B achieves 34.9% — a task absent from the training data entirely.

This generalization is significant because it differentiates D-CORE from SFT-based tool-use models that overfit to training distributions. The paper explicitly positions this as evidence that "performance gains stem from intrinsic improvements in task decomposition and reasoning, rather than overfitting to specific training distributions" (Section 4.3). The mechanism: self-distillation teaches a reasoning strategy (decompose, then execute per-subtask) rather than a task-specific policy (call function X when you see pattern Y). The strategy transfers because decomposition is a domain-general cognitive operation — breaking problems into sub-problems applies to retail, airline, telecom, and web-search tasks alike — while SFT's surface patterns are domain-specific and brittle.

The xLAM2 comparison in Table 2 is particularly instructive. xLAM2-70B achieves 75.0% on BFCLv3 multi-turn (in-distribution) but drops to 5.3% normal and 38.4% special on ACEBench. D-CORE-8B achieves 63.8% on BFCLv3 multi-turn (lower in-distribution) but 78.7% normal and 59.2% special on ACEBench (dramatically higher out-of-distribution). This is a classic generalization vs. specialization tradeoff, with D-CORE favoring generalization. For autonomous agent deployments where task distributions shift over time (new APIs, new domains, evolving user behaviors), generalization-optimized training may be preferable to in-distribution-maximized training, even if the latter posts higher benchmark numbers on known tasks. The paper's generalization results provide evidence for this preference without explicitly arguing it.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper uses two primary benchmarks: BFCLv3 (Berkeley Function Calling Leaderboard v3; Patil et al., 2024), which evaluates single-turn (live, non-live, relevance, irrelevance) and multi-turn tool-use scenarios, and τ-bench (Yao et al., 2024), which simulates complex multi-turn agent interactions in retail and airline customer service domains. The paper reports results on the full BFCLv3 test set (exact size not specified, but Table 1 reports aggregate scores across all categories) and the τ-bench test set. For out-of-distribution evaluation (Table 2), three additional benchmarks are used: τ²-Bench (Barres et al., 2025) with dual-control environments across retail, airline, and telecom; ACEBench (Chen et al., 2025) with normal and special task categories designed as stress tests; and BFCLv4-Agentic with web-search and memory scenarios. Training data for D-CORE is constructed from subsets of open-source tool-use datasets (ToolACE, APIGen, xLAM2) plus trajectories from a custom-built tool-use agent, generating 40,000 self-distillation instances and sampling 5,000 for RL.
Base model(s). All experiments use Qwen3-series LRMs (Yang et al., 2025) at two scales: Qwen3-8B and Qwen3-14B. The authors state these models are representative of contemporary LRM capabilities—they demonstrate strong single-turn tool use (66.3% BFCLv3 average for 8B, 65.9% for 14B) but poor multi-turn performance (33.0% and 36.6%, respectively), making them ideal testbeds for the Lazy Reasoning hypothesis. For cross-architecture transfer experiments (Table 5), Llama3.1-8B and Qwen2.5-14B are used as recipient architectures for D-CORE trajectory distillation.
Metrics. The primary metric is accuracy (%), computed as the fraction of test queries for which the model's final tool calls exactly match the ground-truth tool calls. For BFCLv3, this is broken out by category (Live, Non-Live, Relevance, Irrelevance, Multi-Turn) and reported as an overall average. For τ-bench, retail and airline scores are reported separately and averaged. The "Avg" column in Table 3 represents the average of BFCLv3 overall and τ-bench overall scores. For the Lazy Reasoning analysis (Section 2.3), additional behavioral metrics are computed: thought categorization (decomposition, reflection, verification, deduction counts per rollout), Lazy Reasoning ratio (fraction of incorrect answers exceeding thresholds of >300 tokens AND >3 reflection keywords, as detailed in Appendix A.2.2), and decomposition success rate (Table 6: fraction of decomposition attempts where the number of generated subtasks matches the ground-truth tool call count).
Baselines. The paper compares against five categories of models, as shown in Table 1:
- Base LRMs without D-CORE: Qwen3-8B, Qwen3-14B, Qwen3-32B (the source models before D-CORE training)
- Proprietary models: Claude-3.7-Sonnet, DeepSeek-R1, o1, GPT-4o (reported as upper-bound references)
- SFT-based tool-use specialists: xLAM2-8B, xLAM2-32B, xLAM2-70B (Prabhakar et al., 2025)—the best-performing open-source tool-use models prior to D-CORE
- RL-only tool-use training: ToolRL-Qwen3-8B, ToolRL-Qwen3-14B (Qian et al., 2025)—GRPO applied directly to Qwen3 models without self-distillation, using the same reward function as D-CORE
- Ablation checkpoints: Qwen3-8B + self-distillation only (SD), Qwen3-8B + SD + standard GRPO, Qwen3-8B + SD + DA-GRPO at varying α (0.01, 0.1, 0.4, 1.0) and δ (0.5, 1.0) in Table 3
Generation budget / compute accounting. The paper does not report test-time compute budgets (number of rollouts, beam widths, or generation length caps) for evaluation—it appears to use single-pass generation with the trained models' default sampling configurations (temperature, top-p, etc. for DA-GRPO training are specified in Appendix A.6: temperature 1.0 during actor rollout, validation top-p 0.7). For training compute, the paper reports wall-clock times: self-distillation data generation takes 25 hours (8B) or 30 hours (14B) on a single A100 GPU for 40,000 samples; SFT takes 11 hours (8B) or 21 hours (14B) on 8×A100 GPUs for 3 epochs; DA-GRPO takes 11 hours (8B) or 17 hours (14B) on 8×A100 GPUs for 3 epochs. The "Lazy Reasoning" filtering in Appendix A.2.2 uses thresholds of >300 tokens and >3 reflection keywords as a behavioral metric, but these are not used as compute budgets for method comparison.
Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported. The paper evaluates on fixed test sets (BFCLv3 and τ-bench), and the only explicit data-splitting described is the 40,000 self-distillation samples vs. 5,000 RL samples. For out-of-distribution evaluation (Table 2), models are evaluated directly on τ²-Bench, ACEBench, and BFCLv4-Agentic without any held-out validation or hyperparameter tuning on these benchmarks—this serves as a zero-shot generalization test. The Lazy Reasoning analysis (Section 2.3) samples 20 rollouts per query and uses MATH-500 (Hendrycks et al., 2021) as a reference baseline for thought distribution comparison, but no error bars, confidence intervals, or statistical tests are reported for any result in the paper.

Main Quantitative Results

Lazy Reasoning Diagnosis and Characterization

The paper's first set of results establishes the existence and severity of Lazy Reasoning before introducing D-CORE. Figure 3(a), based on 20 rollouts per query from Qwen3-8B on BFCLv3 and MATH-500, shows that the distribution of thought categories (Decomposition, Reflection, Verification, Deduction) differs dramatically between task types: multi-turn BFCLv3 trajectories exhibit minimal task decomposition but excessive reflection, while single-turn and math trajectories show more balanced distributions with substantial decomposition. Figure 3(b) quantifies the consequence: in multi-turn BFCLv3 tasks, Lazy Reasoning (defined as >300 tokens with >3 reflection keywords) accounts for approximately 45% of incorrect answers from Qwen3-8B. In contrast, parallel and irrelevance tasks show much lower Lazy Reasoning ratios—the behavior is specifically concentrated in the multi-turn setting.

Figure 3(c) establishes that task complexity is a causal factor: by composing queries with increasing numbers of subtasks (1 to 4), performance on Qwen3-8B degrades monotonically, confirming "that decomposition complexity is a primary inducer of Lazy Reasoning." Figure 3(d) provides the key intervention evidence: manual task decomposition (providing explicit subtask breakdowns via prompting) transforms failure cases into successes. The exact accuracy numbers for Figure 3(d) are not reported in the text, but Appendix A.2.5 provides a case study showing that manual decomposition reduces reasoning token usage from 1,616 to 799 tokens (roughly 50% reduction) while converting an incorrect answer to a correct one.

Figures 8 and 9 in Appendix A.2.1 provide distributional analysis: on MATH tasks, correct and incorrect answers show clearly separated distributions of reasoning length and reflection count—longer reasoning with more reflection correlates with correctness (an "effective reasoning region" exists). On BFCLv3 multi-turn tasks, the distributions for correct and incorrect answers are nearly identical, indicating that "the model's reasoning provides no benefit for complex tool use"—the reasoning process is decorrelated from task success, which is the core symptom of Lazy Reasoning.

Main Benchmark Results (Table 1)

Table 1 reports accuracy on BFCLv3 (broken down by Live, Non-Live, Relevance, Irrelevance, Multi-Turn, and Average) and τ-bench (Retail, Airline, and Average). The headline findings:

D-CORE-8B achieves 77.7% BFCLv3 average accuracy, surpassing the previous best 8B model (xLAM2-8B at 72.0%) by 5.7 percentage points. The improvement over the base Qwen3-8B is +11.4% (from 66.3% to 77.7%). On τ-bench, D-CORE-8B achieves 47.6% average (vs. 29.0% for Qwen3-8B), a gain of +18.6 percentage points.

The gains are strongly concentrated in multi-turn scenarios: on BFCLv3 Multi-Turn, D-CORE-8B jumps from 33.0% (Qwen3-8B) to 63.8% — a +30.8 percentage point improvement. This is the largest absolute gain in any category. On BFCLv3 Irrelevance, performance is unchanged at 77.8%, and on BFCLv3 Live, the gain is modest (+3.7%). This confirms that D-CORE specifically addresses the multi-turn deficiency that motivated the work.

D-CORE-14B achieves 79.3% BFCLv3 average, establishing a new state-of-the-art overall. Critically, it outperforms xLAM2-70B (78.4%) despite being 5× smaller (14B vs. 70B parameters). On BFCLv3 Multi-Turn, D-CORE-14B achieves 67.4% vs. 75.0% for xLAM2-70B — the specialized SFT model maintains a lead on its strongest category, but D-CORE-14B is competitive while being dramatically more parameter-efficient. On τ-bench, D-CORE-14B achieves 51.3% average, the highest open-source score on this benchmark.

Comparison to RL-only training (ToolRL): ToolRL-Qwen3-8B, which applies GRPO directly to Qwen3-8B without self-distillation, achieves only 26.8% on BFCLv3 Multi-Turn — worse than the base Qwen3-8B at 33.0% (a -6.2 percentage point regression). On BFCLv3 average, ToolRL-8B is 65.9% vs. 66.3% for the base model (essentially flat). On τ-bench, ToolRL-8B achieves 31.5% vs. 29.0% — a modest improvement that is dwarfed by D-CORE's +18.6%. This comparison directly validates the paper's core claim: standard GRPO is insufficient for complex tool use because Lazy Reasoning patterns dominate the optimization landscape. Self-distillation is the necessary prerequisite.

Comparison to proprietary models: D-CORE-14B (79.3%) exceeds Claude-3.7-Sonnet (58.6%), DeepSeek-R1 (63.8%), and is competitive with o1 (67.8%) and GPT-4o (71.7%) on BFCLv3 average. On τ-bench overall, D-CORE-14B (51.3%) trails o1 (63.9%) but exceeds GPT-4o (52.9%). On τ-bench Airline specifically, D-CORE-14B achieves 46.0%, surpassing all proprietary models in Table 1 except o1 (54.2%). The paper notes this is a task "where the LRM handles complex refund evaluation and compensation decisions, requiring 4-5 subtasks per query when user intentions are unclear."

Out-of-Distribution Generalization Results (Table 2)

Table 2 reports zero-shot performance on three unseen benchmarks. The key finding is that D-CORE's improvements generalize, while SFT-based models (xLAM2) degrade sharply:

On ACEBench (stress test for generalization): D-CORE-8B achieves 77.9% normal and 78.7% special, substantially outperforming the base Qwen3-8B (71.4% normal, 75.3% special). In contrast, xLAM2-32B collapses to 0.0% normal and 24.7% special, and xLAM2-70B drops to 5.3% normal and 38.4% special — despite being 2.7-8.75× larger than D-CORE-8B. This is a striking demonstration that SFT-based tool-use training severely overfits, while D-CORE's strategy-based approach transfers. The paper notes this reveals a "critical limitation in standard fine-tuning: SFT models often degrade in generalization."

On τ²-Bench (dual-control environments): D-CORE-14B achieves 44.2% overall (53.5% retail, 44.1% airline, 34.9% telecom), compared to Qwen3-14B at 36.1% and xLAM2-70B at 43.4%. D-CORE-14B essentially ties the 70B SFT model on overall accuracy while being 5× smaller. Notably, the telecom domain was not in the training data—D-CORE-14B achieves 34.9% vs. 31.7% for Qwen3-14B and 29.3% for xLAM2-70B, demonstrating clean zero-shot generalization to an unseen domain.

On BFCLv4-Agentic (web-search and memory): D-CORE-14B achieves 76.9% overall (39.0% web-based, 26.5% memory) vs. Qwen3-14B at 68.0% (34.0%, 25.2%) and xLAM2-70B at 36.5% (13.0%, 17.6%). The xLAM2-70B collapse is severe on this benchmark (a 41.9 percentage point drop from its BFCLv3 score), while D-CORE maintains strong performance.

The consistent pattern across all three out-of-distribution benchmarks is that D-CORE improves over its base model (Qwen3) while xLAM2 regresses dramatically from its in-distribution peak. This supports the paper's claim that D-CORE teaches generalizable reasoning strategies rather than task-specific surface patterns.

Self-Distillation Scaling and Necessity (Table 4, Table 6)

Table 4 demonstrates that self-distillation effectiveness scales with data quantity and that it is a necessary prerequisite for successful RL:

Qwen3-8B base: BFCLv3 Multi-Turn 33.0%, τ-bench 29.0%
+GRPO (no self-distillation): BFCLv3 Multi-Turn 26.8% (-6.2), τ-bench 31.5% (+2.5) — RL hurts multi-turn performance
+Self-distillation with n=10,000: BFCLv3 Multi-Turn 51.5%, τ-bench 22.1%
+Self-distillation with n=20,000: BFCLv3 Multi-Turn 53.1%, τ-bench 37.8%
+Self-distillation with n=40,000: BFCLv3 Multi-Turn 57.5%, τ-bench 36.6%
+Self-distillation (n=40,000) + GRPO: BFCLv3 Multi-Turn 67.4% (+9.9 over SD alone), τ-bench 45.2% (+8.6)

The monotonic improvement with sample size (10k → 20k → 40k) on BFCLv3 Multi-Turn (51.5% → 53.1% → 57.5%) suggests that more self-distillation data could yield further gains. On τ-bench, the jump from 10k to 20k samples provides a large gain (22.1% → 37.8%), but 40k shows a slight regression to 36.6%, suggesting diminishing returns or noise in the RL phase on this benchmark. Critically, the gains from GRPO applied after self-distillation (+9.9% on BFCLv3 Multi-Turn, +8.6% on τ-bench) are only possible because self-distillation established a foundation of structured reasoning — GRPO applied directly to the base model produced negative or negligible improvements.

Table 6 quantifies decomposition success rates under different configurations of the self-distillation data generation phase (all using Qwen3-8B as the generator):

No reference trajectory, no few-shot examples: 73.8% success rate, τ-bench 20.3% after training
Ground-truth (GT) reference only: 89.1% success rate, τ-bench 33.8%
GT reference + few-shot: 93.2% success rate, τ-bench 37.1%
Pseudo-labels (PL) from Qwen3-Max + few-shot: 92.8% success rate, τ-bench 29.6%

The decomposition success rate strongly predicts downstream performance—going from 73.8% to 93.2% success rate nearly doubles τ-bench accuracy (20.3% → 37.1%). The pseudo-label configuration achieves nearly the same decomposition success rate as ground-truth (92.8% vs. 93.2%) but lower final τ-bench performance (29.6% vs. 37.1%), suggesting that pseudo-labels may have other quality differences (subtask descriptions, parameter accuracy) that affect downstream learning despite correct subtask counts. This is an important finding for practical deployment: pseudo-labels from a stronger model are viable but not fully substitutable for ground-truth references.

Cross-Architecture Trajectory Transfer (Table 5)

Table 5 tests whether D-CORE trajectories generated by Qwen3-8B can teach task decomposition to different model architectures:

DeepSeek-R1 → Llama3.1-8B (SFT on DS-R1 trajectories): BFCLv3 27.8%, τ-bench 19.0%
D-CORE (Qwen3-8B) → Llama3.1-8B: BFCLv3 63.7%, τ-bench 36.0%
DeepSeek-R1 → Qwen2.5-14B: BFCLv3 47.9%, τ-bench 18.2%
D-CORE (Qwen3-8B) → Qwen2.5-14B: BFCLv3 70.5%, τ-bench 41.5%

The D-CORE trajectories are dramatically more effective for teaching tool-use decomposition than DeepSeek-R1's general reasoning trajectories, despite DeepSeek-R1 being a state-of-the-art reasoning model. On Llama3.1-8B, D-CORE trajectories provide a 35.9 percentage point BFCLv3 advantage and 17.0 point τ-bench advantage. The cross-architecture transfer from Qwen3-8B to Qwen2.5-14B achieves 70.5% BFCLv3—competitive with directly trained D-CORE-8B (77.7%) despite the architecture mismatch. This confirms that D-CORE's trajectories encode a generalizable decomposition strategy independent of the generating model's architecture.

DA-GRPO vs. Standard GRPO (Table 3, Figure 6)

Table 3 ablates the reinforcement learning stage, comparing self-distillation alone to self-distillation + standard GRPO and self-distillation + DA-GRPO at various α values. All results are for D-CORE-8B:

Self-distillation only (SD): BFCLv3 82.5% (Live: 82.5, Non-Live: 86.5, Relevance: 66.7, Irrelevance: 89.7, Multi-Turn: 57.5), τ-bench 36.6% overall (Retail: 42.0, Airline: 31.2), Average (BFCLv3 + τ-bench mean): 46.2%
SD + standard GRPO: BFCLv3 75.6% (Multi-Turn: 67.4), τ-bench 45.2%, Average: 55.6% (+9.4 over SD)
SD + DA-GRPO (α=0.01, δ=0.5): Average 56.2%, with τ-bench Retail 52.5% (highest among all variants) but Airline 38.8%
SD + DA-GRPO (α=0.1, δ=0.5): Average 57.6% (the best), BFCLv3 82.3%, τ-bench 47.6% (Retail: 50.7, Airline: 44.4)
SD + DA-GRPO (α=0.4, δ=0.5): Average 55.5%, τ-bench Retail 54.6% (highest) but Airline drops to 36.8%
SD + DA-GRPO (α=1.0, δ=1.0): Average 54.0%, BFCLv3 drops to 76.4%

The non-monotonic relationship between α and overall performance (46.2% → 55.6% → 56.2% → 57.6% → 55.5% → 54.0%) validates the paper's claim that entropy-based advantages create a tradeoff: too little entropy (α=0.01, essentially standard GRPO with a tiny entropy bonus) provides limited diversity, while too much (α=1.0) overwhelms the standard reward signal. α=0.1 achieves the peak, though the difference between α=0.1 (57.6%) and α=0.01 (56.2%) is modest (1.4 percentage points on the Average metric).

Interestingly, standard GRPO after self-distillation (55.6% Average) still outperforms self-distillation alone (46.2%), despite the gradient collapse problem. This suggests that even weakened GRPO provides meaningful signal—perhaps because the reward variance hasn't fully collapsed to zero in all training groups, or because some residual variance remains from format/parameter-level differences even when tool-call accuracy is consistent. DA-GRPO provides an additional 1-2 percentage points on top of standard GRPO.

Figure 6 shows training dynamics: DA-GRPO with α=0.1 consistently achieves higher reward than standard GRPO throughout training, and reflection token counts increase substantially. At α=1.0, reflection tokens increase even more but reward drops below GRPO—the model is exploring but not exploiting effectively. This visualizes the "excessive entropy can confuse rewards" regime the paper describes.

Lazy Reasoning Mitigation (Figure 7)

Figure 7(b) shows that D-CORE dramatically reduces Lazy Reasoning. For the 8B model, errors caused by Lazy Reasoning in BFCLv3 Multi-Turn are reduced from 45% to 6% — a reduction of 39 percentage points. The Lazy Reasoning ratios for the D-CORE model on Multi-Turn and τ-bench tasks drop to levels comparable with Parallel and Irrelevance categories (which had low Lazy Reasoning rates even in the base model). This is the most direct validation of the paper's central claim: D-CORE specifically addresses the Lazy Reasoning phenomenon that motivated its design.

Figure 7(a) shows the corresponding behavioral distribution shift: self-distillation increases the proportion of Task Decomposition thoughts while reducing Reflection thoughts (compared to the base model's distribution in Figure 3a). DA-GRPO subsequently restores some Reflection proportion—the final D-CORE model has both more decomposition and moderate reflection, rather than the base model's reflection-heavy, decomposition-light pattern. This matches the paper's stated goal of balancing decomposition and reflection.

Ablation Studies and Robustness Checks

Self-distillation data quantity (Table 4): Self-distillation performance improves monotonically with training samples. BFCLv3 Multi-Turn accuracy rises from 51.5% at n=10,000 to 53.1% at n=20,000 to 57.5% at n=40,000. τ-bench shows a different pattern: 22.1% → 37.8% → 36.6%, with the jump from 10k to 20k providing the largest gain and a slight regression at 40k. This suggests τ-bench may have diminishing returns or that the 40k sample batch had slightly lower-quality trajectories. The monotonic improvement on BFCLv3 Multi-Turn indicates that scaling self-distillation data could yield further gains, though the τ-bench curve suggests this may not be universal across benchmarks.
Decomposition prompt configuration (Table 6): The critical factor for downstream performance is the decomposition success rate during data generation. Going from no references (73.8% success, 20.3% τ-bench) to ground-truth reference + few-shot (93.2% success, 37.1% τ-bench) nearly doubles downstream accuracy. The pseudo-label configuration (Qwen3-Max as weak teacher) achieves 92.8% decomposition success but only 29.6% τ-bench—a gap of 7.5 points vs. ground-truth despite nearly identical success rate. This implies that decomposition success rate is necessary but not sufficient; the quality of subtask descriptions or the correctness of generated tool calls within each subtask may differ between pseudo-label and ground-truth configurations.
DA-GRPO α hyperparameter (Table 3, Figure 6): The entropy scaling coefficient α exhibits a clear optimal range. α=0.1 maximizes the Average metric (57.6%). Lower α (0.01, 56.2%) slightly underperforms; higher α values degrade: 0.4 → 55.5%, 1.0 → 54.0%. Individual benchmarks show different optima—τ-bench Retail peaks at α=0.4 (54.6%), τ-bench Airline peaks at α=0.1 (44.4%), BFCLv3 peaks at α=0.1 with δ=0.5 (82.3%). This heterogeneity suggests that different task categories benefit from different entropy-reward balances, and the paper's selection of α=0.1 as the best overall represents an aggregate tradeoff. A difficulty-conditioned α (analogous to compute-optimal strategy selection in the reference paper) could potentially yield further gains.
DA-GRPO δ hyperparameter: Only two values are tested: δ=0.5 (for α ∈ {0.01, 0.1, 0.4}) and δ=1.0 (for α=1.0). No ablation of δ at fixed α is reported, making it impossible to assess the sensitivity to this bound. Given that δ caps the maximum entropy advantage, it likely interacts with α in determining the exploration-exploitation balance, but this interaction is not explored.
GRPO vs. DA-GRPO effect on reflection proportion (Figure 7a): The behavioral analysis confirms DA-GRPO's mechanism works as designed. Self-distillation increases Decomposition thoughts and reduces Reflection thoughts compared to the base model. Standard GRPO after self-distillation maintains this pattern. DA-GRPO restores some Reflection proportion without reducing Decomposition—the final D-CORE model occupies a middle ground in reflection frequency between the base model (excessive reflection, no decomposition) and the self-distilled model (good decomposition, suppressed reflection). This is a direct visualization of the "balance" D-CORE aims to achieve.
Cross-architecture transfer with DeepSeek-R1 baseline (Table 5): The comparison between D-CORE trajectories and DeepSeek-R1 trajectories as training data reveals that general reasoning quality does not translate to tool-use decomposition teaching. DeepSeek-R1 trajectories produce dramatically worse results (Llama3.1-8B: 27.8% vs. 63.7% BFCLv3) despite DeepSeek-R1 being a stronger reasoning model on math and coding. This ablation confirms that it is specifically the structured decomposition format of D-CORE trajectories—not just the reasoning quality—that drives the improvement.
Reward function component design (Equations 16-18): The paper uses a four-component reward (format + struct + key + value) inherited from ToolRL. No ablation of reward components is reported—it's not possible to determine whether all four components are necessary, whether simpler rewards (e.g., binary correct/incorrect) would suffice, or whether the partial credit from key and value matching is essential for RL convergence. Given that self-distillation establishes a strong initialization, it's plausible that even a binary reward would work in the DA-GRPO phase, but this is untested.
Negative result: ReST^EM revision training (Appendix K, mentioned in prior sections write-up but not detailed in this paper): Not applicable to this paper—the reference is from the prior analysis template. D-CORE does not use ReST^EM or iterative revision training. The closest negative result in this paper is the ToolRL baseline (Table 1, Table 4), which shows that standard GRPO without self-distillation hurts multi-turn performance, confirming that RL alone is insufficient.

Critical Assessment

Claim: "Lazy Reasoning" is the specific failure mode of LRMs in complex tool use, characterized by excessive reflection and absent task decomposition.

This claim is well-supported by the behavioral analysis in Section 2.3 and Appendix A.2. Figures 3(a) and 8-9 provide multi-dimensional evidence: thought category distributions, reasoning length distributions, and reflection frequency distributions all consistently show that multi-turn tool-use trajectories exhibit fundamentally different (and less productive) reasoning patterns than math or single-turn trajectories. The causal evidence—manual decomposition transforms failure to success (Figure 3d, Appendix A.2.5)—is compelling: the model can succeed when given structure, proving the latent capability exists and the autonomous reasoning strategy is the bottleneck.

However, several aspects of the Lazy Reasoning analysis warrant caution:

Threshold arbitrariness: The definition of Lazy Reasoning (>300 tokens AND >3 reflection keywords) is empirically motivated but not systematically justified. Different thresholds would produce different Lazy Reasoning ratios. The paper does not analyze sensitivity to these thresholds—would the 45% figure hold at >200 tokens and >2 reflections? At >500 tokens and >5 reflections? The qualitative conclusions likely hold under reasonable variations, but the specific numbers may be fragile.
Thought categorization methodology: The categorization of thoughts into Decomposition, Reflection, Verification, and Deduction (following Ning et al., 2025) relies on keyword matching or LLM-based classification (the exact method is not specified). If this classification is noisy, the distributional differences in Figure 3(a) could be partially artifactual. The paper does not report inter-annotator agreement, classification accuracy, or any validation of the thought categorization.
Correlation vs. causation for reflection: The paper treats excessive reflection as the cause of failure (the model wastes compute on loops), but it could equally be a symptom—the model reflects because it's confused, and confusion is caused by the absence of decomposition. The manual decomposition experiment (Figure 3d) shows that providing decomposition eliminates both the failure and (presumably) the excessive reflection, but it doesn't disentangle whether decomposition eliminates reflection or whether reflection was merely a correlate of the underlying planning deficit. This doesn't weaken the practical finding (decomposition helps) but matters for understanding why it helps.
Single model analysis: The Lazy Reasoning characterization is performed only on Qwen3-8B. The paper claims "all LRMs have Lazy Reasoning" (Appendix A.2.4) but provides evidence only from the Qwen3 family (8B and 32B in Figure 10). Testing on DeepSeek-R1, o1, or Claude would strengthen the universality claim but is absent.

Claim: Self-distillation can inject task decomposition capability without a stronger teacher, using only ground-truth references during data generation.

This claim is supported by Table 6, showing 93.2% decomposition success rate with ground-truth references and few-shot examples, and by the downstream performance gains in Table 4 (57.5% Multi-Turn from self-distillation alone vs. 33.0% base). The cross-architecture transfer in Table 5 provides additional evidence that the self-generated trajectories encode transferable decomposition strategies.

However, several qualifications apply:

Ground-truth dependence during generation: The method requires ground-truth reference trajectories $Y^*$ during the data generation phase. For the MATH benchmark (where answers are verifiable), this is reasonable; for arbitrary tool-use queries, ground-truth tool call sequences may be expensive to obtain. The pseudo-label experiment (92.8% success using Qwen3-Max) partially addresses this, but (a) it still requires a stronger model, contradicting the "no stronger teacher" framing, and (b) the downstream performance gap (29.6% vs. 37.1% τ-bench) is nontrivial. The claim of "eliminating the need for a stronger teacher" is therefore more accurately stated as "eliminating the need for a stronger teacher during training, though a stronger model may be required for data generation unless ground-truth references are available."
Decomposition prompt engineering: The decomposition success rates in Table 6 are obtained with carefully constructed prompts (Appendix A.3) that include system policy, tool definitions, conversation history, query, reference trajectory, and few-shot examples. It is unclear how sensitive the success rate is to prompt quality—would a less carefully engineered prompt produce substantially lower decomposition success, and how would that affect downstream performance? This is not ablated.
Single-domain evaluation: Self-distillation is tested only on tool use. The paper positions self-distillation as a general capability-elicitation method, but its effectiveness on other domains (math decomposition, code modularization, planning) is not demonstrated.

Claim: DA-GRPO prevents gradient collapse and restores reflective reasoning diversity after self-distillation.

This claim is supported by theoretical analysis (Theorems 3.1 and 3.2 with proofs in Appendix A.7) and empirical evidence (Figure 5a shows gradient collapse after self-distillation; Figure 6 shows DA-GRPO enables continued learning; Figure 7a shows restoration of reflection proportion). The α sweep in Table 3 confirms the expected non-monotonic relationship.

Qualifications and gaps:

Modest empirical margin: DA-GRPO (α=0.1) achieves 57.6% Average vs. 55.6% for standard GRPO—a gain of only 2.0 percentage points on the combined metric. While this is consistent and directionally correct, the practical significance of DA-GRPO over standard GRPO (which also improves over self-distillation alone) is modest. The primary gain comes from self-distillation (29.0% → 36.6% on τ-bench), not from the entropy-aware advantage modification (45.2% → 47.6%). The paper's framing emphasizes DA-GRPO as solving the gradient collapse problem, but standard GRPO apparently doesn't fully collapse—it still provides substantial gains (+8.6% on τ-bench, +9.9% on BFCLv3 Multi-Turn over self-distillation). This suggests the gradient collapse may be partial rather than complete in practice, and DA-GRPO provides a modest refinement rather than a critical fix.
No comparison to alternative diversity mechanisms: The paper does not compare DA-GRPO to other methods for maintaining diversity after SFT: standard entropy regularization (adding entropy bonus to reward), KL divergence tuning, resetting the reference policy, or simply training for more epochs with a lower learning rate. Without these comparisons, it's impossible to assess whether DA-GRPO's entropy-based advantage is superior to simpler alternatives.
Theorem 3.1's practical relevance: The theorem guarantees non-zero gradients when the policy is non-degenerate and importance ratios are non-zero. But in practice, gradients can be non-zero yet ineffective—the model could receive gradient signal that pushes it in unproductive directions (as seen with α=1.0). The theorem establishes that the method can learn, not that it learns well. The paper's empirical results show it does learn well at α=0.1, but the theorem itself doesn't predict the optimal α or guarantee improvement.
δ hyperparameter is under-explored: Only two values tested, always paired with specific α values. An interaction sweep (α × δ grid) would reveal whether the optimal δ depends on α and whether the current pairing is coincidentally good or robust.

Claim: D-CORE establishes new state-of-the-art results with 5× fewer parameters than prior 70B models.

This claim is quantitatively supported by Table 1: D-CORE-14B (79.3%) vs. xLAM2-70B (78.4%) on BFCLv3 average—a 0.9 percentage point margin with 5× fewer parameters. D-CORE-8B (77.7%) also exceeds xLAM2-8B (72.0%) by 5.7 points.

Important qualifications:

Benchmark coverage: The state-of-the-art claim applies specifically to BFCLv3 and τ-bench. On BFCLv3 Multi-Turn specifically, xLAM2-70B (75.0%) still outperforms D-CORE-14B (67.4%)—the parameter efficiency advantage is reversed on the category that motivated the work. D-CORE wins on aggregate by excelling on other categories (Live: 82.9 vs. 72.9, Relevance: 89.2 vs. 78.9).
Comparison to proprietary models: D-CORE-14B (79.3%) substantially outperforms Claude-3.7-Sonnet (58.6%) and DeepSeek-R1 (63.8%) on BFCLv3 average, but these models were not specifically trained for tool use. The comparison to GPT-4o (71.7%) and o1 (67.8%) is more relevant, and D-CORE's margin is moderate (7.6 and 11.5 points respectively). However, proprietary models have unknown tool-use training—they may be strong generalists that D-CORE's specialized training outperforms on this specific domain.
Training cost not compared to model scale: D-CORE-14B training requires self-distillation data generation (30 hours on 1×A100) + SFT (21 hours on 8×A100) + DA-GRPO (17 hours on 8×A100) = roughly 38 GPU-days. xLAM2-70B presumably requires substantially more pretraining compute but its fine-tuning cost is not reported. Without total FLOPs accounting, the parameter-efficiency claim is about model size at inference, not about total training cost.

Claim: D-CORE's improvements generalize out-of-distribution, while SFT-based models overfit.

This claim is convincingly supported by Table 2. The xLAM2 collapse on ACEBench (5.3% normal for the 70B model) is a genuinely striking negative result that highlights a critical weakness of SFT-only tool-use training. D-CORE's maintained performance (78.7% special, 77.9% normal for 8B) demonstrates meaningful generalization.

Qualifications:

xLAM2 is an SFT-only baseline, but D-CORE uses RL: The generalization comparison is between D-CORE (SFT + RL) and xLAM2 (SFT only). An SFT + standard GRPO baseline on the out-of-distribution benchmarks would clarify whether the generalization advantage comes from RL in general (which often improves robustness) or from D-CORE's specific self-distillation + DA-GRPO recipe. This comparison is absent.
Training data overlap: The paper uses "subsets of open-source datasets (ToolACE, APIGen, xLAM2)" for self-distillation. If D-CORE's training data overlaps with xLAM2's training data but is augmented with self-generated decomposition trajectories, the generalization comparison is slightly confounded—D-CORE may benefit from both the SFT patterns and the decomposition structure, while xLAM2 sees only the SFT patterns.
The benchmarks are still tool-use benchmarks: ACEBench, τ²-Bench, and BFCLv4-Agentic are out-of-distribution w.r.t. the training data but are still tool-use tasks. The generalization is within the tool-use domain. True cross-domain generalization (e.g., to math reasoning or code generation) is not tested, nor is it claimed.

What experiments would have strengthened the paper:

Difficulty-conditioned analysis: The paper does not break down performance by task difficulty (number of subtasks, number of turns, ambiguity of user intent). Understanding where D-CORE helps most (and where it doesn't) would clarify the conditions under which the method is most valuable and reveal whether there are hard problems that resist decomposition-based approaches.
Token efficiency analysis: The paper motivates D-CORE partially by the observation that LRMs "consume substantially more tokens for reasoning yet yield marginal performance gains." But D-CORE's own token consumption is not reported. Does the trained model use fewer reasoning tokens than the base model? More? If D-CORE-8B achieves 77.7% with 500 tokens per query while Qwen3-8B achieves 66.3% with 200 tokens, the accuracy gain comes with a latency cost that matters for deployment.
Scaling to larger models: D-CORE is tested at 8B and 14B. The trend from 8B to 14B is positive but modest (+1.6% BFCLv3 average). Testing at 32B or 70B would reveal whether the approach continues to scale or plateaus. If D-CORE-32B could match or exceed xLAM2-70B on all categories including Multi-Turn, the parameter-efficiency argument would be much stronger.
GRPO without self-distillation, but with more exploration: The paper shows that GRPO alone fails (ToolRL-8B: 26.8% Multi-Turn). But this GRPO uses the ToolRL reward function with standard hyperparameters. Would GRPO with higher temperature, more rollouts per query, or a curiosity bonus eventually discover decomposition? The paper's claim that "RL alone cannot converge" is supported but not proven—it's possible that substantially larger RL budgets would eventually work.
Comparison to SFT + standard entropy regularization: The paper's central RL innovation is the entropy-based advantage. Comparing DA-GRPO to GRPO with a standard entropy bonus in the reward (the most common alternative for maintaining diversity in policy gradient methods) would contextualize the contribution. If standard entropy regularization works nearly as well, DA-GRPO's advantage is incremental.
Error analysis by failure type: The paper shows that Lazy Reasoning decreases from 45% to 6% of errors (Figure 7b). But what are the remaining 94% of errors? Are they tool-call parameter errors despite correct decomposition? Are they failures in the execution phase rather than the planning phase? Understanding the residual failure modes would guide further improvements.

6. Limitations and Trade-offs

The Difficulty-Estimation Cost Is Unmeasured and Potentially Prohibitive

The assumption or constraint. The self-distillation stage requires computing ground-truth reference trajectories Y* for each training query — a correctness signal that drives the decomposition and verification pipeline (Algorithm 1, Lines 1-2, 20). For arbitrary tool-use queries in deployment, these reference trajectories are not available; obtaining them requires either human annotation, access to a verified execution environment with known-correct tool calls, or a stronger model that generates pseudo-labels (Table 6). The paper acknowledges this implicitly by testing pseudo-labels from Qwen3-Max, but the cost of generating those pseudo-labels — and the cost of running the self-distillation data generation pipeline itself (25 hours on a single A100 for 40k samples for the 8B model) — is treated as a one-time training expense and excluded from the efficiency framing.

The consequence. In a realistic deployment where reference trajectories or pseudo-labels must be acquired, the total cost of using D-CORE is: (1) running a stronger model or human annotation to generate decomposition guidance, (2) executing the four-phase self-distillation generation pipeline (decompose → generate per-subtask → compose → verify) for tens of thousands of queries, (3) SFT training on those composed trajectories, and (4) DA-GRPO training. If step (1) requires a strong proprietary model API, the cost scales linearly with dataset size and may exceed the compute cost of steps (2-4). If a stronger model is unavailable (the scenario D-CORE is designed for), the method degrades to the "no reference, no few-shot" configuration in Table 6, which achieves only 73.8% decomposition success rate and 20.3% τ-bench accuracy — barely above the base Qwen3-8B's 29.0%. The headline 77.7% BFCLv3 accuracy is therefore contingent on access to strong supervision during data generation, contradicting the paper's framing of "eliminating the need for a stronger teacher."

What evidence exists in the paper. Table 6 directly quantifies the degradation: removing ground-truth references and few-shot examples drops decomposition success rate from 93.2% to 73.8% and τ-bench from 37.1% to 20.3%. The pseudo-label configuration (Qwen3-Max as a stronger model) partially recovers to 92.8% success and 29.6% τ-bench, but this still requires a stronger model. The data generation costs are reported in Appendix A.6.1 (25 hours for 8B, 30 hours for 14B on a single A100) but are not amortized into any efficiency comparison — the paper compares final model accuracy against baselines without accounting for the cost of generating the training supervision.

Mitigation status. The paper acknowledges the challenge of obtaining ground-truth references and provides the pseudo-label experiment as a practical alternative (Table 6, last row). The authors state that pseudo-labels "bridge the gap between ideal supervision and practical applicability," but do not recommend this as the default configuration, do not report the API cost of generating pseudo-labels from Qwen3-Max, and do not ablate whether a smaller pseudo-label provider (e.g., Qwen3-14B used as a teacher for Qwen3-8B) would suffice. The limitation is flagged but not resolved — a practitioner reading the paper must assume access to either ground-truth references or a meaningfully stronger model for data generation, which narrows the set of deployment scenarios where D-CORE applies as described.

Hard Problems (High-Complexity Multi-Turn Interactions) Remain Largely Unsolved Despite Method Advances

The assumption or constraint. D-CORE is evaluated primarily on aggregate benchmark scores across all difficulty levels, without breaking down performance by task complexity within each benchmark. The paper's own motivating analysis (Figure 3c) shows that performance degrades as the number of subtasks increases, and the core claim is that D-CORE mitigates this degradation. However, the paper never reports how much of the residual error after D-CORE training comes from the hardest queries within each benchmark — those with 4+ subtasks, deeply ambiguous user intent, or long conversation histories.

The consequence. A practitioner deploying D-CORE for complex tool-use agents needs to know: does D-CORE-8B's 63.8% BFCLv3 Multi-Turn accuracy mean it handles 90% of 2-subtask queries correctly but fails on 80% of 4-subtask queries? Or does it achieve moderate accuracy uniformly across difficulty levels? These have very different deployment implications. If D-CORE primarily helps on moderately complex tasks (2-3 subtasks) while leaving high-complexity tasks (4+ subtasks, extensive conversation history, ambiguous intent) at near-baseline accuracy, the method may not be sufficient for production agents that encounter precisely those difficult scenarios. The paper's own analogy to the test-time compute scaling paper — where bin 5 (hardest) problems showed near-zero improvement regardless of compute — suggests that difficulty-dependent analysis is critical for understanding capability boundaries, but no such analysis is presented.

What evidence exists in the paper. The paper does not report any difficulty-stratified results. The motivating analysis in Figure 3 shows that Lazy Reasoning is concentrated in multi-turn tasks and that composed subtask complexity degrades performance (Figure 3c), but the D-CORE evaluation in Tables 1-5 reports only aggregate metrics per benchmark category. The BFCLv3 Multi-Turn category itself contains queries of varying complexity, and the τ-bench tasks span different interaction lengths, but no subsampling by difficulty is performed. The only indirect evidence comes from the Lazy Reasoning reduction in Figure 7(b): errors caused by Lazy Reasoning drop from 45% to 6% in Multi-Turn. But this leaves 94% of errors unexplained — they could be concentrated in a subset of very difficult queries where even decomposition doesn't help, or distributed uniformly.

Mitigation status. Not addressed. The paper does not acknowledge the lack of difficulty-stratified analysis as a limitation, does not suggest it as future work, and does not define difficulty metrics that could be used for such analysis. This is a notable gap given that the paper's central motivation — Lazy Reasoning — is itself a difficulty-dependent phenomenon (more common in multi-turn than single-turn, Figure 3b), making it natural to ask whether D-CORE's effectiveness is similarly difficulty-dependent. Future work on difficulty-conditioned decomposition strategies (e.g., investing more self-distillation data on high-complexity queries) could build on such an analysis, but the paper provides no foundation for it.

Latency Overhead from Sequential Subtask Execution Is Ignored

The assumption or constraint. The self-distillation procedure teaches the model to decompose queries and execute subtasks sequentially when dependencies exist (Algorithm 1, Lines 3-10). At inference time, the trained D-CORE model presumably also generates reasoning in a sequential, subtask-by-subtask manner — first reasoning about subtask 1, calling its tool, processing the result, then reasoning about subtask 2, etc. The paper measures only accuracy and uses "generations" or wall-clock training time as the compute metric, but never measures or reports inference latency — the wall-clock time from query to final answer.

The consequence. Sequential subtask execution is inherently serial: subtask i+1 cannot begin until subtask i's tool call completes and returns results. If each tool call takes 1-3 seconds (realistic for API calls to external services), a 4-subtask query adds 4-12 seconds of mandatory tool-call latency on top of model inference time. In contrast, a non-decomposition approach (the base Qwen3 model) might attempt all tool calls in a single generation step, achieving lower latency at the cost of lower accuracy. The paper does not characterize this accuracy-latency tradeoff. For latency-sensitive deployments (customer-facing chatbots, real-time agent systems), a model that achieves 63.8% multi-turn accuracy with 10-second average latency may be less desirable than one achieving 33.0% accuracy with 2-second latency, especially if the accuracy difference is concentrated on queries that users could rephrase. Without latency data, practitioners cannot make this tradeoff decision.

What evidence exists in the paper. The paper provides a suggestive case study in Appendix A.2.5: manual decomposition of a single query into 3 subtasks reduces reasoning tokens from 1,616 to 799 (a 50% reduction), but this measures only reasoning token count, not total latency including tool execution. Training compute times are reported (25 hours for data generation, 11 hours for SFT, 11 hours for DA-GRPO on 8B), but inference latency is never mentioned. The BFCLv3 and τ-bench evaluations are accuracy-only; neither benchmark reports time-to-completion for model outputs. The paper also does not report the distribution of subtask counts in the training data or in the model's outputs, which would allow a rough latency estimate (e.g., if the average decomposed query has 3.2 subtasks, expected latency scales with that count).

Mitigation status. Not addressed and not acknowledged. The paper's framing emphasizes accuracy and compute efficiency (parameter count, training time) but entirely omits the latency dimension. This is a significant practical blind spot because the sequential execution pattern that D-CORE incentivizes — while beneficial for accuracy — is fundamentally at odds with low-latency deployment. A future study of the accuracy-latency Pareto frontier (how much accuracy is gained per unit of added latency) would be essential for production decision-making but is absent from this work.

Experiments Are Confined to Qwen3 Models on Tool-Use Benchmarks with No Cross-Domain Validation

The assumption or constraint. All main experiments use Qwen3-8B and Qwen3-14B as base models, and all evaluation benchmarks (BFCLv3, τ-bench, ACEBench, τ²-Bench, BFCLv4-Agentic) are tool-use tasks. The out-of-distribution claims (Table 2) refer to generalization across different tool-use domains (retail → airline → telecom → web-search), not across fundamentally different task types such as mathematical reasoning, code generation, or open-ended dialogue. The paper explicitly states in Section 6 that "future work will extend this framework to multimodal models," acknowledging the current scope limitation.

The consequence. It is unclear whether Lazy Reasoning is a problem specific to tool use or a more general phenomenon in LRM reasoning, and correspondingly whether D-CORE's self-distillation + DA-GRPO recipe would transfer to other domains. If Lazy Reasoning is caused by the specific structure of tool-use tasks (multiple discrete actions with verifiable outcomes), D-CORE's task decomposition approach might not help on tasks like mathematical proof generation (where subtask boundaries are ambiguous) or creative writing (where "correctness" is subjective). Conversely, if Lazy Reasoning is a general failure mode of current LRM training, the method might broadly apply. The paper provides no evidence either way.

Furthermore, the model-family specificity matters. Qwen3 models use a particular reasoning format ( tagged blocks), a particular RL training history (Qwen3's proprietary training recipe), and a particular tool-calling paradigm. If D-CORE's success depends on these model-specific characteristics — for example, the tokens the model was already trained to generate during thinking — the method may not transfer to other LRM families (DeepSeek-R1 uses a different reasoning format, Claude uses a different training paradigm entirely). The cross-architecture transfer experiment in Table 5 shows that D-CORE trajectories work for Llama3.1 and Qwen2.5, but these are instruction-tuned LLMs, not LRMs with established reasoning patterns — the experiment tests trajectory quality, not the full D-CORE training pipeline transferability.

What evidence exists in the paper. The cross-architecture experiment (Table 5) tests only the self-distillation trajectory quality (SFT on D-CORE trajectories), not whether DA-GRPO would work on non-Qwen3 architectures. The out-of-distribution benchmarks (Table 2) test domain generalization within tool use, not task-type generalization. No math, code, or reasoning benchmarks are evaluated. The paper uses MATH-500 only as a reference distribution for thought categorization (Section 2.3, Figure 3a), not as an evaluation benchmark for D-CORE.

Mitigation status. The paper acknowledges the model-family limitation implicitly by stating future work will extend to multimodal models (Section 6), but does not explicitly flag the single-model-family evaluation as a limitation. The cross-domain limitation is not discussed. A practitioner considering D-CORE for a non-tool-use reasoning task or a non-Qwen3 model has no guidance on expected transferability, which significantly narrows the method's demonstrated applicability.

DA-GRPO Provides Only Modest Gains Over Standard GRPO After Self-Distillation

The assumption or constraint. The paper positions DA-GRPO as solving the gradient collapse problem that prevents standard GRPO from working after self-distillation (Section 3.2, Figures 5a, 12-13). The claimed mechanism is that self-distillation homogenizes the model's outputs, causing reward variance (and thus GRPO advantages) to approach zero. However, the empirical results show that standard GRPO actually works reasonably well after self-distillation: it improves the Average metric from 46.2% (self-distillation only) to 55.6% — a gain of 9.4 percentage points (Table 3). DA-GRPO at α=0.1 further improves this to 57.6%, a gain of only 2.0 additional percentage points.

The consequence. The practical value of DA-GRPO over standard GRPO depends on whether the 2.0 percentage point improvement (on the Average metric) justifies the additional complexity of computing per-token entropy, tuning two new hyperparameters (α and δ), and managing the theoretical risk of entropy over-optimization (as demonstrated by α=1.0 causing performance degradation). For many deployment scenarios, standard GRPO after self-distillation — which requires no additional infrastructure beyond the existing GRPO implementation — may be good enough, and the marginal gain from DA-GRPO may not warrant the engineering investment. The paper's framing emphasizes DA-GRPO as solving a critical failure mode (gradient collapse), but the empirical evidence suggests the collapse is partial rather than complete — standard GRPO still learns, just slightly less efficiently.

Additionally, the paper does not compare DA-GRPO to simpler alternatives for addressing post-SFT gradient collapse: standard entropy regularization (adding entropy bonus to the reward, a one-line code change in most RL frameworks), adjusting the KL penalty coefficient, resetting the reference policy, or simply training standard GRPO for more steps with a lower learning rate. Without these comparisons, it's unknown whether DA-GRPO's entropy-based advantage formulation is the best solution or merely one of several viable approaches, and whether the 2.0 percentage point gain over standard GRPO could be matched by simpler methods.

What evidence exists in the paper. Table 3 provides the direct comparison: self-distillation (46.2% Average) → standard GRPO (+9.4, to 55.6%) → DA-GRPO α=0.1 (+2.0 more, to 57.6%). The gap is consistent across individual benchmarks but modest: on BFCLv3, standard GRPO achieves 67.4% Multi-Turn vs. DA-GRPO's 63.8% (standard GRPO is actually better on this metric); on τ-bench, standard GRPO achieves 45.2% vs. DA-GRPO's 47.6%. Figure 6 shows that DA-GRPO with α=0.1 achieves higher reward and more reflection tokens than standard GRPO throughout training, but the final performance gap is small. No comparison to standard entropy regularization or other diversity mechanisms is reported.

Mitigation status. Not addressed. The paper does not discuss the modest empirical margin between DA-GRPO and standard GRPO, does not compare to alternative diversity mechanisms, and does not conduct a cost-benefit analysis of the additional complexity. The theoretical analysis (Theorems 3.1 and 3.2) establishes that DA-GRPO prevents gradient collapse, but the practical significance of this prevention — given that collapse is apparently partial — is not critically examined. A practitioner reading the paper might reasonably conclude that self-distillation is the essential contribution (providing +17.2 percentage points over the base model on the Average metric) while DA-GRPO is an incremental refinement, a framing the paper does not adopt.

Self-Distillation Training Data Generation Uses Ground-Truth Verification That Requires a Correctness Oracle

The assumption or constraint. The self-distillation pipeline (Algorithm 1, line 20) discards composed trajectories that fail verification against ground-truth reference trajectories Y*. This verification step — "Verify(Ŷ, Y*)" — ensures the SFT training data contains only correct demonstrations. The verification requires comparing the composed trajectory's tool calls and execution results against Y*, which itself must be a known-correct sequence of tool calls solving the query. For the experiments in the paper, Y* comes from the open-source tool-use datasets (ToolACE, APIGen, xLAM2) plus custom agent trajectories — these datasets already contain ground-truth tool calls.

The consequence. In any deployment scenario where new tool-use queries arise that are not covered by existing datasets with ground-truth annotations, the self-distillation pipeline cannot generate verified training data. The model could be prompted to decompose novel queries and generate trajectories, but without Y* to verify against, incorrect or hallucinated trajectories would enter the SFT training set, potentially teaching the model wrong decomposition patterns or incorrect tool calls. This is the standard "garbage in, garbage out" problem for self-supervised data generation: the model generates its own training data, but if some of that data is wrong and there's no oracle to filter it, the SFT stage will reinforce errors.

The paper does not explore or even mention what happens when the verification step is removed — would the self-distillation pipeline still work if all generated trajectories (including incorrect ones) were used for SFT? Would performance degrade gracefully or collapse? This is the scenario that would apply in most real-world deployments where new APIs or task domains are introduced and ground-truth trajectories don't exist. Without this analysis, the method's applicability is restricted to domains with existing labeled tool-use data.

What evidence exists in the paper. The paper does not report any experiments without the verification step. The decomposition success rates in Table 6 represent the fraction of queries where the model produces the correct number of subtasks, but even a query with the correct subtask count could have incorrect subtask descriptions, wrong tool calls, or parameter errors — the verification step catches all of these. No ablation of verification is performed. The pseudo-label experiment (Table 6, last row) replaces ground-truth Y* with pseudo-labels from Qwen3-Max, but still uses those pseudo-labels for verification — it replaces the oracle source, not the oracle requirement.

Mitigation status. Not addressed or acknowledged. The paper treats the availability of ground-truth reference trajectories as a given for the training datasets (subsets of ToolACE, APIGen, xLAM2) and does not discuss what happens when labeled data is unavailable. This is a significant practical limitation because it means D-CORE is fundamentally a method for improving performance on existing labeled tool-use data, not a method for bootstrapping tool-use capability from unlabeled queries. Extending D-CORE to work without verification — perhaps using the PRM's confidence, ensemble agreement, or execution-based feedback as surrogate correctness signals — is an open problem that the paper does not address.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper shifts the diagnosis of LRM failure in complex tool use from a generic "reasoning deficiency" to a specific, diagnosable behavioral pathology: Lazy Reasoning — the systematic substitution of structural task decomposition with unproductive reflection cycles. This reframing matters because it changes both what the field measures and what it builds. Prior work treated multi-turn tool-use failures as a matter of insufficient data, larger models, or stronger RL, with evaluation focused exclusively on aggregate accuracy. D-CORE's behavioral analysis framework (thought categorization into decomposition, reflection, verification, deduction; Lazy Reasoning ratio quantification; reward variance collapse diagnosis) introduces a set of intermediate behavioral metrics that sit between training objectives and final accuracy. Practitioners can now ask: "Is my model failing because it can't decompose tasks, or because it decomposes incorrectly? Does its reasoning process actually correlate with correctness, or are the reasoning tokens wasted?" These questions were not systematically askable before.

The reconciliation the paper achieves is significant but domain-specific. The tool-use literature contained a contradiction: single-turn LRM performance was strong and improving (ToolRL, Nemotron-N1 confirming RL helps), yet multi-turn performance was stagnant or regressing (ToolRL-8B dropping from 33.0% to 26.8% on BFCLv3 Multi-Turn, Table 1). Explanations ranged from "RL doesn't work for tool use" to "multi-turn is fundamentally harder," but neither was explanatory. D-CORE's behavioral analysis resolves this: RL works fine when the task structure enables the model to discover effective reasoning patterns (single-turn, math), but fails when the optimization landscape is dominated by an easier-to-discover-but-ineffective strategy (reflection loops instead of decomposition). The contradiction wasn't about RL's effectiveness — it was about which behavioral strategy the RL process converged to, which depended on the task structure. This reframes the problem from "how do we scale RL for tool use?" to "how do we ensure RL converges to the right reasoning strategy?"

On the methodological side, D-CORE establishes self-distillation with generation-time correctness scaffolding as a viable alternative to stronger-teacher distillation for capability elicitation. This is not a paradigm shift — it's an incremental but practically important expansion of the training toolbox. The key insight is that a model can generate training data demonstrating behavior X when provided with structural guidance (ground-truth references, few-shot examples) even if it cannot produce X autonomously, and that SFT on this data transfers the prompted behavior to autonomous generation. This "scaffolded self-distillation" pattern could apply to any domain where (a) the desired reasoning pattern is latent but not spontaneously expressed, (b) a correctness signal exists to guide generation. The paper does not claim universality — it demonstrates the pattern for tool-use decomposition specifically — but the template is clear and replicable.

Research directions that become more attractive:

Behavioral diagnostics for LRM reasoning: The paper's thought categorization and Lazy Reasoning ratio metrics provide a template for diagnosing what specific cognitive behaviors an LRM is deploying (or failing to deploy) on a given task. Extending this to other domains — code generation (is the model doing top-down design or iterative patching?), mathematical reasoning (forward chaining vs. proof-by-contradiction search?), multi-hop QA (information gathering vs. guessing?) — could produce similar "lazy" behavior patterns that suggest targeted interventions.
Difficulty-conditioned decomposition strategies: The paper shows that Lazy Reasoning is concentrated in multi-turn tasks (Figure 3b) and that composed-subtask complexity degrades performance (Figure 3c), but never breaks down D-CORE's performance by task difficulty. A difficulty-conditioned variant — using simpler strategies for easy queries and reserving full decomposition for complex ones, analogous to compute-optimal test-time scaling — could improve efficiency. This requires difficulty estimation, which the paper does not address.
Self-distillation without ground-truth verification: The paper's most significant unaddressed limitation is the dependence on ground-truth reference trajectories for verifying self-generated training data. Research into alternative verification signals — execution-based feedback (run the tool calls and check results), ensemble agreement (multiple decomposition attempts must converge), or learned verifiers (a PRM trained on tool-call correctness) — would determine whether self-distillation can operate in truly unsupervised settings.

Research directions that become less attractive:

Pure RL from scratch for complex planning tasks: The ToolRL baseline (Table 1, Table 4) provides strong negative evidence that standard GRPO with outcome rewards cannot discover structured decomposition in multi-turn tool use — it actually regresses performance. While larger RL budgets or different algorithms might eventually work, the paper's demonstration that explicit structural injection (self-distillation) is both effective and efficient suggests that hybrid SFT+RL approaches are more promising than pure RL discovery.
Scaling model size as a solution to tool-use complexity: The xLAM2-70B results (78.4% BFCLv3, but collapsed to 5.3% on ACEBench normal, Table 2) show that scaling parameters without improving reasoning strategy produces brittle models that overfit to training distributions. D-CORE-8B achieving 77.7% with 8.75× fewer parameters suggests that reasoning strategy quality — not parameter count — is the binding constraint for complex tool use. Research investments in larger tool-use SFT models face diminishing returns unless they also address generalization.

Follow-Up Research This Work Enables

Difficulty-stratified evaluation of D-CORE to identify capability boundaries. The paper never reports performance broken down by task complexity within benchmarks — number of subtasks, conversation turn count, ambiguity of user intent. D-CORE-8B's 63.8% BFCLv3 Multi-Turn accuracy could mean 90% on 2-subtask queries and 10% on 4-subtask queries, or uniform 60-65% across all difficulties. A follow-up study would annotate BFCLv3 and τ-bench queries with subtask count and interaction complexity, then plot D-CORE accuracy against these difficulty metrics. The prediction: D-CORE helps most on moderate-complexity queries (2-3 subtasks) where decomposition is non-trivial but within the model's planning horizon, and least on very high-complexity queries (4+ subtasks, long conversation histories) where decomposition alone is insufficient. This would establish the method's capability ceiling and identify what needs to improve for truly hard queries — better decomposition? Better execution tracking? Longer planning horizons?

Comparison of DA-GRPO to standard entropy regularization and other diversity mechanisms. The paper's headline RL contribution is the entropy-based advantage function, but it never compares this to the most obvious alternative: adding an entropy bonus to the reward (standard in policy gradient methods). A systematic comparison of DA-GRPO (α=0.1) vs. GRPO with entropy-regularized reward vs. GRPO with temperature annealing vs. GRPO with reference-policy resets would contextualize the contribution. The experiment: take the self-distilled Qwen3-8B checkpoint, apply each diversity method with hyperparameter sweeps, and measure (a) final accuracy on BFCLv3 Multi-Turn and τ-bench, (b) reflection token count, (c) training stability (reward variance over time). If standard entropy regularization matches DA-GRPO's performance, the contribution is primarily the diagnostic framework rather than the specific algorithm.

Self-distillation without any ground-truth or pseudo-label supervision. The paper demonstrates self-distillation with ground-truth references (93.2% decomposition success) and with pseudo-labels from a stronger model (92.8% success), but the "no reference, no few-shot" configuration achieves only 73.8% success and 20.3% τ-bench (Table 6). A critical follow-up would explore whether execution-based verification — running the generated tool calls and checking whether outputs satisfy constraints — can replace ground-truth comparison. For each candidate decomposition trajectory, execute the tool calls in a sandbox environment and check whether the final state matches the query's requirements. Use successful executions as verified training data, discarding failed ones. Measure whether this execution-filtered self-distillation approaches the performance of ground-truth-verified self-distillation. This would determine whether D-CORE can operate in genuinely unsupervised settings (new APIs, no labeled data), which is the practical scenario for most deployments.

Cross-domain Lazy Reasoning diagnosis and remediation. The paper identifies Lazy Reasoning as a tool-use phenomenon and demonstrates D-CORE only on tool-use benchmarks. The thought categorization framework (decomposition, reflection, verification, deduction) and Lazy Reasoning ratio metric could be applied to other reasoning domains to test whether similar behavioral pathologies exist. Specific experiments: sample 20 rollouts from Qwen3-8B on (a) Codeforces programming problems (does the model plan a solution structure or iteratively patch?), (b) multi-hop question answering (does it decompose into sub-questions or guess-and-check?), (c) legal or medical reasoning (does it identify sub-issues or produce verbose hedging?). If Lazy Reasoning patterns appear in other domains, the self-distillation template could be adapted: for code, decompose into function stubs before generating implementations; for QA, decompose into sub-questions with information-gathering steps; for professional reasoning, decompose into issue-spotting and rule-application subtasks. This would test whether D-CORE is a point solution for tool use or an instance of a general principle.

Latency-aware decomposition optimization. The paper ignores inference latency, but sequential subtask execution introduces unavoidable serial delays from tool calls. A follow-up would measure the accuracy-latency Pareto frontier for D-CORE models: for each query, record (a) whether the model produces a decomposition into N subtasks, (b) wall-clock time to completion (model inference + tool execution), (c) correctness. Plot accuracy vs. latency at different decoding temperatures and with different constraints (e.g., limit decomposition depth, allow parallel subtask batching). The key question: can D-CORE be tuned to match the base model's latency while retaining most of the accuracy gain? One approach: train a lightweight classifier that predicts whether a query requires decomposition (difficult multi-turn) or can be handled with direct generation (simple single-turn), routing accordingly. This would address the deployment reality that latency matters as much as accuracy for interactive agents.

Scaling D-CORE to larger models and longer planning horizons. D-CORE is demonstrated at 8B and 14B. The trend from 8B to 14B is positive but the gains are modest (+1.6% BFCLv3 average, +3.7% τ-bench, Table 1). Does this continue to 32B or 70B? And more importantly: does the decomposition capability scale to queries requiring 5+ subtasks with nested dependencies? Current BFCLv3 Multi-Turn queries likely average 2-3 turns; custom-constructed queries with 5-10 sequential steps would stress-test the decomposition horizon. Train D-CORE-32B on the existing 40k dataset plus an additional 10k high-complexity queries (synthetically composed from simpler ones, following the logic of Figure 3c). Measure whether the larger model can decompose and execute longer chains without forgetting intermediate state, and whether DA-GRPO's entropy mechanism works at larger scale or requires re-tuning.

Practical Applications and Downstream Use Cases

Customer service automation with multi-step backend operations. The τ-bench tasks — airline refunds requiring "complex refund evaluation and compensation decisions, requiring 4-5 subtasks per query when user intentions are unclear" (Section 4.2) — directly model real customer service workflows. D-CORE-14B's 46.0% τ-bench Airline accuracy (highest among open-source models, Table 1) represents a substantial improvement over the base Qwen3-14B's 25.6%. For an airline or e-commerce platform handling thousands of automated agent interactions daily, a 20.4 percentage point improvement in correctly resolved queries (from 25.6% to 46.0%) translates to fewer escalations to human agents, lower operational costs, and faster resolution times. The generalization evidence (Table 2: 34.9% on τ²-Bench telecom, an unseen domain) suggests the method transfers to new service domains without retraining, enabling deployment across multiple product lines from a single model.

Enterprise API orchestration with evolving tool landscapes. BFCLv4-Agentic (Table 2) introduces web-search and memory scenarios that were not in training. D-CORE-8B achieves 36.0% web-based accuracy vs. 16.0% for the base model — a 2.25× improvement on an unseen tool domain. For enterprises whose internal API landscape changes frequently (new microservices, deprecated endpoints, evolving parameter schemas), the generalization advantage over SFT-based models (xLAM2-70B drops to 13.0% on the same task) is critical. A model that maintains performance when tools change, without requiring retraining on new API schemas, reduces the maintenance burden of keeping AI agents synchronized with backend infrastructure. The decomposition strategy — "identify what needs to be done, then figure out which tools to use" — is inherently more robust to tool changes than memorizing "when you see pattern X, call function Y."

Self-improving data generation pipelines for tool-use training. The cross-architecture transfer results (Table 5) show that D-CORE trajectories generated by Qwen3-8B can train entirely different architectures (Llama3.1-8B: 63.7% BFCLv3, Qwen2.5-14B: 70.5%). This has direct implications for data flywheel systems: deploy D-CORE to generate high-quality decomposition trajectories on new queries, verify them against execution outcomes, and use them to continually fine-tune the base model. Unlike stronger-teacher distillation (which requires maintaining and paying for a proprietary model API), self-distillation uses the same model for generation and training, creating a closed self-improvement loop. The 38 GPU-days for D-CORE training (Appendix A.6: 25h generation + 11h SFT + 11h DA-GRPO on 8×A100) amortized over thousands of subsequent queries is modest for production-scale systems.

When to Prefer This Method

The paper positions D-CORE against two alternative paradigms — SFT-only tool-use training (xLAM2-style) and RL-only reasoning optimization (ToolRL-style) — in the context of complex multi-turn scenarios. The decision rule that emerges from the results:

Prefer D-CORE when:

The deployment scenario includes multi-turn tool interactions where maintaining state across turns, reconciling ambiguous user intent, and coordinating multiple tool calls is required. (Single-turn-only deployments can use simpler SFT or RL approaches, since Lazy Reasoning is concentrated in multi-turn tasks — Figure 3b.)
Out-of-distribution generalization matters — the tool landscape will change (new APIs, new domains) or the query distribution will shift over time. D-CORE's strategy-based approach (decompose-then-execute) transfers to unseen domains (Table 2: 34.9% telecom on τ²-Bench), while SFT-based models collapse (xLAM2-70B: 5.3% on ACEBench normal).
A labeled tool-use dataset with ground-truth trajectories exists (ToolACE, APIGen, xLAM2, or custom agent trajectories), or a somewhat stronger model is available to generate pseudo-labels for novel queries (Table 6: Qwen3-Max pseudo-labels achieve 92.8% decomposition success). Without either, the self-distillation verification step cannot filter incorrect trajectories, and performance degrades sharply.

Prefer SFT-only tool-use training (xLAM2-style) when:

The deployment scenario is single-turn and in-distribution. xLAM2-70B achieves 75.0% on BFCLv3 Multi-Turn (Table 1) vs. D-CORE-14B's 67.4% — the specialized SFT model maintains an edge on its training distribution for the task category that motivated D-CORE. If the query distribution is static and well-represented in training data, SFT-only training is simpler and can achieve higher in-distribution accuracy.
Inference latency is critical and any sequential dependency is unacceptable. The paper does not report latency, but the sequential subtask execution pattern D-CORE teaches introduces serial delays from tool calls that parallel-generation approaches avoid.
The training budget does not permit RL. D-CORE requires both SFT and DA-GRPO stages; the SFT-only portion (self-distillation alone) achieves 57.5% BFCLv3 Multi-Turn (Table 4), which is substantially above the base model but below the full D-CORE pipeline (63.8%). If compute for RL is unavailable, self-distillation SFT still provides gains but leaves performance on the table.

Prefer RL-only tool-use training (ToolRL-style) when:

The task is single-turn with clear correctness signals. ToolRL-8B achieves 82.4% BFCLv3 Live and 88.9% Non-Live (Table 1) — very strong single-turn performance without the complexity of self-distillation. If multi-turn performance is not required, the overhead of D-CORE's two-stage pipeline may not be justified.
The model's base reasoning strategy already includes decomposition. If future LRM training recipes produce models that naturally decompose tasks (rather than defaulting to reflection loops), the self-distillation injection step may become unnecessary. D-CORE's value is specifically in correcting the Lazy Reasoning behavioral pathology — if the pathology is absent, simpler RL may suffice.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

Search-R1: Training LLMs to Reason and Leverage Search Engines with Reinforcement Learning2025· training-methods← LLM-judged similar
- MindSearch: Mimicking Human Minds Elicits Deep AI Searcher2024· agents← LLM-judged similar
- Stream of Search (SoS): Learning to Search in Language2024· training-methods← LLM-judged similar
- ReST meets ReAct: Self-Improvement for Multi-Step Reasoning LLM Agent2023· agents← LLM-judged similar
- Training and Inference Efficiency of Encoder-Decoder Speech Models2025· training-methods← in-domain predecessor
- Training LLMs for Divide-and-Conquer Reasoning Elevates Test-Time Scalability2026· training-methods← similar topic
- TruthRL: Incentivizing Truthful LLMs via Reinforcement Learning2025· training-methods← similar topic
- Training Language Models to Self-Correct via Reinforcement Learning2024· training-methods← similar topic
Decouple Searching from Training: Scaling Data Mixing via Model Merging for Large Language Model Pre-training2026· training-methods← in-domain predecessor
- DaMo: Data Mixing Optimizer in Fine-tuning Multimodal LLMs for Mobile Phone Agents2025· training-methods← LLM-judged similar
- BiMix: A Bivariate Data Mixing Law for Language Model Pretraining2024· pretraining← LLM-judged similar
- Golden Goose: A Simple Trick to Synthesize Unlimited RLVR Tasks from Unverifiable Internet Text2026· training-methods← in-domain predecessor
ScaleEnv: Scaling Environment Synthesis from Scratch for Generalist Interactive Tool-Use Agent Training2026· agents← topic thread
- Towards General Agentic Intelligence via Environment Scaling2025· agents← LLM-judged similar
- AgentCPM-Report: Interleaving Drafting and Deepening for Open-Ended Deep Research2026· agents← in-domain predecessor
- WebWorld: A Large-Scale World Model for Web Agent Training2026· agents← similar topic
- Unify-Agent: A Unified Multimodal Agent for World-Grounded Image Synthesis2026· agents← similar topic
- SIMA 2: A Generalist Embodied Agent for Virtual Worlds2025· agents← similar topic
Does Your Reasoning Model Implicitly Know When to Stop Thinking?2026· inference-optimization← topic thread
- LIMO: Less is More for Reasoning2025· reasoning← LLM-judged similar
- DFlash: Block Diffusion for Flash Speculative Decoding2026· inference-optimization← in-domain predecessor
- Lost in the Noise: How Reasoning Models Fail with Contextual Distractors2026· reasoning← topic thread

What it influenced

Later papers in the same chain. Direction reversed.

Training LLMs for Divide-and-Conquer Reasoning Elevates Test-Time Scalability2026· training-methods→ in-domain predecessor
- Self-Hinting Language Models Enhance Reinforcement Learning2026· training-methods→ in-domain predecessor
- Search-R1: Training LLMs to Reason and Leverage Search Engines with Reinforcement Learning2025· training-methods→ similar topic
- Reinforcement Learning for Reasoning in Large Language Models with One Training Example2025· training-methods→ similar topic
- Nemotron Elastic: Towards Efficient Many-in-One Reasoning LLMs2025· training-methods→ similar topic
Learning When to Act or Refuse: Guarding Agentic Reasoning Models for Safe Multi-Step Tool Use2026· alignment→ topic thread
- Reasoning Models Struggle to Control their Chains of Thought2026· alignment→ in-domain predecessor
- FinMCP-Bench: Benchmarking LLM Agents for Real-World Financial Tool Use under the Model Context Protocol2026· evaluation→ topic thread
- Safe RLHF: Safe Reinforcement Learning from Human Feedback2023· alignment→ similar topic