DianJin-R1: Evaluating and Enhancing Financial Reasoning in Large Language Models

ArXiv: 2504.15716

🎯 Pitch

General-purpose reasoning models like DeepSeek-R1 actually underperform their non-reasoning counterparts on financial benchmarks—dropping over 20 points on tasks like CFLUE. DianJin-R1 closes this gap, and a single model call matches a multi-agent compliance system that uses 8× more API queries.

1. Executive Summary

This paper introduces DianJin-R1, a reasoning-enhanced framework that combines reasoning-augmented supervised fine-tuning with reinforcement learning to improve financial reasoning in large language models. Starting from Qwen2.5-7B-Instruct and Qwen2.5-32B-Instruct, the authors construct a high-quality dataset (DianJin-R1-Data) from CFLUE, FinQA, and a proprietary compliance corpus (CCC), train models to generate structured reasoning steps within ⟨think⟩ tags followed by answers in ⟨answer⟩ tags, and then refine reasoning quality through Group Relative Policy Optimization (GRPO) with dual rewards — one for structured output format and one for answer correctness. The resulting DianJin-R1-32B achieves the highest accuracy on all three financial benchmarks (86.74% on CFLUE, 80.82% on FinQA, 96.00% on CCC), and on the CCC dataset, a single-call reasoning model matches or surpasses a multi-agent system requiring 8.15× more API calls (94.50–96.00% vs. 95.00%), establishing that domain-specialized reasoning models can subsume complex multi-step compliance workflows without the inference cost of orchestrating multiple agents — though the gains depend critically on the presence of large-scale, reasoning-annotated in-domain training data, with CFLUE providing over 31,000 examples that drive improvements across all benchmarks.

2. Context and Motivation

The Core Problem: General-Purpose Reasoning Models Fail on Specialized Financial Tasks

The paper addresses a specific and practical gap: general-purpose reasoning models, despite their impressive performance on math and science benchmarks, do not reliably transfer their reasoning capabilities to the financial domain. This is not a subtle degradation — the paper presents evidence that some reasoning models actually underperform their non-reasoning counterparts on financial tasks. Table 3 shows that DeepSeek-R1-Distill-Qwen-7B scores 48.39% on CFLUE compared to 69.37% for the base Qwen2.5-7B-Instruct — a 21-point drop from adding reasoning capabilities. Similarly, DeepSeek-R1 scores 79.81% on FinQA while the non-reasoning DeepSeek-V3 achieves 81.34%. The reasoning capability that dramatically improves MATH-500 performance (from 71.40% to 90.20% for the Distill-7B model) actively harms performance on financial benchmarks.

This failure mode is not obvious. One might expect that reasoning — the ability to think step-by-step, verify intermediate conclusions, and catch errors — would generalize across domains. The paper's results demonstrate otherwise. The authors cite Fino1 (Qian et al., 2025) as having previously reported similar findings, establishing this as a documented phenomenon rather than an isolated observation.

The core reason is that financial reasoning requires qualitatively different cognitive machinery than mathematical or scientific reasoning:

• Domain-specific knowledge: Financial exam questions (CFLUE) presuppose familiarity with regulatory frameworks, financial instruments, accounting standards, and market conventions. A generic reasoning process that logically chains from first principles will produce coherent-sounding but factually incorrect reasoning when it lacks the necessary domain knowledge to constrain its inferences.

• Precise numerical reasoning with domain conventions: FinQA questions require extracting numerical values from financial reports and performing calculations according to financial conventions. For example, computing forward prices from spot prices and forward points involves specific bid-ask spread conventions (as shown in Figure 3's example: the seller uses the bid-side spot price of 268.50 plus the bid-side forward points of 700.0 basis points to get 275.5). A model that treats this as generic arithmetic will apply the wrong side of the spread.

• Multi-step compliance logic with regulatory constraints: The CCC dataset requires evaluating whether a customer service agent's behavior violates compliance rules across multiple dimensions (regulatory authority complaints, social media exposure risk, legal escalation risk, ticket escalation procedures). This is not free-form reasoning but rather constrained reasoning within a predefined decision workflow, where each step involves checking specific conditions against domain-specific guidelines.

The gap is thus not merely about reasoning quality — it is about reasoning in the presence of domain constraints that general-purpose models do not internalize during pretraining. A model can produce perfectly logical chains of thought that are nevertheless wrong because they apply generic reasoning patterns to domain-specific situations where the rules differ.

Why This Problem Matters: Practical Deployment and Computational Cost

The significance of this problem extends beyond academic benchmarking. The paper identifies three dimensions of real-world impact:

1. Financial services require reliable, auditable reasoning. In compliance checking (the CCC use case), a model that flags violations must produce reasoning that a human auditor can review and validate. A model that makes correct decisions with incorrect or irrelevant reasoning is legally problematic — regulators and internal audit teams need to verify why a decision was made. General-purpose reasoning models may produce superficially plausible but domain-incorrect reasoning, making their outputs untrustworthy in high-stakes financial applications where decisions have legal and regulatory consequences.

2. Multi-agent systems are computationally expensive to deploy at scale. The paper demonstrates that a multi-agent LLM system — where specialized agents handle each condition node in a compliance workflow — achieves 95.00% accuracy on CCC (Table 6), up from 55.50% for a single-call baseline. However, this requires 8.15 API calls per instance. In a production customer-service quality inspection system processing thousands or millions of dialogues daily, this 8× multiplier on inference cost is prohibitive. The raw performance is there, but the economics are not. The practical question the paper implicitly addresses is: can we achieve multi-agent accuracy at single-call cost?

3. The financial domain has unique evaluation requirements that existing benchmarks fail to capture. General reasoning benchmarks (MATH-500, GPQA-Diamond) test mathematical problem-solving and graduate-level science knowledge. They do not test whether a model knows financial regulations, understands bid-ask spread conventions, can interpret financial report tables, or can reason about compliance workflows. The gap between DeepSeek-R1's 94.80% on MATH-500 and its 79.81% on FinQA (Table 3) illustrates that domain competence is not a byproduct of general reasoning strength — it must be explicitly cultivated.

The theoretical significance lies in demonstrating that reasoning is not a monolithic, domain-agnostic capability. The success of models like DeepSeek-R1 and QwQ on math and science benchmarks created an implicit assumption that "reasoning" was a transferable skill. This paper, along with contemporaneous work like Fino1 (Qian et al., 2025) and Fin-R1 (Liu et al., 2025), challenges that assumption by showing that reasoning algorithms (like GRPO) produce different outcomes depending on the domain of the training data used during optimization.

Prior Approaches and Where They Fall Short

The paper situates itself against three categories of prior work, each with distinct limitations:

1. General-purpose LLMs without explicit reasoning (GPT-4o, DeepSeek-V3, Qwen2.5-Instruct). These models operate in a single forward pass, producing answers without visible intermediate reasoning steps. On financial tasks, their limitations are clear: Qwen2.5-72B-Instruct achieves only 55.50% on CCC (Table 3), indicating that even large models struggle with multi-step compliance reasoning when not explicitly trained to reason. GPT-4o achieves 71.68% on CFLUE and 50.00% on CCC — respectable but far from production-ready. The fundamental limitation is that these models cannot systematically work through multi-step financial problems, verify intermediate conclusions, or backtrack from dead ends. Their reasoning is implicit in the model weights rather than explicit in the output, making errors opaque and hard to diagnose.

2. General-purpose reasoning models (DeepSeek-R1, DeepSeek-R1-Distill, QwQ-32B). These models are trained with reinforcement learning (typically GRPO) on math and science reasoning data to produce explicit chain-of-thought reasoning. They represent the state of the art in general reasoning, but their domain transfer is unreliable:

• DeepSeek-R1-Distill-Qwen-7B scores 48.39% on CFLUE (Table 3), worse than the non-reasoning Qwen2.5-7B-Instruct baseline of 69.37%. This is a catastrophic failure of transfer: the distillation process that teaches the model to reason using general-domain data actually degrades its financial performance. The likely mechanism is that the model learns to produce elaborate reasoning chains that, in the absence of domain knowledge, converge on incorrect conclusions — essentially, it learns to confidently reason toward wrong answers.

• DeepSeek-R1 scores 86.64% on CFLUE but only 79.81% on FinQA (Table 3). Even the strongest general reasoning model shows domain-specific weakness. CFLUE is multiple-choice and knowledge-heavy, playing to DeepSeek-R1's strength in reasoning through options. FinQA requires extracting and computing over numerical data from tables — a different cognitive profile that general reasoning training does not fully cover.

• QwQ-32B scores 83.49% on CFLUE, competitive but below DianJin-R1-32B's 86.74%. The specialized training provides a margin that matters in high-stakes applications.

The critical insight is that these models' reasoning chains, while structurally sound, may be substantively incorrect because they lack the domain knowledge to constrain their reasoning. The paper's filtering process for CFLUE (Section 2.1) — removing questions that smaller models answer correctly — specifically targets questions that require genuine domain expertise rather than surface-level pattern matching.

3. Multi-agent systems for complex workflows. For tasks like CCC compliance checking, a natural approach is to decompose the decision into sub-tasks and assign specialized agents to each (Table 6). The Qwen2.5-72B-Instruct multi-agent system achieves 95.00% accuracy — excellent performance — but requires 8.15 API calls per instance. Each call invokes a 72B-parameter model, making the total computational cost equivalent to running a single 72B model roughly 8 times per dialogue. At production scale, this is economically infeasible for many organizations. The multi-agent approach is functionally effective but practically expensive, creating a gap for methods that can match its accuracy at lower cost.

4. Prior financial LLM efforts. The paper cites several financial benchmarks and models (Xie et al., 2023; 2024; Zhu et al., 2024; Chen et al., 2024; Qian et al., 2025; Liu et al., 2025) but positions its contribution differently. Existing financial LLMs typically focus on instruction tuning on financial data without explicit reasoning augmentation. The key prior work is Fino1 (Qian et al., 2025), which also studied the transferability of reasoning to finance and found similar limitations. DianJin-R1 extends this line of work by: (a) constructing a much larger reasoning-annotated dataset (over 38,000 instances vs. unspecified in the paper), (b) incorporating both multiple-choice and open-ended formats, (c) developing a multi-agent-based reasoning synthesis pipeline for compliance tasks, and (d) applying GRPO reinforcement learning on top of supervised fine-tuning rather than SFT alone.

How This Paper Positions Itself

The paper's positioning can be understood through three strategic choices:

1. Domain-specialized reasoning rather than general reasoning. Unlike DeepSeek-R1 or QwQ, which train reasoning on math and science data with the goal of general-purpose improvement, DianJin-R1 trains reasoning specifically on financial data. The hypothesis is that GRPO, when applied to in-domain problems, will optimize reasoning patterns that are appropriate for financial contexts rather than generic patterns that may conflict with domain constraints. The ablation in Table 4 provides partial support: RL adds ~5 points on CFLUE (75.48% → 80.32%) and 1.5 points on CCC (93.00% → 94.50%), but actually hurts FinQA (80.28% → 77.72%), suggesting the RL training data (which is Chinese and CFLUE-sourced) transfers positively only within its linguistic and domain context.

2. Reasoning as a learned behavior, not just a prompting strategy. The paper's approach is to train models to internalize reasoning through SFT on reasoning traces, then refine through RL, rather than relying on chain-of-thought prompting at inference time. This is a stronger form of reasoning augmentation: the model learns not just to produce reasoning when asked, but to produce correct reasoning that leads to correct answers, reinforced by accuracy rewards during GRPO. The structured output format ( ⟨think⟩ and ⟨answer⟩ tags) makes the reasoning explicit, auditable, and verifiable — addressing the compliance and interpretability requirements of financial applications.

3. Efficiency through single-call reasoning rather than multi-agent orchestration. The paper's most striking result is that DianJin-R1 models achieve multi-agent-level accuracy with single API calls on CCC (Table 6). This positions reasoning-augmented training as an alternative to workflow decomposition: rather than engineering a multi-agent system with domain expertise distributed across specialized agents and orchestrated through a predefined workflow, one can train a single model that internalizes the workflow's reasoning logic and executes it in one coherent chain of thought. The cost reduction is substantial (8.15× fewer calls), and the performance is comparable or better (94.50% for 7B, 96.00% for 32B vs. 95.00% for multi-agent 72B).

This positioning represents a particular bet about where domain-specific reasoning capability should reside: in the model weights (through fine-tuning) rather than in the system architecture (through multi-agent orchestration). The paper's evidence suggests this bet pays off for the CCC task, though the authors are careful to note that the multi-agent system was used to generate the training data (Section 2.2.3) — the single-call model is essentially distilling the multi-agent system's reasoning patterns into its own weights through SFT.

4. Incremental contribution within a growing research area. The paper explicitly connects to contemporaneous work on financial reasoning (Fino1, Fin-R1) and builds on established methods (GRPO from Shao et al., 2024; the ⟨think⟩/⟨answer⟩ format from DeepSeek-R1). The contribution is not a fundamentally new algorithm or architecture but rather a systematic demonstration that combining these techniques with domain-specific data yields practical, cost-effective improvements on real-world financial tasks. The novelty lies in the data construction methodology (especially the multi-agent reasoning synthesis for CCC), the demonstration that single-call models can match multi-agent systems, and the ablation studies that characterize when and how different training components contribute.

3. Technical Approach

3.1 Reader Orientation

The paper builds a reasoning-enhanced training pipeline that takes a base instruction-tuned LLM (Qwen2.5-Instruct) and teaches it to produce explicit, structured reasoning steps before delivering answers to financial domain questions. The core problem it solves is that general-purpose reasoning models fail on specialized financial tasks because they lack domain knowledge and produce reasoning chains that, while structurally sound, lead to wrong conclusions — the solution is to construct a large dataset of verified financial reasoning traces, fine-tune the model to imitate those traces, and then use reinforcement learning to reward the model for producing correct answers with properly formatted reasoning, essentially distilling domain expertise into the model weights so that a single inference call can match the accuracy of a multi-agent system requiring 8× more computation.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components connected in a pipeline:

1. Data Sources — three corpora (CFLUE multiple-choice financial exam questions with explanations, FinQA numerical reasoning QA pairs from financial reports, and CCC compliance-checking dialogues with ground-truth violation labels) that provide the raw question-answer pairs from which reasoning traces will be constructed.

2. Reasoning Generation Pipeline — a set of procedures that convert raw QA pairs into structured reasoning traces. For CFLUE and FinQA, this uses DeepSeek-R1 to generate chain-of-thought reasoning followed by GPT-4o verification. For CCC, this uses a multi-agent LLM system that follows a predefined compliance decision workflow, generating intermediate reasoning at each condition node, which is then merged into a unified chain-of-thought by GPT-4o.

3. DianJin-R1-Data (the constructed dataset) — the output of the reasoning generation pipeline, consisting of (x, r, y) triples where x is the question, r is the reasoning path (formatted within ⟨think⟩...⟨/think⟩ tags), and y is the correct answer (formatted within ⟨answer⟩...⟨/answer⟩ tags). This dataset is split into two subsets: reasoning-augmented instances (where verification succeeded) used for supervised fine-tuning, and hard non-reasoning instances (where verification failed after multiple attempts) used for reinforcement learning.

4. Supervised Fine-Tuning (SFT) Stage — the base Qwen2.5-Instruct model is fine-tuned on the reasoning-augmented portion of DianJin-R1-Data to learn to generate both reasoning and answers in the structured tag format. The question x serves as input, and the concatenation of ⟨think⟩r⟨/think⟩⟨answer⟩y⟨/answer⟩ serves as the target.

5. Reinforcement Learning (RL) Stage — the SFT model is further optimized using Group Relative Policy Optimization (GRPO) on the hard non-reasoning subset from CFLUE, using two reward signals: a format reward (1 if the output contains exactly one ⟨think⟩ block and one ⟨answer⟩ block with nothing outside them, 0 otherwise) and an accuracy reward (1 if the answer within ⟨answer⟩ tags exactly matches the gold answer, 0 otherwise).

Information flows sequentially: raw data sources → reasoning generation (with verification and retry logic) → DianJin-R1-Data → SFT training → RL training → DianJin-R1 model.

3.3 Roadmap for the Deep Dive

• First, the data filtering and preparation logic for each source (CFLUE, FinQA, CCC), since the quality of the reasoning dataset determines everything downstream.
• Second, the reasoning generation pipeline for CFLUE and FinQA — how DeepSeek-R1 generates chain-of-thought, how GPT-4o verifies it, and what happens when verification fails (the retry-and-fallback mechanism).
• Third, the reasoning generation pipeline for CCC — the multi-agent compliance workflow, how intermediate reasoning is produced at each condition node, and how GPT-4o merges it into a unified chain-of-thought.
• Fourth, the supervised fine-tuning stage — the training data format, exact hyperparameters, and design choices.
• Fifth, the reinforcement learning stage — GRPO mechanics, the format and accuracy reward definitions, and why only CFLUE data is used for RL.
• Sixth, the structured output format and its role in enabling both training and evaluation, since the ⟨think⟩ and ⟨answer⟩ tags are the backbone of the entire framework.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a data-centric engineering paper whose core idea is that reasoning capability in the financial domain can be instilled through a two-stage pipeline: first, construct high-quality reasoning traces using strong teacher models with a verification-and-retry mechanism, then train smaller models to imitate those traces (SFT) and reinforce correct behavior (GRPO).

3.4.1 Data Source Filtering: Ensuring Questions Require Genuine Reasoning

The paper does not train on all available data from CFLUE, FinQA, and CCC. Each source undergoes filtering designed to retain only questions that require non-trivial reasoning — questions that smaller models cannot answer correctly through pattern matching alone. This filtering is critical because training on easy questions would teach the model to produce reasoning traces for problems it could already solve, providing no marginal improvement in capability.

CFLUE filtering (Section 2.1). CFLUE originally contains 38,638 multiple-choice financial exam questions from 15 types of Chinese financial qualification mock exams. The filtering pipeline has three sequential stages:

• Length filter: questions with fewer than 15 tokens are removed. The rationale is that very short questions typically test factual recall rather than multi-step reasoning — for example, a question asking "What is the base currency in a USD/CNY quote?" requires minimal reasoning regardless of domain. Such questions, if included, would pad the dataset with instances where a reasoning chain adds no value and could teach the model to generate verbose justifications for trivial answers.

• Difficulty filter: questions that are correctly answered by all smaller language models (specifically LLaMA-3.1-8B and Qwen2.5-7B-Instruct) are discarded. This is a critical design choice: by removing questions that even 7–8B parameter models answer correctly without reasoning, the remaining dataset consists only of questions where smaller models fail, meaning they require capabilities (domain knowledge, multi-step inference, careful numerical reasoning) that exceed simple pattern matching. This filter operationalizes the paper's goal of teaching genuine reasoning rather than reinforcing existing surface-level capabilities. The citations to Ye et al. (2025) and Muennighoff et al. (2025) connect this to broader findings that "simple QA pairs may not significantly enhance reasoning ability."

• Ambiguity filter: GPT-4o is used to identify and remove questions containing ambiguous wording. This ensures that each remaining question has a "clear and well-defined" correct answer, which is essential for both training (ambiguous questions would produce inconsistent reasoning traces) and evaluation (ambiguous questions would make accuracy metrics unreliable).

After filtering, the CFLUE subset contains 26,672 multiple-choice questions for the MCQ format plus 5,045 for the open-ended format (Table 1), each accompanied by detailed explanations that serve as reference reasoning for verification.

FinQA filtering. FinQA contains 8,281 English financial QA pairs requiring numerical reasoning over financial reports. The paper applies "the same length and difficulty filters as used in the CFLUE dataset" (Section 2.1), though the specific thresholds may differ since FinQA questions involve extracting numbers from tables — a different length profile than CFLUE's exam questions. The result is 4,851 QA pairs (Table 1). The ambiguity filter is not applied to FinQA, presumably because the numerical nature of the questions (computing specific values) makes ambiguity less of a concern than for multiple-choice exam questions where wording can be interpreted multiple ways.

CCC curation. The Chinese Compliance Check dataset is an in-house corpus drawn from a "quality inspection system used in actual customer service operations" (Section 2.1). Each instance includes a full customer-service agent dialogue plus meta-information such as "customer service actions (e.g., ticket escalation)." Each instance has been "manually reviewed to ensure labeling accuracy." The paper samples from manually validated data to produce "a roughly balanced distribution between compliant and non-compliant cases." The final CCC training set contains 1,800 instances (Table 1). The small size (1,800 vs. 31,717 for CFLUE) reflects the cost of manual review and the specialized nature of compliance data — unlike exam questions and financial reports, compliance dialogues cannot be automatically sourced and labeled.

Why filtering matters for the approach. The filtering choices encode a specific hypothesis about what makes financial reasoning hard: it is not the reasoning process itself (which general models can already perform) but the combination of domain knowledge with reasoning. By removing questions that smaller models can answer, the filtered dataset focuses training on where domain knowledge matters most. This also explains why CFLUE dominates the training data: it is the only source large enough (31,717 instances after filtering) to provide broad coverage of financial domain knowledge across 15 qualification exam categories.

3.4.2 Reasoning Generation for CFLUE: DeepSeek-R1 as Teacher, GPT-4o as Verifier

The core data construction challenge is converting standard QA pairs into reasoning-augmented training examples — (question, reasoning chain, answer) triples where the reasoning chain is both correct and consistent with domain knowledge. The paper's solution is a generate-then-verify pipeline with retry logic.

Step 1: Open-ended question generation (for MCQ format). CFLUE questions are originally multiple-choice with options A, B, C, D. Training a model to reason toward a multiple-choice answer is different from training it to reason toward a free-form answer: in the MCQ case, the reasoning can exploit the options (e.g., "eliminating B and D because...") while in the open-ended case, the reasoning must derive the answer from first principles. To teach both skills, the paper converts a subset of MCQ questions into open-ended format.

The conversion uses GPT-4o with the prompt shown in Figure 4 (Appendix A). The prompt instructs GPT-4o to "rewrite it into an open-ended question and provide a standard answer" with two specific requirements: "the question must be specific and address the key points tested in the original multiple-choice question" and "provide a concise standard answer based on the correct answer from the original question." The output format is JSON with question and answer fields.

Figure 3 provides a concrete example: the MCQ asks for the outright forward price given spot prices (268.50/268.70) and forward points (700.0/900.0) with the seller as the initiating party, with four numeric options. The open-ended version asks "how is the forward full price calculated when the initiator is the seller, and what is the result?" with the answer "275.5 RMB per gram." The conversion preserves the computational challenge while removing the multiple-choice scaffolding.

The resulting open-ended dataset, D_CFLUE_OE, contains 5,045 instances (Table 1). The MCQ dataset, D_CFLUE_MCQ, retains 26,672 instances in their original multiple-choice format.

Step 2: Reasoning generation by DeepSeek-R1. For each question x_i in the dataset (whether MCQ or open-ended), the paper uses DeepSeek-R1 (Guo et al., 2025) to generate a chain-of-thought r_i and predicted answer a_i:

$r_i, a_i = \text{DS}(x_i)$

where DS denotes a single forward pass through DeepSeek-R1, which is "a model known for its strong reasoning capabilities" (Section 2.2.1).

What this notation conceals. DeepSeek-R1 is itself a reasoning model trained with GRPO to produce chain-of-thought before answering. So the paper is using one reasoning model (DeepSeek-R1) as a teacher to generate reasoning traces that will train another model (Qwen2.5-Instruct) to reason. This is knowledge distillation from a larger reasoning model to a smaller non-reasoning model, mediated by explicit reasoning traces rather than just output logits.

The choice of DeepSeek-R1 as the teacher model is motivated by its general reasoning strength — the paper does not claim DeepSeek-R1 has domain-specific financial knowledge, only that its reasoning capability is strong enough to produce coherent chains of thought that can then be verified for domain correctness by GPT-4o.

Step 3: Verification by GPT-4o. The generated reasoning r_i and predicted answer a_i are evaluated by GPT-4o against two criteria:

• Answer correctness: whether the predicted answer a_i matches the gold answer y_i. For multiple-choice questions, this is straightforward (does the letter A/B/C/D match?). For open-ended questions, the gold answer is the one generated during conversion. For numerical answers, the paper's evaluation pipeline (Appendix B, Figure 8) allows for format flexibility — "numerical values are considered consistent if they are the same despite different formats" (e.g., 0.88 and 88% match) and "rounding leads to the same result" (e.g., 8 and 7.96 match).

• Reasoning consistency: whether the generated reasoning r_i is "consistent with the reference explanation e_i" — the explanation that came with the original CFLUE question. This is the critical verification step that distinguishes the paper's approach from simple answer-matching. A model could produce the correct answer with incorrect reasoning (e.g., guessing, or using a wrong method that coincidentally yields the right number), and such instances would teach the student model to produce plausible-sounding but domain-incorrect reasoning. By requiring reasoning consistency with the reference explanation, the verification step ensures that the reasoning traces encode genuine financial domain reasoning.

The verification prompt is not shown in the paper. Section 2.2.1 states that GPT-4o is used "to assess two key aspects of the generated output" but the specific prompt is not included in Appendix B (which shows prompts for evaluation, not for data construction verification). This is a methodological gap — the criteria for "consistency with the reference explanation" are not operationally defined.

Step 4: Retry-and-fallback mechanism. If verification fails — either the answer is wrong or the reasoning is inconsistent — the paper retries the reasoning generation "up to T attempts (with T = 3 in this paper)." This is essentially a rejection sampling procedure: keep generating from DeepSeek-R1 until you get a verified output or exhaust the retry budget.

If all T attempts fail, the instance is "considered a hard case and preserved as a non-reasoning sample" — meaning only the question-answer pair (x_i, y_i) is kept, without reasoning. These hard cases form the dataset G_CFLUE_MCQ (for MCQ) and G_CFLUE_OE (for open-ended), which are later used for reinforcement learning rather than SFT.

What makes a case "hard"? The paper does not explicitly analyze this, but the mechanism implies that hard cases are those where even DeepSeek-R1 — a strong general reasoner — cannot produce reasoning that is both domain-consistent and answer-correct. These are likely questions requiring specialized financial knowledge that DeepSeek-R1 lacks (specific regulatory thresholds, accounting conventions, market microstructure details). The retry limit of 3 attempts means this classification is noisy — a question could be answerable by DeepSeek-R1 with, say, 15% probability, and by chance none of the 3 attempts succeed. Such questions would be incorrectly classified as hard.

Why this pipeline design? The paper could have used GPT-4o directly to generate reasoning (rather than DeepSeek-R1 as generator and GPT-4o as verifier). The choice to separate generation and verification reflects a specific belief: that DeepSeek-R1 produces more diverse or higher-quality reasoning than GPT-4o would in a single pass, but GPT-4o is better at verification (checking consistency against a reference) than it is at generation. This is consistent with the broader literature showing that LLMs are often better evaluators than generators for domain-specific tasks.

The pipeline produces two complementary datasets from the same source questions: R_CFLUE_MCQ (reasoning-augmented, used for SFT) and G_CFLUE_MCQ (hard non-reasoning, used for RL). The same procedure is applied to both MCQ and open-ended formats, yielding four datasets from CFLUE: R_CFLUE_MCQ, G_CFLUE_MCQ, R_CFLUE_OE, G_CFLUE_OE.

3.4.3 Reasoning Generation for FinQA: Same Pipeline, Different Input

FinQA questions are already in open-ended format, so the open-ended conversion step is skipped. The procedure is otherwise identical to CFLUE's open-ended pipeline:

1. For each QA pair (x_i, y_i) in the filtered FinQA dataset, DeepSeek-R1 generates reasoning r_i and predicted answer a_i.
2. GPT-4o verifies answer correctness and reasoning consistency (against the reference answer, since FinQA does not provide detailed explanations like CFLUE).
3. If verification fails, retry up to 3 times.
4. If all attempts fail, the instance becomes a hard non-reasoning sample in G_FinQA.

The resulting datasets are R_FinQA (4,851 instances in Table 1, suggesting most instances passed verification within 3 attempts) and G_FinQA (hard cases, not explicitly sized in the paper).

A notable difference from CFLUE: FinQA has no reference explanations. CFLUE questions come from mock exams that provide detailed answer explanations. FinQA provides only questions and answers (numerical values). This means the "reasoning consistency" verification for FinQA cannot check against a reference chain of thought — it can only verify that the generated reasoning is internally coherent and leads to the correct answer. This is a weaker verification standard, which may partially explain why Table 5 shows that adding FinQA to CFLUE during SFT improves FinQA accuracy (71.65% → 80.85%) but does not improve CCC and only marginally helps CFLUE — the FinQA reasoning traces may contain domain errors that the weaker verification fails to catch, limiting their transfer value.

3.4.4 Reasoning Generation for CCC: Multi-Agent Workflow as Teacher

The CCC dataset represents a qualitatively different reasoning challenge. Unlike CFLUE (evaluating multiple-choice options using domain knowledge) or FinQA (extracting and computing numerical values), CCC requires structured compliance reasoning: given a customer service dialogue, determine whether the agent violated compliance rules by checking a sequence of condition nodes in a predefined workflow.

The key insight is that even humans do not perform this task through free-form reasoning — they follow a checklist. The paper operationalizes this by defining a decision workflow with specific condition nodes:

• Regulatory authority complaint detection: does the customer mention filing a complaint with a regulatory agency? If yes, flag as alert.
• Social media complaint detection: does the customer mention complaining on social media platforms? If yes, flag as alert.
• Legal risk detection: has the customer mentioned consulting a lawyer? If yes, flag as alert.
• Customer service audit: given the alerts from previous nodes, did the service agent perform required actions (e.g., ticket escalation)? If required actions were not taken, flag as violation.

The workflow begins at a start node, proceeds through condition nodes in sequence, and ends at one of two outcome nodes: "no violation" or "violation detected."

Why a multi-agent system for data generation? The paper acknowledges that "it is challenging for LLMs to directly generate reasoning from a dialogue" (Section 2.2.3) because the reasoning must follow the workflow structure — a single LLM asked to "determine if there is a compliance violation and explain why" would need to internally execute this multi-step condition-checking process, which is difficult to do reliably in one pass. The multi-agent approach decomposes the problem: each condition node gets a specialized agent (implemented as Qwen2.5-72B-Instruct with a node-specific prompt) that only needs to evaluate one specific condition.

Step-by-step reasoning generation:

1. For each CCC instance (x_i, y_i) where x_i is a dialogue and y_i is the gold-standard compliance judgment with summarized reasoning, the system follows the predefined workflow strictly.

2. At each condition node j (where j ranges from 0 to n_i, with n_i being the number of nodes traversed before reaching the outcome), the corresponding LLM agent receives the dialogue x_i and any relevant context from previous nodes, and generates:

   • An intermediate chain-of-thought r_i^j explaining its assessment of whether the condition is met.
   • An intermediate answer a_i^j (yes/no for condition met).

3. The final answer a_i is determined by the outcome node based on the collective intermediate answers (a_i^0, ..., a_i^{n_i}) — essentially a deterministic function of the condition evaluations.

4. Verification: if a_i matches the gold answer y_i, the instance is candidate for retention. If not, retry up to 3 attempts. (The paper does not specify whether retrying means re-running all agents or only the ones whose decisions were implicated in the mismatch.)

5. Reasoning merging: if the answer is correct, GPT-4o merges all intermediate chains of thought (r_i^0, ..., r_i^{n_i}) into a single unified chain of thought r_i. Figure 1 shows an example: the four agents' outputs (regulatory authority alert, social media alert, legal risk alert, customer service auditor) are merged into a single ⟨think⟩ block that walks through each condition in sequence, with headers like "首先，我们检测客户是否有向监管机构投诉倾向" ("First, we check whether the client has a tendency to file a complaint with regulatory agencies").

Why GPT-4o for merging rather than simple concatenation? The agent outputs are generated independently and may contain redundancies, contradictions in phrasing, or references to shared context that need to be unified. Simple concatenation would produce a disjointed reasoning trace. GPT-4o's role is to produce a coherent, flowing narrative that reads as if a single agent performed all the checks in sequence — this is what the student model will learn to imitate during SFT.

What the merged reasoning captures. The unified CoT encodes the workflow structure implicitly: rather than explicitly referencing condition nodes, it presents the reasoning as a natural sequence of checks ("First we check X... Next we check Y... Finally we check Z..."). This is crucial because the student model (DianJin-R1) will not have access to the multi-agent workflow at inference time — it must learn to internally structure its reasoning along the same condition-checking dimensions from the narrative alone.

Cost implications of this approach. The multi-agent system generates reasoning once (offline, during dataset construction) but is not used at inference time. The student model learns to replicate the multi-agent reasoning in a single forward pass, achieving 94.50–96.00% accuracy with 1 API call vs. 95.00% with 8.15 calls (Table 6). The training cost (running the multi-agent system and GPT-4o on 1,800 CCC instances) is amortized over all future inference calls, making this an economically sound strategy for production deployment.

Why this works for CCC but would be harder for other tasks. The CCC task has a well-defined workflow with discrete condition nodes — it decomposes naturally into sub-tasks. For tasks without such clear decomposition (e.g., open-ended financial essay questions), the multi-agent approach to data generation would be harder to apply, and alternative reasoning synthesis methods (like direct DeepSeek-R1 generation, as used for CFLUE and FinQA) would be needed.

3.4.5 Supervised Fine-Tuning: Teaching Structured Reasoning Generation

With the reasoning datasets constructed, the first training stage teaches the base model to produce reasoning-then-answer outputs in a specific structured format.

Training data format. Each SFT instance is a (question, target) pair where the target is the concatenation of reasoning and answer:

⟨think⟩ [reasoning text] ⟨/think⟩ ⟨answer⟩ [answer text] ⟨/answer⟩

The question x serves as input to the model. The target output t is the reasoning and answer with tags. During training, the model is optimized to maximize the probability of generating t given x:

$\mathcal{L}_{\text{SFT}} = -\sum_{k=1}^{|t|} \log P_\theta(t_k | x, t_{<k})$

where P_θ is the model's predicted probability distribution, t_k is the k-th token of the target, and t_{<k} are the preceding target tokens.

What this computes: standard autoregressive language modeling loss summed over all tokens in the reasoning-and-answer sequence. The model learns to produce the reasoning first, then the answer, in exactly the tagged format seen during training.

Why this format? The ⟨think⟩ and ⟨answer⟩ tags serve multiple purposes:

• At training time: they structure the loss computation, ensuring the model learns the two-phase generation pattern.
• At RL time: they enable the format reward — the system can automatically check whether the output contains exactly one think block and one answer block.
• At evaluation time: they enable answer extraction — for rule-based evaluation, the content within ⟨answer⟩ tags can be parsed and compared against the gold answer. For GPT-4o-based evaluation (FinQA, CCC), the structured format makes it easier to identify the model's final answer.

The format is inherited from the reasoning model literature (DeepSeek-R1 uses similar thinking/answer separation), but the paper does not claim novelty here — it adopts a proven convention.

Training configuration (Section 3.1): The SFT stage uses the following hyperparameters, quoted verbatim:

• Optimization: DeepSpeed's Zero-3 for distributed training across GPUs.
• Learning rate: $1.0 \times 10^{-5}$.
• Sequence length: 16K tokens (necessary because reasoning traces can be long — Table 1 shows average reasoning token counts of 807–1,577 across datasets).
• Precision: bf16 (bfloat16, a 16-bit floating-point format that preserves more exponent range than float16, important for training stability).
• Epochs: 3 (indicating the model sees each training example three times).
• Gradient accumulation: 16 steps "to simulate a larger batch size" — the effective batch size is 16× the per-device batch size, but the paper does not report the per-device batch size.
• Hardware: 7B model on a single node with 8 NVIDIA A100 GPUs; 32B model on 32 GPUs across 4 nodes.

Data mixing strategy. The paper states that "CFLUE_MCQ constitutes a large portion of the SFT data" (26,672 out of 38,368 total SFT instances, or approximately 70%) and that it is "shuffled together with the other datasets to prevent overfitting to any single source." This is a standard practice but raises a question: the heavy imbalance toward CFLUE (and specifically toward Chinese-language MCQ format) means the model receives many more training examples of Chinese MCQ reasoning than English open-ended numerical reasoning (FinQA) or dialogue-based compliance reasoning (CCC). The ablation in Table 5 partially addresses this by showing that adding FinQA or CCC on top of CFLUE improves those specific benchmarks without degrading others, but the dominance of CFLUE in the training mix is an implicit design choice that the paper does not justify beyond data availability.

Dataset sizes from Table 1:

These statistics reveal interesting patterns:

• CFLUE_OE has shorter questions but longer answers than MCQ: The open-ended format strips away the multiple-choice options (reducing input tokens) but requires full-sentence answers (increasing output tokens). This teaches the model to produce substantive free-form answers rather than single-letter selections.
• FinQA has the longest reasoning traces: At 1,576.91 tokens on average, FinQA's numerical reasoning requires extensive step-by-step computation, likely including extracting numbers from financial tables, setting up equations, and performing multi-step arithmetic.
• CCC has the longest input but moderate reasoning: Dialogue inputs are long (1,695.78 tokens) but the reasoning, once merged by GPT-4o, is more concise (884.29 tokens) — the multi-agent workflow produces structured condition checks that don't require extensive narrative.

3.4.6 Reinforcement Learning: GRPO with Dual Rewards

The SFT model can generate reasoning in the correct format, but its answers may still be incorrect — SFT teaches the model to produce reasoning that looks like the training data, not necessarily to produce reasoning that leads to correct answers. The reinforcement learning stage addresses this by directly optimizing for answer correctness.

Why RL rather than more SFT? The hard, non-reasoning dataset G_CFLUE_MCQ consists of instances where even DeepSeek-R1 (with up to 3 attempts) could not produce verified reasoning traces. These are the hardest questions. Training on them with SFT would require reasoning traces, which do not exist — by definition, these instances failed reasoning generation. However, the questions and correct answers are still valuable training signals: the model can learn to produce correct answers through its own reasoning, even if the teacher model could not generate reasoning for these instances.

RL enables this because the reward is based on answer correctness, not on matching a pre-existing reasoning trace. The model generates its own reasoning (guided by the format reward) and receives positive feedback only when that reasoning leads to the correct answer.

Group Relative Policy Optimization (GRPO). The paper adopts GRPO from Shao et al. (2024), the same algorithm used by DeepSeek-R1. GRPO is a variant of policy gradient methods designed for LLM fine-tuning. The key mechanic:

1. For each question, the model generates K candidate outputs (the paper uses K = 8 rollouts per sample, specified in Section 3.1).
2. Each output receives a scalar reward.
3. Rather than using an absolute reward threshold, GRPO computes the advantage of each output relative to the group mean: outputs that score above average get positive advantage; outputs that score below average get negative advantage.
4. The policy is updated to increase the probability of high-advantage outputs and decrease the probability of low-advantage outputs.

The group-relative nature is important because it provides a learning signal even when all outputs are incorrect: the model still learns to prefer the least incorrect outputs and avoid the most incorrect ones. This contrasts with absolute reward methods (like standard PPO) where uniformly low rewards provide no gradient signal.

Reward definition. The total reward for an output y is the sum of two components:

$R(y) = R_{\text{format}}(y) + R_{\text{accuracy}}(y)$

where each component is defined as:

• Format reward R_format: 1 if the output "contains exactly one reasoning segment enclosed within ⟨think⟩...⟨/think⟩ tags and one final answer enclosed within ⟨answer⟩...⟨/answer⟩ tags, with no additional content outside these boundaries"; 0 otherwise.

• Accuracy reward R_accuracy: 1 if "the content enclosed within the ⟨answer⟩...⟨/answer⟩ tags exactly matches the reference answer"; 0 otherwise. Currently applied "exclusively to multiple-choice questions from R_CFLUE_MCQ" (footnote 2 in Section 2.3.2).

What this reward structure incentivizes:

• Format: The binary format reward is strict — any deviation from the ⟨think⟩⟨/think⟩⟨answer⟩⟨/answer⟩ structure with nothing outside yields 0. This strongly penalizes outputs that mix reasoning and answer, produce multiple reasoning blocks, or include extraneous text. The model learns that adhering to the structure is non-negotiable.

• Accuracy: The binary accuracy reward is also strict — "exactly matches" means the extracted answer string must be identical to the reference. For multiple-choice questions, this is straightforward (the answer is a letter A/B/C/D or the full option text). There is no partial credit for "close" answers.

• Combined: Since both rewards range from 0 to 1, the total reward R ranges from 0 to 2. An output with correct format and wrong answer scores 1; an output with wrong format and correct answer also scores 1; only an output with both gets the full 2. This balanced weighting ensures the model does not sacrifice format for accuracy or vice versa.

Why only CFLUE_MCQ for RL? The paper states in footnote 1: "In the future, we will include G_CFLUE_OE, G_FinQA, and G_CCC in RL." The current RL stage uses only the hard subset of multiple-choice CFLUE questions. This is a significant limitation:

• Language: All RL training data is Chinese. This explains why RL improves CFLUE (+4.84 points from SFT to SFT+RL in Table 4) and CCC (+1.50 points) but actually hurts FinQA (−2.56 points) — the RL optimization is language-specific and transfers negatively to English tasks.
• Format: All RL data is multiple-choice. The model is rewarded for producing a single-letter answer within ⟨answer⟩ tags. This may not generalize well to open-ended answer formats.
• Size: 4,096 instances (Table 1) is relatively small for RL training, which typically benefits from more exploration data.

RL hyperparameters (Section 3.1):

• Rollouts per sample: 8 (meaning 8 candidate outputs are generated for each question).
• Train batch size: 1024.
• Rollout batch size: 256.
• Learning rate: $1.0 \times 10^{-6}$ (ten times lower than SFT, typical for RL fine-tuning to avoid catastrophic forgetting).
• Sampling temperature: 0.6 (moderate temperature — high enough to encourage exploration and diversity among the 8 rollouts, but low enough to avoid degenerate outputs).
• Epochs: 5.

Why this RL configuration? The temperature of 0.6 is a deliberate balance: at temperature 0 (greedy), all 8 rollouts would be identical, providing no advantage signal for GRPO's group comparison. At temperature 1.0+, outputs might be too diverse and often malformed, wasting training compute on obviously bad outputs. The value 0.6 provides sufficient diversity for meaningful within-group comparison while keeping outputs mostly coherent.

The lower learning rate (1e-6 vs. SFT's 1e-5) prevents the RL updates from overwriting the SFT-learned behavior — the model should refine its reasoning toward correct answers without losing the ⟨think⟩/⟨answer⟩ format or the domain knowledge acquired during SFT.

The GRPO advantage computation (implicit, not shown in paper): While the paper does not provide the GRPO equations, the standard formulation from Shao et al. (2024) computes the advantage of the i-th output in a group as:

$A_i = \frac{R_i - \text{mean}(\{R_1, \dots, R_K\})}{\text{std}(\{R_1, \dots, R_K\})}$

This normalized advantage is then used in a clipped policy gradient update analogous to PPO, where the policy is encouraged to increase probability for positive-advantage outputs and decrease for negative-advantage outputs, with clipping to prevent destructive large updates.

3.4.7 The Structured Output Format: Design and Motivation

The ⟨think⟩...⟨/think⟩⟨answer⟩...⟨/answer⟩ format is the backbone of the entire training pipeline. It is worth examining why this specific format was chosen and what alternatives it rejects.

What the format encodes. The separation of reasoning and answer into distinct tagged blocks serves as explicit metacognitive scaffolding: the model learns that "thinking" and "answering" are distinct phases of output generation. During inference, this manifests as the model first producing internal reasoning (akin to working memory or scratchpad) and then producing a final, committed answer based on that reasoning. The tags make this two-phase process machine-readable, enabling automated evaluation and reward computation.

Why not free-form chain-of-thought? A model could be trained to produce reasoning without explicit tags — for example, by simply generating "Let me think step by step..." followed by "Therefore, the answer is..." This is how chain-of-thought prompting typically works. The disadvantage is that answer extraction becomes heuristic (e.g., parsing the last number or sentence), which is error-prone for complex answer formats. The explicit ⟨answer⟩ tags make extraction deterministic — the evaluator simply takes everything between the tags.

Why not separate calls? An alternative approach would be to have the model generate reasoning in one API call (with thinking tags) and then extract the answer in a separate call. The single-call approach is more efficient and, more importantly, ensures that the reasoning and answer are produced by the same model state — the answer is conditioned on the full reasoning context, which would be lost in a separate call.

The "no additional content outside" constraint. The format reward requires that there be zero text outside the tagged blocks — not even a preamble like "Here is my reasoning:" or a closing like "I hope this helps." This constraint teaches the model that its entire output is the structured reasoning+answer unit, with nothing extraneous. This is important for downstream programmatic processing where extraneous text could interfere with tag parsing.

Why 0/1 scoring for format rather than partial credit? A softer format reward (e.g., partial points for having tags but with extra content) would be more forgiving but would also provide a weaker learning signal. The binary reward forces the model to learn the exact format — there is no gradient between "almost correct" and "correct," so the only way to get the format reward consistently is to produce outputs that machine-parse perfectly. This is the right choice for a deployment-oriented system where format reliability matters.

4. Key Insights and Innovations

Innovation 1: Domain-Specialized Reasoning Training as a Distinct Capability, Not a Subset of General Reasoning

The paper's most important conceptual contribution is demonstrating that reasoning is not a domain-agnostic, transferable skill that general-purpose training can adequately cultivate for all applications. This is not merely an empirical observation — it is a reframing of how the field should think about reasoning in LLMs.

Prior to this work (and contemporaneous efforts like Fino1 and Fin-R1), the dominant narrative around reasoning models — driven by DeepSeek-R1, QwQ, and OpenAI o1 — was that training models to reason on math and science data produces a generalizable reasoning capability. The assumption was implicit but widespread: a model that learns to reason through calculus problems will also reason better through legal analysis, medical diagnosis, or financial compliance, because the reasoning process is transferable even if the domain knowledge differs.

The paper challenges this assumption with a striking counterexample: DeepSeek-R1-Distill-Qwen-7B, a model specifically distilled to reason, scores 48.39% on CFLUE compared to 69.37% for the non-reasoning Qwen2.5-7B-Instruct (Table 3) — a 21-percentage-point degradation from adding reasoning capabilities. This is not a failure to transfer — it is active harm. The model's learned reasoning patterns, optimized for math and science, lead it to produce elaborate but domain-incorrect chains of thought that converge on wrong answers more often than the base model's simpler, less confident decision-making.

What makes this insight distinctive is that it recasts reasoning as a domain-coupled capability rather than a domain-independent cognitive skill. The reasoning process cannot be separated from the knowledge that constrains it. A model trained to reason through mathematical derivations learns patterns — step-by-step variable manipulation, algebraic simplification, checking for extraneous solutions — that are actively misleading when applied to financial exam questions where the correct inference depends on knowing specific regulatory thresholds, market conventions, or accounting standards that the model never encounters during math training. The reasoning capability amplifies the model's confidence in incorrect domain inferences, producing worse outcomes than not reasoning at all.

The significance extends beyond the financial domain. It suggests that the entire research program of training "general reasoning models" on math and science benchmarks may produce models whose reasoning transfers only within closely related domains — quantitative, rule-based, procedurally decomposable problems — and fails catastrophically on domains requiring different forms of inference (regulatory interpretation, compliance judgment, domain-specific common sense). The paper's framing implies that future work should not ask "how can we make reasoning more general?" but rather "what domain-specific data and training procedures produce reliable reasoning for each target domain?"

The evidence for this reframing is not a single data point. Table 3 shows a consistent pattern: general reasoning models (DeepSeek-R1, DeepSeek-R1-Distill variants, QwQ-32B) show erratic performance on financial benchmarks despite dominating general benchmarks like MATH-500 and GPQA-Diamond. DeepSeek-R1 achieves 94.80% on MATH-500 — near-ceiling — but only 79.81% on FinQA, below the non-reasoning DeepSeek-V3 at 81.34%. The reasoning capability that adds 23.4 points on MATH-500 (comparing Qwen2.5-7B-Instruct at 71.40% to DeepSeek-R1-Distill-Qwen-7B at 90.20%) subtracts 21 points on CFLUE. This is not a correlation failure — it is a sign reversal, the strongest possible evidence that the underlying capability is domain-specific.

This insight represents a fundamental conceptual shift rather than an incremental improvement. It changes the unit of analysis in reasoning research from "can the model reason?" to "can the model reason about what?" — a distinction that parallels the classic finding in cognitive science that expertise is domain-specific (Chase and Simon's chess studies, Chi et al.'s physics expertise work). Just as human chess masters do not transfer their superior memory to random board positions, LLM reasoning trained on math does not transfer to finance. The paper provides the first clear LLM-scale evidence for this domain-specificity of learned reasoning.

Innovation 2: Reasoning Distillation from Multi-Agent Workflows into Single-Call Models

The paper's second conceptual contribution is demonstrating that complex multi-agent reasoning workflows can be distilled into the weights of a single model, achieving comparable accuracy at a fraction of the inference cost. This is not merely an efficiency gain — it represents a different architectural philosophy about where domain reasoning should reside.

The traditional approach to complex, multi-step domain tasks is system-level decomposition: break the problem into sub-tasks, assign specialized agents (or modules) to each, and orchestrate their interactions through a predefined workflow. The paper shows this approach works — the multi-agent system on CCC achieves 95.00% accuracy (Table 6) — but at a cost of 8.15 API calls per instance, each invoking a 72B-parameter model. At production scale (thousands of customer-service dialogues daily), this computational burden makes the approach economically infeasible for many organizations.

The alternative the paper demonstrates is model-level internalization: use the multi-agent system to generate training data (reasoning traces that encode the workflow's condition-checking logic), then train a single model to produce the same reasoning end-to-end. The result is DianJin-R1-7B, a 7B-parameter model, achieving 94.50% accuracy on CCC with a single API call — statistically indistinguishable from the multi-agent 72B system's 95.00% (given the 200-instance test set, the difference of 0.5 percentage points corresponds to a single question). DianJin-R1-32B at 96.00% actually exceeds it.

What makes this contribution intellectually distinctive is that it inverts the standard relationship between system architecture and model capability. The conventional view is that complex tasks require complex systems — more agents, more orchestration, more runtime coordination. The paper's finding suggests an alternative: complexity during training, simplicity during inference. The multi-agent system's structured reasoning, encoded in the training data, enables a much simpler model to replicate the workflow's logic without the runtime overhead. The reasoning distillation process transfers the workflow structure from the system architecture into the model's weights, where it becomes implicit rather than explicit but no less effective.

This connects to a broader trend in machine learning — the compression of algorithmic reasoning into learned model weights (exemplified by AlphaGo's distillation of Monte Carlo Tree Search into a policy network, or more recently by DeepSeek-R1's emergence of self-verification behaviors from RL). But the paper's specific contribution is showing that this compression works for domain-expert workflows where the reasoning is defined by external regulatory or procedural constraints, not just by logical consistency. The CCC workflow is not a mathematical derivation — it is a human-designed compliance checklist. The model learns to execute this checklist not by being programmed with the rules but by imitating reasoning traces that encode them.

The practical significance is substantial: organizations with domain-specific decision workflows can use existing multi-agent or human-in-the-loop systems to generate training data for specialized reasoning models, then deploy those models at dramatically lower inference cost. The paper provides a concrete recipe for this transformation — multi-agent reasoning generation → GPT-4o merging → SFT on reasoning traces → GRPO refinement — that other domains can adopt.

However, the innovation also has a clear boundary: it requires the target task to be decomposable into a structured workflow that multi-agent systems can execute. For open-ended financial analysis without predefined decision trees, the multi-agent data generation approach would not directly apply. The paper's CFLUE and FinQA results rely on a different data generation method (DeepSeek-R1 as teacher), suggesting that the distillation-from-workflows insight is complementary to, rather than a replacement for, other reasoning data construction approaches.

Innovation 3: The Hard-Case Split as a Training Strategy — Separating Imitation from Discovery

The paper's third conceptual contribution is a specific data partitioning strategy that has implications beyond the financial domain: using successfully verified reasoning traces for supervised fine-tuning (imitation) and failed-to-verify hard cases for reinforcement learning (discovery).

The standard approach in reasoning-augmented training is to use whatever reasoning data you can generate — if a teacher model can produce a correct reasoning trace, include it for SFT; if not, discard the instance or fall back to non-reasoning training. This treats reasoning generation as a filter: keep the successes, ignore the failures.

The paper's approach is different. When DeepSeek-R1 (with up to 3 retry attempts) cannot produce verified reasoning for a CFLUE question, the instance is not discarded. Instead, it is preserved as a "hard case" and assigned to the reinforcement learning stage, where the model receives rewards based on answer correctness but must generate its own reasoning from scratch. This creates a division of labor between the two training stages:

• SFT stage: Teach the model to produce well-structured reasoning through imitation of high-quality traces. The model learns how to reason — the format, the step-by-step pattern, the integration of domain knowledge with inference — from instances where a teacher model succeeded.

• RL stage: Push the model to discover reasoning strategies for problems where imitation alone fails. The model explores its own reasoning paths, guided only by answer-correctness feedback, on instances that even the teacher model could not reliably solve.

What makes this distinctive is that it treats the failures of the teacher model as a training resource rather than a data quality problem. The hard cases, by definition, require reasoning capabilities that exceed what DeepSeek-R1 — a strong general reasoner — can produce. If the student model can learn to solve some of these through RL exploration, it has acquired a capability that the teacher model lacks for these specific instances. The paper's ablation (Table 4) provides partial evidence for this: RL adds 4.84 points on CFLUE (75.48% → 80.32%), suggesting the model does learn to solve some hard cases through exploration.

This insight reframes the relationship between SFT and RL in reasoning training. Rather than viewing RL as a refinement step that "polishes" SFT-learned behavior (the common framing in instruction-tuning pipelines), the paper treats RL as a capability-discovery step that operates on a complementary data distribution — the instances where SFT's imitation learning hits a ceiling. The two stages address different parts of the difficulty spectrum, and the hard-case split operationalizes this.

The innovation is incremental rather than fundamental — it is a data partitioning strategy that builds on existing SFT and GRPO methods — but it has practical significance for any domain where reasoning traces can be imperfectly generated. The key design choice is not how to train but what data to assign to which stage, and the paper provides a principle: verified reasoning traces go to SFT, unverifiable instances go to RL.

A limitation worth noting: the paper's current RL stage only uses CFLUE multiple-choice hard cases (4,096 instances, Table 1), and the authors acknowledge plans to expand this to other datasets. The finding that RL on Chinese MCQ data does not transfer to English FinQA (Table 4: SFT+RL drops FinQA from 80.28% to 77.72%) suggests that the hard-case split strategy works within a domain but may not generalize across languages or task formats. This is consistent with Innovation 1 (domain specificity of reasoning) but adds a practical constraint: hard-case RL data should be matched to the target domain and language.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on five benchmarks: three financial-domain test sets (CFLUE: 3,864 Chinese multiple-choice financial exam questions; FinQA: 1,147 English numerical reasoning questions over financial reports; CCC: 200 Chinese compliance-checking dialogues) and two general-domain test sets (MATH-500: 500 competition-level math problems from Hendrycks et al., 2021; GPQA-Diamond: 198 graduate-level science QA questions from Rein et al., 2024). All datasets are used exclusively for evaluation — none of the test data appears in DianJin-R1-Data for training. The CCC test set is manually validated and balanced between compliant and non-compliant cases.

• Base model(s). Two instruction-tuned models from the Qwen2.5 family serve as starting points: Qwen2.5-7B-Instruct (7 billion parameters) and Qwen2.5-32B-Instruct (32 billion parameters), both from Yang et al. (2024). These were chosen because they represent the Qwen family's instruction-following capability without explicit reasoning training, making them appropriate baselines for measuring the impact of reasoning augmentation. The 7B-vs-32B scale comparison allows assessing whether the framework's benefits are consistent across model sizes.

• Metrics. All results are reported as accuracy — the proportion of questions where the model's predicted answer matches the ground-truth answer — and an average accuracy across all five test sets. For CFLUE, MATH-500, and GPQA-Diamond, answer correctness is determined by rule-based extraction (parsing the content within ⟨answer⟩ tags and comparing directly against gold answers). For FinQA and CCC, GPT-4o is used as the evaluator because answers can take varied forms: for FinQA, numerical answers may differ in formatting (0.88 vs. 88%) or rounding (7.96 vs. 8.0); for CCC, compliance judgments may be expressed in different natural language formulations. The GPT-4o evaluation prompts (Appendix B, Figures 8 and 9) specify criteria for when answers are considered consistent despite surface differences (e.g., "numerical values are considered consistent if they are the same despite different formats" and "rounding leads to the same result").

• Baselines. The paper compares against two categories of models. Non-reasoning general models: GPT-4o (OpenAI, 2024), DeepSeek-V3 (Liu et al., 2024), Qwen2.5-7B-Instruct, Qwen2.5-32B-Instruct, and Qwen2.5-72B-Instruct (Yang et al., 2024). These models produce answers without explicit chain-of-thought — they are evaluated as zero-shot or few-shot answer generators (the paper does not specify prompting details for baselines, though prompts for the main models are shown in Appendix B). Reasoning general models: DeepSeek-R1 (Guo et al., 2025), DeepSeek-R1-Distill-Qwen-7B, DeepSeek-R1-Distill-Qwen-14B, DeepSeek-R1-Distill-Qwen-32B, and QwQ-32B (Qwen, 2024). These are models specifically trained to produce chain-of-thought reasoning before answering, making them the most relevant comparators for DianJin-R1's reasoning-augmented approach. Notably absent from baselines: other financial-domain LLMs like FinMA or BloombergGPT, which would provide domain-specialized non-reasoning baselines, or Fin-R1 (Liu et al., 2025), a contemporaneous financial reasoning model that would be the most direct competitor.

• Generation budget / compute accounting. For all single-call models (all baselines plus DianJin-R1), the generation budget is 1 API call or 1 forward pass per instance — the model produces reasoning and answer in a single autoregressive generation. For the multi-agent Qwen2.5-72B-Instruct baseline on CCC (Table 6), the cost is measured in average number of API calls per instance (8.15), with each call invoking a 72B-parameter model, providing a direct computational cost comparison. The paper does not account for different generation lengths across models — a reasoning model that produces 1,000 tokens of chain-of-thought uses more inference FLOPs than a non-reasoning model producing 10 tokens, but this is not normalized in the main accuracy comparisons. Training cost (GPU-hours for SFT and RL) is described qualitatively but not quantified as a FLOPs budget.

• Cross-validation / statistical protocol. The paper does not report cross-validation, confidence intervals, or statistical significance tests for any result. The test sets are used as fixed evaluation benchmarks — each model is evaluated once on the full test set, and accuracies are reported as point estimates. For the ablation studies (Tables 4 and 5), the same test sets are used to compare training configurations, meaning the ablations are not cross-validated and model selection could be overfit to the specific test-set instances. The CCC test set size of 200 instances means each percentage point corresponds to 2 questions, so differences of 1–2 points between DianJin-R1 models and the multi-agent baseline are within sampling noise. The paper does not discuss this limitation.

Main Quantitative Results

Financial Domain Performance: DianJin-R1 Achieves State-of-the-Art on Specialized Benchmarks

The central result is Table 3, which reports accuracy across all five benchmarks for 12 models. On the three financial benchmarks, DianJin-R1-32B achieves the best or tied-for-best performance:

• CFLUE: 86.74% (best overall), compared to DeepSeek-R1 at 86.64% (underlined as second-best) and Qwen2.5-32B-Instruct at 77.95%. The improvement over the base model is +8.79 percentage points, and over the strongest non-reasoning baseline (Qwen2.5-72B-Instruct at 79.46%) is +7.28 points.

• FinQA: 80.82% (tied for second-best with DeepSeek-V3 at 81.34%, which is best). Compared to Qwen2.5-32B-Instruct at 79.51%, the improvement is +1.31 points — a much smaller gain than on CFLUE. DeepSeek-R1 scores 79.81%, below its non-reasoning counterpart DeepSeek-V3 (81.34%), illustrating the domain-transfer failure.

• CCC: 96.00% (best overall). The improvement over Qwen2.5-32B-Instruct at 56.50% is +39.50 percentage points — the largest gain on any benchmark, reflecting the specialized compliance training data. DianJin-R1-7B achieves 94.50%, demonstrating that even the smaller model internalizes the compliance reasoning effectively.

DianJin-R1-7B shows a more mixed profile: 80.32% on CFLUE (third-best, behind DeepSeek-R1 and DianJin-R1-32B but ahead of QwQ-32B at 83.49%), 77.72% on FinQA (underlined as second-best, notably ahead of Qwen2.5-32B-Instruct at 79.51%), and 94.50% on CCC. The 7B model outperforms DeepSeek-R1-Distill-Qwen-14B (70.83% on CFLUE, 76.63% on FinQA, 50.00% on CCC) by large margins on financial tasks despite having half the parameters, demonstrating that domain-specific reasoning training can compensate for smaller model scale.

The average accuracy column tells a nuanced story. DianJin-R1-32B achieves the highest average at 82.07%, ahead of DeepSeek-R1 at 78.98%. However, this average is dominated by financial benchmarks where DianJin-R1 has been specifically trained — the advantage over general reasoning models is large on CFLUE and CCC but small on FinQA, and DianJin-R1 trails general reasoning models on MATH-500 and GPQA-Diamond. The average is best interpreted as a summary of domain-specialized performance with general-reasoning as a secondary axis.

General Domain Performance: Financial Reasoning Training Provides Limited Transfer to Math and Science

Table 3 also reports performance on MATH-500 and GPQA-Diamond, where DianJin-R1 models were not specifically trained:

• MATH-500: DianJin-R1-32B achieves 88.20%, compared to Qwen2.5-32B-Instruct at 81.00% (+7.20 points). This is a meaningful improvement from financial reasoning training, suggesting some transfer of reasoning capability. However, DeepSeek-R1-Distill-Qwen-32B and QwQ-32B both achieve 95.00% — a 6.80-point gap that represents the ceiling of general-purpose reasoning training on math data. DianJin-R1-7B at 76.60% improves over Qwen2.5-7B-Instruct at 71.40% (+5.20 points) but trails DeepSeek-R1-Distill-Qwen-7B at 90.20% by 13.60 points.

• GPQA-Diamond: DianJin-R1-32B achieves 58.59%, up from Qwen2.5-32B-Instruct at 44.95% (+13.64 points). DeepSeek-R1 achieves 66.16% (best), and DeepSeek-R1-Distill-Qwen-32B/QwQ-32B achieve 63.64%. DianJin-R1-7B at 37.54% shows minimal improvement over Qwen2.5-7B-Instruct at 33.84% (+3.70 points), suggesting the 7B model hits a ceiling on graduate-level science QA that financial reasoning training cannot overcome.

The pattern is consistent: financial reasoning training improves general-domain performance relative to the non-reasoning base, but the gains are substantially smaller than those from general-domain reasoning training. The paper acknowledges this in Section 3.2: "since our SFT and RL training pipelines do not incorporate any general-domain reasoning datasets, the performance of DianJin-R1 models on these benchmarks remains lower than that of models with larger parameter sizes or those fine-tuned on general reasoning data." This is an honest acknowledgment of a limitation — DianJin-R1 optimizes for financial-domain accuracy at the expense of general reasoning capability.

The Catastrophic Transfer Failure of General Reasoning Models on CFLUE

One of the most striking results in Table 3 is not about DianJin-R1 at all but about the baselines: DeepSeek-R1-Distill-Qwen-7B scores 48.39% on CFLUE, compared to 69.37% for Qwen2.5-7B-Instruct (the base model it was distilled from) and 80.32% for DianJin-R1-7B (the same architecture fine-tuned on financial reasoning data). This is a 20.98-point degradation from adding general reasoning distillation, and a 31.93-point gap to domain-specialized reasoning training on the same base architecture.

This is not an isolated failure mode for the 7B scale. DeepSeek-R1-Distill-Qwen-14B scores 70.83% on CFLUE — still below the non-reasoning Qwen2.5-32B-Instruct at 77.95% despite having reasoning capabilities. DeepSeek-R1-Distill-Qwen-32B at 78.52% barely exceeds the non-reasoning Qwen2.5-32B-Instruct at 77.95%, gaining only 0.57 points from reasoning training. The only general reasoning model that substantially outperforms non-reasoning baselines on CFLUE is DeepSeek-R1 itself at 86.64%, and even this trails DianJin-R1-32B at 86.74% (though the 0.10-point difference is negligible given the 3,864-instance test set).

This pattern — general reasoning distillation degrading financial performance at smaller scales, breaking even at 32B, and showing gains only at the full DeepSeek-R1 scale — suggests that smaller models are more vulnerable to negative transfer from general reasoning training, possibly because their limited capacity forces a tradeoff between general reasoning patterns and domain-specific knowledge. The larger DeepSeek-R1 (671B parameters) has enough capacity to retain domain knowledge alongside learned reasoning, but the distilled 7B, 14B, and even 32B variants lose financial competence in the process of acquiring reasoning patterns optimized for math and science.

SFT vs. RL Contributions: Both Stages Matter, But RL Is Domain-Language-Specific

Table 4 decomposes the contribution of SFT and RL to DianJin-R1-7B's performance, starting from Qwen2.5-7B-Instruct:

• SFT alone: CFLUE improves from 69.37% to 75.48% (+6.11 points), FinQA from 66.70% to 80.28% (+13.58 points), CCC from 55.00% to 93.00% (+38.00 points), MATH-500 from 71.40% to 74.87% (+3.47 points), GPQA-Diamond from 33.84% to 34.85% (+1.01 points). The average jumps from 59.26% to 71.70%.

• SFT + RL: CFLUE further improves to 80.32% (+4.84 points over SFT alone), CCC to 94.50% (+1.50 points), MATH-500 to 76.60% (+1.73 points), GPQA-Diamond to 37.54% (+2.69 points). However, FinQA drops from 80.28% to 77.72% (−2.56 points). Average improves to 73.34%.

The headline finding — that SFT provides the majority of the gains and RL adds further improvement on most benchmarks — partially supports the paper's two-stage training design. However, the FinQA regression is a critical negative result. The paper's explanation in Section 3.3 is worth quoting verbatim:

"We suspect this exception may be due to the fact that all instances used for RL are in Chinese and sourced from CFLUE, whereas FinQA is in English."

This interpretation is plausible: the RL stage optimizes the model to produce reasoning patterns and answer formats specific to Chinese multiple-choice financial questions, and this optimization comes at the expense of the English numerical reasoning capability learned during SFT. It is a concrete demonstration that RL in one language can negatively transfer to another, even within the same domain (financial reasoning). The paper cannot quantify this because they did not run an ablation with English RL data or with RL applied only to the Chinese benchmarks.

A less-discussed implication: the RL stage uses 4,096 hard-case CFLUE instances (Table 1), which is a small fraction of the 31,717 CFLUE instances used in SFT. The fact that this small RL dataset produces a 4.84-point CFLUE improvement suggests the hard cases are high-leverage training examples — questions where the SFT model is close to the right answer but produces slightly wrong reasoning, and RL's accuracy reward pushes it over the threshold. This is consistent with the hard-case split innovation but cannot be verified without analyzing the difficulty distribution of the 4,096 RL instances.

Data Source Ablation: CFLUE Dominates, Other Sources Provide Marginal Improvements

Table 5 ablates the contribution of each data source to SFT (without RL) using Qwen2.5-7B-Instruct as the base:

• CFLUE alone (31,717 instances): CFLUE accuracy 75.09%, FinQA 71.65%, CCC 70.50%, MATH-500 75.07%, GPQA-Diamond 36.03%, average 65.67%. Compared to the untrained baseline (59.26%), this is a +6.41-point average gain, driven primarily by CFLUE (+5.72 points) and CCC (+15.50 points).

• CFLUE + FinQA: FinQA jumps from 71.65% to 80.85% (+9.20 points), but CFLUE (75.20% vs. 75.09%), CCC (70.00% vs. 70.50%), MATH-500 (75.33% vs. 75.07%), and GPQA-Diamond (36.03% vs. 36.03%) are essentially unchanged. Average increases to 67.48%.

• CFLUE + CCC: CCC jumps from 70.50% to 95.00% (+24.50 points), MATH-500 increases to 76.27% (+1.20 points over CFLUE alone), but FinQA (71.78% vs. 71.65%) and GPQA-Diamond (35.35% vs. 36.03%) show marginal changes. Average increases to 70.71%.

• CFLUE + CCC + FinQA (the full SFT dataset): CFLUE 75.48%, FinQA 80.28%, CCC 93.00%, MATH-500 74.87%, GPQA-Diamond 34.85%, average 71.70%.

Three observations stand out:

1. CFLUE provides broad transfer, not just CFLUE-specific improvement. Training on CFLUE alone lifts all benchmarks, including English FinQA (71.65% vs. 66.70% baseline) and general MATH-500 (75.07% vs. 71.40% baseline). The 31,717 Chinese financial exam questions apparently teach reasoning patterns that transfer across languages and partially to math. This supports a position between the paper's strong domain-specificity claim and the null hypothesis of perfect transfer: financial reasoning training transfers better than general reasoning training for financial tasks, and provides modest benefits for non-financial reasoning.

2. Each dataset primarily improves its own benchmark, with limited cross-task transfer beyond CFLUE's broad effect. Adding FinQA to CFLUE helps FinQA by +9.20 points but barely moves CFLUE, CCC, or general benchmarks. Adding CCC to CFLUE helps CCC by +24.50 points but does not meaningfully affect FinQA. This is expected — FinQA teaches numerical reasoning from financial reports, CCC teaches structured compliance checking — but it highlights that the training data is task-specialized and the model's capabilities remain somewhat siloed even after multi-task SFT.

3. The full dataset (CFLUE + FinQA + CCC) does not always outperform subsets on individual benchmarks. On CCC, CFLUE + CCC achieves 95.00% while the full dataset achieves 93.00% — a 2-point drop from adding FinQA. On MATH-500, CFLUE alone achieves 75.07% while the full dataset achieves 74.87% — a negligible difference but in the wrong direction. On GPQA-Diamond, CFLUE alone achieves 36.03% while the full dataset achieves 34.85% — a 1.18-point drop. This suggests negative interference between the datasets: the model's capacity (7B parameters) may be stretched by learning three distinct reasoning formats (Chinese multiple-choice with options, English numerical reasoning, Chinese compliance workflow), and the multi-task optimization slightly degrades performance on tasks where single-dataset training suffices. The 32B model, with larger capacity, might not show this interference — but the ablation is only reported for the 7B model.

CCC Efficiency Result: Single-Call Reasoning Matches Multi-Agent Accuracy

Table 6 presents the efficiency-accuracy tradeoff on CCC:

The multi-agent system (using Qwen2.5-72B-Instruct agents at each condition node) improves accuracy by 39.50 points over the single-call baseline, demonstrating that the workflow decomposition is highly effective — the task genuinely benefits from structured multi-step reasoning. However, the 8.15× inference cost multiplier makes this approach expensive at scale.

DianJin-R1-7B at 94.50% is within 0.50 points of the multi-agent accuracy — a gap of exactly 1 question on the 200-instance test set, making the difference statistically indistinguishable from noise. DianJin-R1-32B at 96.00% exceeds the multi-agent system by 1.00 point (2 questions). Both DianJin-R1 models achieve this with a single API call, representing an 8.15× reduction in inference cost relative to the multi-agent baseline.

What this means: The paper demonstrates that a reasoning model trained on multi-agent-generated reasoning traces can internalize the multi-step compliance workflow and execute it in a single forward pass, matching or exceeding the accuracy of the multi-agent system that generated its training data. This is not just distillation — it is workflow compression, where the explicit decision tree encoded in the multi-agent architecture becomes implicit in the model's autoregressive generation. The model learns to navigate the condition checks sequentially without external orchestration.

Ablation Studies and Robustness Checks

Effect of RL stage (Table 4): RL improves performance on 4 of 5 benchmarks relative to SFT alone (+4.84 points on CFLUE, +1.50 on CCC, +1.73 on MATH-500, +2.69 on GPQA-Diamond) but reduces FinQA by 2.56 points, confirming that the Chinese-language CFLUE-based RL data does not transfer to English numerical reasoning. This is a genuine negative result that qualifies the paper's claim that RL "enhances reasoning quality" — it enhances reasoning quality in the language and format of the RL training data.

Effect of different SFT data sources (Table 5): CFLUE alone provides a +6.41-point average improvement over the untrained baseline, demonstrating that financial exam reasoning transfers broadly. Adding FinQA specifically improves FinQA (+9.20 points) but produces negligible or negative cross-task effects. Adding CCC specifically improves CCC (+24.50 points) and slightly helps MATH-500 but not other benchmarks. The full three-dataset combination does not strictly dominate the best subset configurations on all individual benchmarks, suggesting negative interference at the 7B scale.

Effect of model scale (Table 3, comparing 7B vs. 32B): DianJin-R1-32B outperforms DianJin-R1-7B on all five benchmarks, with particularly large gaps on CFLUE (+6.42 points, 86.74% vs. 80.32%), MATH-500 (+11.60 points, 88.20% vs. 76.60%), and GPQA-Diamond (+21.05 points, 58.59% vs. 37.54%). The gap is smaller on FinQA (+3.10 points) and negligible on CCC (+1.50 points, 96.00% vs. 94.50%). The general-domain gaps are expected — larger models have more capacity for math and science knowledge — but the small CCC gap suggests the compliance reasoning task is sufficiently constrained that even the 7B model can near-saturate performance after domain-specific training.

Effect of multi-agent workflow on CCC (Table 6): Decomposing CCC into condition-node agents improves Qwen2.5-72B-Instruct from 55.50% to 95.00% (+39.50 points) at the cost of 8.15× more API calls, validating that the structured workflow is essential for this task. The DianJin-R1 models replicate this gain at single-call cost.

Critical Assessment

Does DianJin-R1 "consistently outperform non-reasoning counterparts" on financial tasks?

The claim that reasoning-augmented DianJin-R1 models outperform their non-reasoning Qwen2.5-Instruct bases is clearly supported: DianJin-R1-32B improves on all five benchmarks relative to Qwen2.5-32B-Instruct (Table 3), with gains ranging from +1.31 points (FinQA) to +39.50 points (CCC). DianJin-R1-7B similarly improves on all benchmarks except FinQA where SFT+RL produces 77.72% vs. 66.70% for the base — still a gain, though the ablation in Table 4 shows this is entirely from SFT (80.28%) with RL degrading it. The claim holds broadly but the FinQA nuance matters: the full DianJin-R1 pipeline (SFT+RL) delivers mixed results on FinQA, and the paper's explanation (language mismatch in RL data) is post-hoc.

However, the broader implicit claim — that domain-specialized reasoning training is necessary for financial tasks — requires comparing against general reasoning models, not just non-reasoning bases. Here the evidence is mixed: DianJin-R1-32B at 86.74% on CFLUE is only marginally ahead of DeepSeek-R1 at 86.64% (0.10 points). DianJin-R1-32B at 80.82% on FinQA is slightly below DeepSeek-V3 at 81.34%. The CCC result is the strongest case for domain-specialization (96.00% vs. DeepSeek-R1's 67.50%), but CCC is also the smallest test set (200 instances) and the closest to the training distribution (CCC training data included 1,800 instances from the same domain). The claim that domain specialization outperforms general reasoning holds strongly for in-domain, in-distribution tasks (CCC, CFLUE to a lesser extent) but weakens for tasks that also benefit from broad reasoning capability (FinQA, where DeepSeek-V3 ties or exceeds).

Does single-call reasoning "match or even surpass" multi-agent system performance at lower cost?

This is the paper's most striking claim and it is well-supported for the specific CCC configuration tested. DianJin-R1-7B at 94.50% with 1 call is statistically equivalent to Qwen2.5-72B-Instruct multi-agent at 95.00% with 8.15 calls (Table 6), and DianJin-R1-32B at 96.00% exceeds it. The efficiency gain is 8.15× in API calls.

However, several qualifications narrow the scope of this claim:

• The multi-agent baseline is not optimized. The paper uses Qwen2.5-72B-Instruct with node-specific prompts but does not explore whether better prompting, different agent models, or improved agent coordination could push the multi-agent system higher. The 95.00% is presented as a ceiling, but it may not be — a stronger multi-agent system (using reasoning models as agents, or with iteration between agents) might achieve higher accuracy that DianJin-R1 cannot match with a single call.

• The single-call model was trained on data generated by a multi-agent system using the same workflow. The DianJin-R1 models are essentially distilling the multi-agent system — they learn to replicate the reasoning patterns that the multi-agent system produced during data generation. This is not an independent demonstration that single-call models can replace multi-agent systems in general; it is a demonstration that a multi-agent system can be compressed into a single model for this specific task. The result would be more compelling if the training data were generated by a different method (e.g., human experts writing reasoning traces) and the model still matched multi-agent performance.

• The test set is 200 instances. A 0.50-point difference between DianJin-R1-7B and the multi-agent baseline corresponds to exactly 1 question. The claim that DianJin-R1 "matches" multi-agent performance rests on this single-question margin, which could easily flip with a different random split or slightly different evaluation criteria.

• The claim does not extend to other tasks. The paper does not demonstrate single-call models matching multi-agent systems on CFLUE, FinQA, or general benchmarks — only on CCC, where the task structure (a predefined decision workflow) makes it particularly amenable to compression into a coherent reasoning chain. This is a proof of concept, not a general result.

Does financial reasoning training enhance general reasoning capabilities?

The paper claims that "training on financial reasoning data can enhance general reasoning capabilities to some extent" (Section 3.2), and the evidence for this is that DianJin-R1-32B improves on MATH-500 (81.00% → 88.20%) and GPQA-Diamond (44.95% → 58.59%) relative to Qwen2.5-32B-Instruct. These are non-trivial gains (+7.20 and +13.64 points respectively).

But "to some extent" is doing a lot of work here. The gains are substantially smaller than what general reasoning training achieves: DeepSeek-R1-Distill-Qwen-32B reaches 95.00% on MATH-500 (6.80 points ahead of DianJin-R1-32B), and DeepSeek-R1 reaches 66.16% on GPQA-Diamond (7.57 points ahead). The financial reasoning training provides about half to two-thirds of the gain that general reasoning training would, on benchmarks where the model was not specifically trained. This is a meaningful but bounded transfer effect — consistent with the paper's own domain-specificity argument (reasoning is not fully domain-agnostic) but also showing some cross-domain benefit.

For the 7B model, the transfer is weaker: DianJin-R1-7B reaches 76.60% on MATH-500 (vs. 71.40% base, +5.20 points) and 37.54% on GPQA-Diamond (vs. 33.84% base, +3.70 points). These are modest gains that trail DeepSeek-R1-Distill-Qwen-7B's 90.20% on MATH-500 by 13.60 points, confirming that at smaller scales, domain-specific reasoning training does not substitute for general reasoning training on out-of-domain benchmarks.

Missing experiments that would strengthen the paper

Several experiments are conspicuously absent:

• No human evaluation of reasoning quality. The paper uses GPT-4o to verify reasoning consistency during data construction and to evaluate answer correctness on FinQA and CCC. But the quality of the generated reasoning — whether it is factually correct, logically coherent, and free of domain errors — is never directly evaluated by human experts. The paper claims "interpretability" as a benefit (Section 4) but provides no evidence that the reasoning chains are actually interpretable to human auditors. A small-scale human evaluation of reasoning traces, particularly on CCC where regulatory compliance has legal consequences, would substantially strengthen this claim.

• No comparison to non-reasoning financial models. The baseline set includes general-purpose models (GPT-4o, DeepSeek-V3, Qwen2.5-Instruct) and general reasoning models (DeepSeek-R1, QwQ-32B), but no financial-domain-specific models that were trained without explicit reasoning. Comparing against a model like FinMA (fine-tuned on financial data without chain-of-thought training) would isolate the contribution of reasoning augmentation from the contribution of domain-specific data. Without this baseline, it is unclear whether DianJin-R1's gains come from the financial training data, the reasoning format, or the specific combination.

• No evaluation on the full CFLUE or FinQA test sets as reported in their original papers. CFLUE's original benchmark (Zhu et al., 2024) includes multiple task categories beyond knowledge assessment (sentiment analysis, event detection, etc.). The paper uses only the knowledge assessment subset (multiple-choice exam questions), which is the most reasoning-intensive but not representative of all financial NLP tasks. The results do not speak to DianJin-R1's performance on other financial language understanding tasks.

• No analysis of which CFLUE question types benefit most from reasoning. CFLUE covers 15 financial qualification exam categories (securities, banking, insurance, accounting, etc.). The paper does not break down performance by subject area, which would reveal whether the reasoning training helps uniformly or only for certain types of financial knowledge (e.g., quantitative finance vs. regulatory compliance). This analysis would strengthen the domain-specificity argument by showing which sub-domains within finance benefit from reasoning.

• No statistical treatment of small test sets. The CCC test set has 200 instances and GPQA-Diamond has 198. Differences of 1–3 percentage points on these sets (which correspond to 2–6 questions) are not statistically reliable, yet the paper treats all differences as meaningful. Reporting confidence intervals or conducting McNemar's test for paired comparisons would clarify which differences are likely to replicate.

• No exploration of why RL hurts FinQA. The paper notes the FinQA degradation after RL (Table 4) and hypothesizes it is due to Chinese-only RL data, but does not run the obvious ablation: apply RL with English FinQA data and measure whether the degradation disappears. This is a one-experiment fix that would either confirm the hypothesis or reveal a deeper issue. The statement that "we will include... in the future" (footnote 1) acknowledges this gap but does not close it.

Conditions under which claims hold

The paper's central claims are best understood as holding under specific conditions that the experiments partially but not fully delineate:

• Domain-specific reasoning training substantially outperforms general reasoning training — holds when the target task requires domain knowledge that general reasoning models lack (CCC: 96.00% vs. 67.50%) and the training data includes reasoning traces verified for domain consistency. Weakens when the target task is close to the general reasoning training distribution (FinQA: 80.82% vs. 79.81% for DeepSeek-R1).

• Single-call reasoning models can match multi-agent systems — holds when (a) the task has a well-defined workflow that can be encoded in training data, (b) the training data is generated by the same or similar multi-agent system, (c) the test set is drawn from the same distribution as the training data, and (d) the multi-agent system is not optimized beyond its initial configuration. Whether this generalizes to other tasks or workflows is not demonstrated.

• RL enhances reasoning beyond SFT — holds for in-language, in-format tasks (Chinese multiple-choice: +4.84 points on CFLUE, Table 4) but can harm cross-language performance (English FinQA: −2.56 points). The benefit of RL is data-language-dependent, which the paper acknowledges but does not fully characterize.

• Financial reasoning training transfers partially to general reasoning — holds with the qualification that gains are meaningful (+7–14 points on MATH-500 and GPQA-Diamond for the 32B model, Table 3) but smaller than what general reasoning training would achieve, and the transfer is weaker at smaller model scales.

6. Limitations and Trade-offs

6.1 Difficulty Estimation for Hard Cases is Never Performed or Validated

The assumption or constraint. The paper's data construction pipeline classifies training instances as "hard cases" when DeepSeek-R1 fails to produce verified reasoning within 3 retry attempts (Section 2.2.1). These instances — which form the RL training set G_CFLUE_MCQ — are assumed to require reasoning capabilities beyond what the teacher model can provide. However, the paper never validates whether the 3-retry classification actually identifies genuinely hard questions or is simply a noisy label driven by DeepSeek-R1's stochastic generation. The paper states that "if all attempts fail to produce a correct answer and consistent reasoning, the instance is considered a hard case" (Section 2.2.1), but provides no analysis of failure patterns.

The consequence. The hard-case classification determines which instances go to RL (for capability discovery) versus SFT (for imitation). A noisy classification means that the "hard" RL set likely contains a mixture of genuinely difficult questions (where the teacher model lacks domain knowledge), unlucky sampling failures (where the teacher could produce correct reasoning but did not in 3 attempts), and verification errors (where GPT-4o incorrectly judged a valid reasoning trace as inconsistent). The model is then rewarded for exploring its own reasoning on instances where the ground-truth reasoning quality is unknown — by definition, these instances have no verified reasoning trace. The consequence is that RL may reinforce incorrect reasoning patterns on instances where the teacher's failure was due to verification noise rather than genuine difficulty, potentially degrading rather than improving reasoning quality on borderline cases. The FinQA degradation after RL (Table 4: 80.28% → 77.72%) could partially reflect this: if some FinQA-like numerical reasoning patterns were inappropriately penalized during RL because the CFLUE hard-case set contained structurally similar instances with noisy classification, the model would unlearn useful behaviors.

What evidence exists in the paper. The paper provides no analysis of hard-case classification quality. There is no measurement of: (a) the inter-attempt consistency of DeepSeek-R1's outputs on the same questions, (b) the false-negative rate of GPT-4o's verification (how often does it reject reasoning that a human would accept?), (c) the distribution of question difficulty within the hard-case set versus the verified set, or (d) whether the 3-attempt threshold is well-calibrated (e.g., what fraction of instances succeed on attempt 3 vs. attempt 1?). The RL ablation in Table 4 shows that RL helps on 4 benchmarks but hurts FinQA, which is consistent with (but does not prove) noisy classification. The G_CFLUE_MCQ set contains 4,096 instances (Table 1), representing approximately 13% of the 31,717 CFLUE training instances — a substantial fraction whose labeling fidelity is unexamined.

Mitigation status. Not addressed. The paper does not discuss hard-case classification quality as a concern, does not report any validation of the classification, and does not propose methods for improving it (e.g., increasing retry attempts, using multiple teacher models, or having humans audit a sample). The future work statement about including other datasets in RL (footnote 1 in Section 2.3.2) suggests expanding the RL data but not improving its quality.

6.2 Difficulty Estimation Cost is Not Accounted For in Any Reported Efficiency Gain

The assumption or constraint. The paper's headline efficiency result — single-call DianJin-R1 models matching multi-agent accuracy at 8.15× lower inference cost (Table 6) — accounts only for inference-time cost after the model is trained. The cost of constructing the training data that makes this possible is never quantified or amortized. Specifically, the reasoning data generation pipeline requires: (1) DeepSeek-R1 inference (with up to 3 retries per instance) for 38,368 SFT instances across CFLUE, FinQA, and CCC; (2) GPT-4o verification (two evaluations per generation: answer correctness and reasoning consistency); (3) multi-agent Qwen2.5-72B-Instruct inference across 1,800 CCC dialogues, averaging 8.15 agent calls per dialogue, plus GPT-4o merging of intermediate reasoning chains; (4) GPT-4o conversion of 5,045 CFLUE MCQ questions to open-ended format. None of these costs appear in any table or efficiency analysis.

The consequence. The claim that DianJin-R1 provides a "scalable and practical solution for real-world applications" (Section 1) is only partially supported if the data construction cost is excluded. For an organization considering deploying DianJin-R1 for their own compliance checking use case, the total cost is not 1 API call per inference — it is the upfront cost of (a) defining a multi-agent workflow, (b) running a teacher model (potentially DeepSeek-R1-level, requiring significant compute) to generate reasoning traces on their domain data, (c) running GPT-4o as a verifier, and (d) training the SFT+RL pipeline. For the specific CCC task studied, this amortized cost may be justifiable given the 8.15× inference savings at production scale, but the paper provides no break-even analysis to help practitioners determine when the upfront investment pays off. For smaller-scale deployments or tasks where the inference volume is low, the data construction cost could dominate the total lifetime cost, making the approach less "scalable and practical" than claimed.

What evidence exists in the paper. The paper provides no cost accounting for data construction. The #Calls column in Table 6 measures only inference-time costs for the deployed models. The training compute is described qualitatively (Section 3.1: "7B model is trained on a single node with 8 GPUs, and the 32B model uses 32 GPUs across 4 nodes") but not translated into GPU-hours, dollar costs, or FLOPs. The multi-agent system's 8.15 calls per instance for data generation (on 1,800 CCC examples, totaling ~14,670 agent calls) is separate from the multi-agent system's 8.15 calls per instance for inference (reported in Table 6), but only the latter is counted in the efficiency comparison. The DeepSeek-R1 inference cost for generating reasoning on 38,368 training instances, with up to 3 retries (potentially ~100,000+ DeepSeek-R1 calls), plus GPT-4o verification on each, is entirely unaccounted.

Mitigation status. Not addressed. The paper does not mention data construction cost as a limitation or propose methods for reducing it (e.g., using cheaper teacher models, reducing verification passes, or amortizing cost estimates). The future work section (Section 4) discusses "alternative reinforcement learning strategies" and "tool-augmented reasoning" but does not address data construction efficiency.

6.3 RL Training Data is Monolingual and Single-Format, Producing Negative Transfer to English Tasks

The assumption or constraint. The RL stage uses only 4,096 Chinese multiple-choice questions from CFLUE (Table 1, Section 2.3.2). The accuracy reward is applied "exclusively to multiple-choice questions" (footnote 2 in Section 2.3.2), and the format reward enforces a specific ⟨think⟩...⟨/think⟩⟨answer⟩...⟨/answer⟩ structure. The paper implicitly assumes that RL optimization on this data will transfer positively or at least neutrally to other languages (English FinQA), other formats (open-ended answers in CFLUE_OE), and other task structures (compliance dialogue reasoning in CCC). This assumption is inconsistent with the paper's own central finding that reasoning is domain-specific (Innovation 1 in Section 4) — if general math reasoning does not transfer to financial reasoning, why would Chinese multiple-choice RL transfer to English numerical reasoning?

The consequence. The assumption fails empirically: RL degrades FinQA accuracy from 80.28% (SFT-only) to 77.72% (SFT+RL), a 2.56-point drop (Table 4). This is a genuine negative transfer: the optimization that improves CFLUE multiple-choice performance (+4.84 points) simultaneously harms English open-ended numerical reasoning. The paper's post-hoc explanation — "all instances used for RL are in Chinese and sourced from CFLUE, whereas FinQA is in English" (Section 3.3) — acknowledges the language mismatch but does not address the format mismatch: RL rewards the model for producing short answers (typically a single letter or number) within ⟨answer⟩ tags, while FinQA requires numerical answers that may involve units, percentages, or formatted values. The model optimized for single-token answers may learn to truncate or simplify its FinQA outputs, reducing accuracy. For practitioners, this means the full DianJin-R1 pipeline (SFT+RL) is not uniformly beneficial — it improves Chinese multiple-choice tasks at the cost of English open-ended tasks, creating a deployment tradeoff where model selection depends on the target language and format mix.

What evidence exists in the paper. Table 4 provides direct evidence of the negative transfer. The SFT-only row shows FinQA at 80.28%; the SFT+RL row shows 77.72%. This is the only regression in the RL ablation, and it is not a small one — 2.56 points on a 1,147-instance test set represents approximately 29 questions. Table 3 provides additional context: DianJin-R1-7B (SFT+RL) at 77.72% on FinQA is below the SFT-only result and also below Qwen2.5-32B-Instruct at 79.51%, meaning the RL optimization for a 7B model produces FinQA performance below a non-reasoning 32B model. The paper does not ablate RL with English data or open-ended format data, so the hypothesis that language/format mismatch causes the regression, while plausible, is not experimentally confirmed.

Mitigation status. Partially addressed through future work. The paper states in footnote 1 (Section 2.3.2): "In the future, we will include G_CFLUE_OE, G_FinQA, and G_CCC in RL." This acknowledges the limitation and proposes a direct fix — adding English and open-ended RL data should reduce or eliminate the negative transfer. However, the fix is proposed but not implemented, and the paper does not discuss whether simply adding more data would resolve the issue or whether more fundamental changes to the RL reward structure (e.g., language-conditioned rewards, separate RL phases per language) are needed.

6.4 Single Benchmark, Single Domain, Single Model Family — No Evidence of Generalization Beyond the Training Distribution

The constraint. All experiments use a single base model family (Qwen2.5-Instruct, 7B and 32B variants), a single domain (financial reasoning, with CFLUE, FinQA, and CCC covering three sub-tasks within that domain), and a single evaluation paradigm (accuracy on benchmark test sets drawn from the same distributions as the training data). The paper provides no experiments on other model families (e.g., LLaMA, Mistral), other domains (e.g., legal reasoning, medical diagnosis), other task formats (e.g., structured prediction, information extraction, summarization), or out-of-distribution evaluations (e.g., CFLUE questions from exam categories not represented in training, or FinQA questions from financial reports of companies in different sectors). The paper's claim that DianJin-R1 offers a "scalable and practical solution for real-world applications" (Section 1) implicitly assumes these results generalize.

The consequence. A practitioner considering DianJin-R1 for a different domain (e.g., legal compliance checking, medical coding, insurance claims processing) cannot determine from this paper whether the approach would work. The central findings — that domain-specialized reasoning training outperforms general reasoning, that multi-agent workflows can be distilled into single-call models, that CFLUE provides broad transfer — may all be specific to financial exam-style reasoning. Financial qualification exams have a particular structure (multiple-choice with domain-specific options, detailed explanations available for verification, clear correct answers) that may not exist in other domains. The CFLUE-to-other-benchmarks transfer observed in Table 5 (CFLUE alone improves CCC by +15.50 points and MATH-500 by +3.67 points) could be driven by the breadth of CFLUE's 15 exam categories rather than a general property of domain-specialized reasoning training. For a domain with narrower training data or different reasoning patterns, the transfer might be minimal or negative (as general reasoning training produced negative transfer to CFLUE for smaller models).

Even within the financial domain, generalization is uncertain. The CCC test set of 200 instances is drawn from the same customer-service quality inspection system that provided the 1,800 training instances. The near-saturated performance (94.50–96.00%, Table 6) may reflect overfitting to the specific compliance guidelines, dialogue patterns, and violation types in this system rather than general compliance-checking capability. A different financial institution with different compliance rules, different customer service scripts, or different violation categories might see substantially lower accuracy.

What evidence exists in the paper. No cross-domain, cross-model-family, or out-of-distribution experiments are reported. The paper evaluates only on benchmarks whose training splits were used (or whose close relatives were used) during DianJin-R1-Data construction. Table 3 compares against models from different families (GPT-4o, DeepSeek) but does not train DianJin-R1-style models on those families — the Qwen2.5 base model choice is fixed. The ablation in Table 5 shows that CFLUE training transfers to other financial benchmarks and partially to general benchmarks, but this is in-distribution transfer (all benchmarks are standard evaluation sets) rather than out-of-distribution generalization.

The paper acknowledges the model-family limitation implicitly by stating the base models were chosen because they are "representative of the capabilities of many contemporary LLMs" (not quoted in the paper directly; this is an interpretive claim). But "representative" is not demonstrated — Qwen2.5-Instruct may have specific properties (instruction-following quality, knowledge cutoff, pretraining data composition) that interact with the financial reasoning training in ways that other model families would not replicate.

Mitigation status. Not addressed. The paper does not discuss generalization scope as a limitation, does not propose cross-domain or cross-model-family experiments for future work, and does not qualify its claims with appropriate scope constraints. The future work section focuses on "alternative reinforcement learning strategies" and "tool-augmented reasoning" (Section 4) rather than broader validation.

6.5 The Structured Output Format Enables Automation but Creates a Single Point of Failure with No Graceful Degradation

The assumption or constraint. The entire training and evaluation pipeline depends on the ⟨think⟩...⟨/think⟩⟨answer⟩...⟨/answer⟩ format being produced exactly. The format reward in RL is binary: 1 if the output contains exactly one think block and one answer block with nothing outside, 0 otherwise (Section 2.3.2). The accuracy reward depends on extracting content from within the ⟨answer⟩ tags. The rule-based evaluation for CFLUE, MATH-500, and GPQA-Diamond (Section 3.1) similarly depends on deterministic answer extraction from these tags. The paper assumes that the trained model will reliably produce this format at inference time, and that format deviations are necessarily errors to be penalized.

The consequence. In production deployment, format deviations are inevitable — the model may produce malformed tags (e.g., ⟨think⟩...⟨/think⟩⟨answer⟩... without closing), multiple think blocks (if it re-evaluates after an initial answer), or extraneous text outside the tags (e.g., a preamble acknowledging the question). Under the current system design, any such deviation produces an unparseable output: the rule-based extractor cannot identify the answer, the accuracy metric cannot be computed, and the output is essentially useless without manual intervention. There is no fallback mechanism, no partial credit, and no graceful degradation — a single missing ⟨/answer⟩ tag renders the entire inference call wasted. This is a reliability concern for high-stakes financial applications where every inference call may correspond to a compliance decision with legal consequences. A model that produces correct reasoning 99% of the time but malformed formatting 5% of the time would have an effective accuracy far below its benchmark score, because the 5% of malformed outputs would either require costly human review or produce incorrect automated extraction.

The RL training may actually increase format brittleness. The binary format reward teaches the model that any deviation from the exact ⟨think⟩⟨/think⟩⟨answer⟩⟨/answer⟩ structure yields zero reward — equivalent to a completely wrong answer. This creates a sharp cliff in the reward landscape where slightly malformed but substantively correct outputs are treated identically to hallucinated nonsense. The model may learn to be format-compliant on the training distribution but fail to generalize format production under distribution shift (e.g., unusually long questions, questions with special characters that interact with tag parsing, or questions that elicit particularly long reasoning chains where the model might "forget" to close a tag).

What evidence exists in the paper. The paper provides no analysis of format compliance rates at inference time. Table 3 reports accuracy but does not report what fraction of outputs were unparseable due to format violations (and whether those were counted as incorrect or excluded). The RL ablation in Table 4 shows that RL improves format-adjacent metrics (CFLUE accuracy goes up, suggesting the accuracy reward is working), but does not report whether format compliance improved, stayed constant, or decreased. The evaluation prompts in Appendix B include instructions like "wrap the answer in boxed{} format" (Figure 5), suggesting the evaluation pipeline has heuristics for extracting answers without tags — but whether these heuristics are applied to DianJin-R1 outputs (which use the tag format) or only to baseline models (which may not) is unclear.

The paper implicitly acknowledges format sensitivity by making the format reward a separate, equal-weighted component of the total RL reward (Section 2.3.2: "a reward score of 1 is granted if the output contains exactly one reasoning segment... and one final answer... with no additional content outside these boundaries"). Making format strict and binary is a deliberate design choice, but the paper does not discuss the tradeoff between format reliability and robustness to format variation.

Mitigation status. Not addressed. The paper does not discuss format brittleness as a concern, does not propose fallback extraction methods for malformed outputs, does not report format compliance rates, and does not explore softer format rewards (e.g., partial credit for having both tags even if extra content exists, or a continuous reward proportional to tag completeness). The future work section does not mention format robustness.

6.6 The 7B Model Shows Negative Interference Between Training Datasets, Limiting Multi-Task Scaling at Smaller Parameter Counts

The assumption or constraint. The paper trains DianJin-R1-7B on a mixture of four datasets spanning three task formats (Chinese multiple-choice, English numerical reasoning with financial tables, Chinese dialogue compliance checking) and two languages (Chinese, English). The implicit assumption is that multi-task SFT on these diverse datasets will produce a model that performs well on all tasks, with positive or at least non-negative transfer between them. The CFLUE-dominated data mixture (70% of SFT instances) assumes that broad financial exam knowledge provides a foundation that other datasets build upon without interference.

The consequence. Table 5 reveals that this assumption partially fails at the 7B scale. The full three-dataset SFT configuration (CFLUE + CCC + FinQA) does not achieve the best performance on any single benchmark: on CCC, it scores 93.00% vs. 95.00% for CFLUE + CCC (+2.00 points lost by adding FinQA); on GPQA-Diamond, it scores 34.85% vs. 36.03% for CFLUE alone or CFLUE + FinQA; on MATH-500, it scores 74.87% vs. 76.27% for CFLUE + CCC (−1.40 points). These are small degradations (1–2 points), but they are consistent: adding the third dataset never improves and sometimes slightly reduces performance on benchmarks where the other two datasets already performed well. This pattern is consistent with negative interference — the 7B model's limited capacity forces a tradeoff between the different reasoning patterns required by each dataset, and optimizing for all three simultaneously produces a model that is slightly worse on each individual task than a model trained on the two most relevant datasets.

For practitioners, this means the 32B model is effectively required for multi-task financial reasoning deployment — the 7B model shows clear capacity limitations that manifest as interference between datasets. Organizations with compute constraints that can only deploy 7B models may need to choose between task-specific models (e.g., a CFLUE+CCC model for Chinese compliance and exam tasks, vs. a CFLUE+FinQA model for bilingual numerical reasoning) rather than a single multi-task model.

What evidence exists in the paper. Table 5 provides direct evidence of negative interference. Comparing the CFLUE + CCC configuration to CFLUE + CCC + FinQA:

• CFLUE: 75.16% → 75.48% (+0.32, negligible)
• FinQA: 71.78% → 80.28% (+8.50, expected since FinQA data was added)
• CCC: 95.00% → 93.00% (−2.00, negative interference)
• MATH-500: 76.27% → 74.87% (−1.40, negative interference)
• GPQA-Diamond: 35.35% → 34.85% (−0.50, negligible but negative)

Similarly, comparing CFLUE + FinQA to CFLUE + CCC + FinQA: adding CCC data improves CCC substantially (70.00% → 93.00%) but slightly reduces FinQA (80.85% → 80.28%, −0.57) and does not improve CFLUE (75.20% → 75.48%, essentially flat). The paper does not run the equivalent ablation for the 32B model, so it is unknown whether this interference disappears at larger scales (where more capacity could accommodate all three reasoning patterns) or persists (suggesting a more fundamental conflict between the task formats).

The paper does not discuss this interference pattern. Section 3.3's discussion of Table 5 focuses on which datasets help which benchmarks, not on cases where adding data hurts performance. The statement "using all three datasets together during SFT results in the best overall performance" (Section 3.3) is true for average accuracy (71.70% vs. 70.71% for CFLUE + CCC) but masks the per-benchmark degradations.

Mitigation status. Not addressed. The paper does not discuss capacity limitations, dataset interference, or the tradeoff between multi-task breadth and per-task depth at smaller model scales. The 32B model is reported only in the full three-dataset configuration in Table 3, with no ablation of dataset subsets at that scale. The future work section does not mention multi-task interference or propose methods for mitigating it (e.g., task-specific adapters, dynamic data mixing ratios, or curriculum learning strategies that sequence dataset introduction).

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a pragmatic reframing of domain-specific reasoning that shifts the conversation from "can models reason?" to "can models reason about our domain, using our workflows, at our cost constraints?" It is not a paradigm shift in the sense of introducing a new algorithm or architecture — the SFT + GRPO pipeline is assembled from established components (DeepSeek-R1's reasoning format, Shao et al.'s GRPO, Qwen2.5-Instruct base models). Rather, it is a methodological demonstration that combining these components with domain-specific data construction yields practical, cost-effective reasoning models for specialized industrial applications. The shift is from viewing reasoning as a capability to be purchased (by using a large general reasoning model like DeepSeek-R1) to viewing reasoning as a capability to be manufactured (by constructing reasoning-annotated domain data and training smaller, cheaper models to internalize it).

The most significant reconciliation the paper achieves is between two competing narratives about reasoning models in specialized domains. One narrative, driven by DeepSeek-R1 and QwQ's success on math and science benchmarks, holds that general-purpose reasoning training produces transferable reasoning capabilities — that a model trained to reason through calculus problems will reason better through any structured task, including financial compliance. The counter-narrative, suggested by Fino1 (Qian et al., 2025) and now substantiated by this paper's baselines, is that general reasoning training can actively degrade domain-specific performance. Table 3 provides the clearest evidence: DeepSeek-R1-Distill-Qwen-7B scores 48.39% on CFLUE vs. 69.37% for the non-reasoning Qwen2.5-7B-Instruct — a 21-point regression from adding general reasoning. This is not a failure to transfer; it is negative transfer, where the reasoning patterns learned from math and science training lead the model to produce elaborate but domain-incorrect chains of thought.

The paper resolves this tension not by declaring one narrative correct but by showing they describe different regimes: general reasoning transfers positively when the target domain is close to the training distribution (math reasoning → MATH-500), transfers unpredictably for intermediate cases (math reasoning → FinQA, where DeepSeek-R1 at 79.81% is slightly below non-reasoning DeepSeek-V3 at 81.34%), and transfers negatively when domain-specific knowledge is the binding constraint (math reasoning → CFLUE for smaller distilled models). The implication is that domain-specific reasoning training is not merely "nice to have" for specialized domains — it is necessary to avoid the degradation that general reasoning training can cause when the domain requires knowledge that contradicts or overrides the reasoning patterns learned from math and science data. A financial exam question about forward pricing conventions (Figure 3's example: knowing that the seller uses the bid side of the spread) has a correct reasoning path that depends on domain convention, not logical deduction from first principles. A model trained to reason from mathematical first principles will confidently produce a different reasoning path that is logically coherent but financially wrong.

This reframing opens a specific research direction that was previously underappreciated: the study of negative transfer in reasoning training. Prior work on reasoning models (DeepSeek-R1, QwQ, OpenAI o1) focused on maximizing reasoning capability and measuring positive transfer to benchmarks. This paper shows that negative transfer is a first-class phenomenon — adding reasoning capability can reduce accuracy — and that it follows a predictable pattern (worse at smaller model scales, worse for domains far from the reasoning training distribution). This creates a research agenda around when reasoning training helps vs. hurts, which requires characterizing the distributional distance between reasoning training data and target tasks, something the field currently lacks vocabulary and metrics for.

The paper also changes the economics of domain-specific AI deployment in a concrete way. The CCC result (Table 6: DianJin-R1-7B at 94.50% with 1 call vs. multi-agent Qwen2.5-72B-Instruct at 95.00% with 8.15 calls) demonstrates that a 7B model can match a 72B multi-agent system on a complex compliance task, at 8.15× lower inference cost and with a model 10× smaller. This is not just an efficiency gain — it changes what is deployable. A 72B multi-agent system may be technically feasible but economically prohibitive for production customer-service quality inspection processing thousands of dialogues daily. A 7B single-call model is deployable on a single GPU with modest latency. The paper shows that the multi-agent system's structured reasoning can be compressed into the weights of a much smaller model through supervised imitation, making sophisticated compliance checking economically viable for organizations that could not afford the multi-agent alternative.

The research directions that become more attractive after this work include: (a) studying what properties of a domain make it amenable to reasoning distillation from multi-agent workflows (clearly defined decision trees? human-designed checklists? regulatory rule systems?), (b) developing cheaper methods for reasoning data construction that do not require expensive teacher models and GPT-4o verification, and (c) understanding why general reasoning training produces negative transfer at small scales — whether this is a capacity limitation (the 7B model cannot retain both general reasoning patterns and domain knowledge) or a more fundamental issue of conflicting optimization objectives.

The research directions that become less attractive include: (a) pursuing ever-larger general reasoning models with the assumption that domain-specific performance will improve as a side effect (the paper shows this assumption fails for financial tasks), (b) investing in complex multi-agent orchestration for tasks where the workflow can be distilled into a single model (the 8.15× cost difference creates a strong economic incentive to prefer distillation), and (c) treating SFT and RL as interchangeable or uniformly beneficial — the paper's finding that RL helps Chinese multiple-choice but hurts English numerical reasoning (Table 4) shows that training stage contributions are task- and language-specific.

Follow-Up Research This Work Enables

Characterizing when general reasoning training produces negative transfer and why. The paper's most striking baseline result — DeepSeek-R1-Distill-Qwen-7B losing 21 points on CFLUE relative to its non-reasoning base — is reported but not explained. A follow-up study would systematically measure reasoning model performance on domain-specific benchmarks as a function of (a) the domain's distance from the reasoning training distribution (math, science, code), (b) model scale (7B, 14B, 32B, 70B+, full DeepSeek-R1), and (c) the type of domain knowledge required (factual recall, convention application, numerical computation, regulatory interpretation). The hypothesis would be that negative transfer is worst at small scales for domains requiring convention- or regulation-based reasoning (where the "correct" answer depends on human-defined rules rather than logical necessity), and that it diminishes or reverses at larger scales where the model has enough capacity to retain domain knowledge alongside general reasoning patterns. The experiment would require evaluating all DeepSeek-R1-Distill variants on a suite of domain-specific benchmarks (medical licensing exams, legal bar exams, accounting certification tests, engineering professional exams) alongside their non-reasoning base models, and measuring the accuracy delta as a function of scale and domain type. The paper's CFLUE result provides one data point; a systematic study would reveal the shape of the transfer function and identify the "break-even scale" where general reasoning training stops hurting and starts helping for each domain.

Measuring the quality and fidelity of multi-agent-to-single-model reasoning distillation. The paper demonstrates that single-call models match multi-agent accuracy on CCC (Table 6), but does not measure whether the single-call model's reasoning faithfully follows the multi-agent workflow or merely arrives at the same answers through different reasoning paths. A follow-up study would compare the reasoning traces of DianJin-R1 on CCC test instances against the multi-agent system's intermediate outputs, measuring: (a) condition-node agreement — does the single-call model's reasoning mention the same compliance conditions (regulatory complaint, social media risk, legal risk, ticket escalation) in the same order? (b) intermediate-decision agreement — when the single-call model's reasoning makes statements like "the client mentioned regulatory authority complaint, therefore this requires alerting," do these intermediate conclusions match the multi-agent system's decisions at the corresponding condition nodes? (c) reasoning fidelity vs. answer correctness — are there instances where the single-call model gets the right answer but with wrong or incomplete reasoning, indicating it learned a shallow shortcut rather than the workflow logic? This would require human annotation of reasoning traces — something the paper does not do — but would distinguish between true workflow distillation (the model internalizes the decision tree) and answer-level imitation (the model learns surface patterns that correlate with compliance labels without executing the workflow). The finding would determine whether single-call distillation is safe for high-stakes compliance applications where reasoning auditability matters as much as answer correctness.

Testing whether the hard-case split strategy actually identifies instances where RL provides capability discovery vs. instances where the teacher model was unlucky. The paper's data partitioning strategy (verified reasoning → SFT; unverified instances → RL) assumes that DeepSeek-R1's failure to produce verified reasoning in 3 attempts identifies genuinely hard instances where the teacher model lacks capability. A follow-up study would increase the retry budget substantially (e.g., to 100 attempts per instance) on a sample of the 4,096 hard cases in G_CFLUE_MCQ and measure: (a) what fraction of "hard cases" actually yield correct verified reasoning with more attempts (revealing the false-negative rate of the 3-attempt classification), (b) whether the instances that remain unsolved after 100 attempts have different characteristics (subject area, question length, required domain knowledge type) than those that eventually succeed, and (c) whether RL provides larger accuracy gains on the genuinely hard instances (where the teacher truly failed) or on the unlucky-sampling instances (where the teacher could have succeeded but didn't). The hypothesis is that RL's benefit is concentrated on genuinely hard instances where the model must discover reasoning strategies beyond what the teacher provided — if instead the benefit is on instances that were misclassified as hard, then the hard-case split is not doing the work the paper attributes to it, and a simpler approach (more retries during data construction) would achieve similar results without RL. This experiment requires significant teacher-model inference cost but would clarify whether the two-stage SFT+RL design is necessary or whether improved data construction alone would suffice.

Measuring cross-lingual RL transfer in reasoning models with controlled language matching. The paper shows that Chinese-only RL data degrades English FinQA performance (Table 4: −2.56 points) but does not isolate whether this is a language effect, a format effect (multiple-choice vs. open-ended), or a domain effect (exam questions vs. numerical reasoning from reports). A follow-up study would train four RL variants on the same 7B SFT base model: (a) Chinese multiple-choice RL data only (the current paper's configuration), (b) English multiple-choice RL data only (e.g., translated CFLUE questions), (c) Chinese open-ended RL data only (e.g., from CFLUE_OE hard cases), and (d) English open-ended RL data only. If variant (b) preserves or improves FinQA performance while variant (a) degrades it, the effect is language-driven. If variant (c) degrades CFLUE_MCQ performance, the effect is format-driven. If both language and format matter, RL would need to be matched to the target task's language and format — meaning the paper's current RL configuration (Chinese MCQ) is only appropriate for Chinese MCQ deployment, and multilingual multi-format systems would require either separate RL phases or a mixed RL dataset. This experiment directly addresses the paper's stated future work intention (footnote 1: "we will include G_CFLUE_OE, G_FinQA, and G_CCC in RL") but with a more diagnostic design that reveals why the current RL configuration fails on FinQA rather than just adding more data and hoping it helps.

Evaluating DianJin-R1-style training on a model family other than Qwen2.5 to test whether the approach is architecture-dependent. All experiments use Qwen2.5-Instruct as the base model. The paper's claims about domain-specialized reasoning training would be substantially strengthened by replicating the full pipeline (data construction, SFT, RL) on a different base model family — e.g., LLaMA-3.1-8B-Instruct and LLaMA-3.1-70B-Instruct — and measuring whether the same patterns hold: (a) does domain-specialized SFT on the same DianJin-R1-Data produce similar benchmark improvements over the non-reasoning base? (b) does the general-reasoning negative-transfer pattern replicate on LLaMA-based reasoning models (if available)? (c) does the RL language-mismatch degradation on FinQA replicate? If the patterns are consistent across model families, the paper's findings are about domain-specialized reasoning training in general. If they are Qwen-specific (e.g., due to Qwen2.5's particular pretraining data composition or instruction-tuning procedure), the claims need to be scoped accordingly. This experiment is straightforward — DianJin-R1-Data is being open-sourced, so other researchers can run the SFT and RL stages on their preferred base models — but critical for establishing the generality of the approach.

Stress-testing the CCC distillation claim with an adversarially strengthened multi-agent baseline. The paper's headline CCC result (single-call 7B matches multi-agent 72B) uses a multi-agent baseline that is not optimized — Qwen2.5-72B-Instruct with node-specific prompts, with no iteration between agents, no debate or consensus mechanism, and no ability for agents to revise decisions based on downstream condition checks. A skeptical follow-up would test whether a state-of-the-art multi-agent system (e.g., using reasoning-model agents, implementing agent-to-agent communication where the customer service auditor agent can query the regulatory complaint agent for clarification, or allowing agents to iterate until consensus) achieves substantially higher accuracy on CCC than 95.00%. If an optimized multi-agent system reaches, say, 98% on CCC, the paper's claim that single-call models "match or even surpass" multi-agent performance would need to be qualified — single-call models match simple multi-agent systems but not optimized ones, and the distillation process may compress the multi-agent reasoning imperfectly, losing some accuracy that better orchestration could recover. This experiment tests the ceiling of the distillation approach and identifies whether there is a fundamental accuracy gap between explicit workflow execution and implicit workflow internalization. If the gap exists, it would motivate hybrid approaches where the single-call model handles routine cases and escalates ambiguous ones to a multi-agent system — combining the cost efficiency of distillation with the accuracy ceiling of explicit reasoning.

Practical Applications and Downstream Use Cases

Automated compliance checking in regulated industries with auditable reasoning trails. The most directly deployable application is the CCC use case: a single-call model that evaluates customer-service dialogues for regulatory compliance violations, producing step-by-step reasoning that a human auditor can review. The paper's numbers are compelling for this use case: DianJin-R1-7B at 94.50% accuracy with 1 call per dialogue (Table 6) vs. a multi-agent 72B system at 95.00% with 8.15 calls. For a financial institution processing 10,000 customer-service dialogues per day, the multi-agent system requires 81,500 API calls daily (each to a 72B model) while DianJin-R1 requires 10,000 calls to a 7B model — an 8.15× reduction in inference volume with a model that is 10× smaller, translating to roughly two orders of magnitude reduction in inference compute. The explicit ⟨think⟩ tags provide auditable reasoning that addresses the regulatory requirement for explainable compliance decisions — a human reviewer can read the model's step-by-step condition checks (regulatory complaint? social media risk? legal escalation? ticket upgrade performed?) and verify each intermediate conclusion against the dialogue, rather than trusting an opaque classification. The main deployment risk is the format brittleness discussed in Section 6.5: if even 2–3% of outputs have malformed tags, those dialogues require manual review, which may erode the cost savings. A production deployment would need fallback parsing heuristics or a format-compliance check with retry logic.

Financial exam preparation and professional certification training. CFLUE's 15 financial qualification exam categories cover securities, banking, insurance, accounting, and other professional certifications. DianJin-R1-32B at 86.74% on CFLUE (Table 3) represents strong performance on a diverse set of exam questions, and the model produces explicit reasoning traces that explain why each answer is correct — going beyond what a typical QA system provides. This has direct application in professional education: trainees preparing for Chinese financial qualification exams can submit practice questions and receive not just the correct answer but a detailed reasoning chain that explains the domain concepts, conventions, and calculation steps. The filtering design (removing questions that smaller models already answer correctly, Section 2.1) means the training data focuses on challenging questions where reasoning adds value, making the model particularly useful for trainees who have mastered basics and are working on harder material. The limitation is language and jurisdiction: CFLUE is Chinese financial regulation, and the model's knowledge of U.S. FINRA exams, U.K. FCA regulations, or other jurisdictions' qualification frameworks is untested and likely limited. Expanding to other jurisdictions would require constructing equivalent reasoning-annotated datasets for those regulatory frameworks — following the same multi-source data construction pipeline (exam questions from mock tests, numerical reasoning from financial reports, compliance scenarios from operational data) but adapted to local regulations.

Cost-efficient data generation for self-improving domain-specific models. The paper's reasoning data construction pipeline — use a strong teacher model (DeepSeek-R1) plus a verifier (GPT-4o) to generate high-quality reasoning traces, then train a smaller model to imitate them — is a general recipe that can be applied to any domain where teacher models can produce verifiable reasoning. For an organization with domain-specific tasks (legal document review, medical coding, insurance claims processing, tax preparation), the workflow would be: (1) collect question-answer pairs from existing records (e.g., historical claims with auditor determinations), (2) use a strong general reasoning model plus domain-expert verification (either automated via a second LLM or human-in-the-loop) to generate reasoning traces, (3) train a smaller specialized model via SFT on verified traces, (4) optionally apply RL on hard cases where the teacher model failed. The paper's ablation (Table 4) suggests that SFT provides the majority of gains (+12.44 points average over the base model for the 7B) and RL adds a further +1.64 points on average, with the caveat that RL data should match the target language and format. For organizations where the inference volume justifies the upfront data construction cost, this recipe enables deploying specialized reasoning models at a fraction of the inference cost of the teacher models used to construct the training data. The paper does not provide a break-even analysis for when the upfront investment pays off — a critical missing piece for practitioners.

Replacing simple multi-agent systems with single-call distilled models for structured decision workflows. The paper's CCC result demonstrates a specific pattern that generalizes: any task with a predefined decision workflow (a flowchart, decision tree, or checklist) where multi-agent systems are currently used for accuracy but create inference cost problems can potentially be compressed into a single-call reasoning model. The key requirements are: (a) the workflow can be executed by LLM agents to generate training data (multi-agent reasoning traces), (b) the reasoning traces can be merged into coherent single-agent chains of thought, and (c) the task distribution at deployment matches the training distribution. Applications include insurance underwriting (checking applicant information against eligibility criteria in sequence), loan origination compliance (verifying required disclosures at each step of the application process), medical triage (checking symptoms against escalation criteria), and customer support escalation (determining whether a ticket meets criteria for supervisor review). In each case, the current state-of-the-art is likely a multi-agent or rule-based system that explicitly walks through the decision tree; the paper shows these can potentially be replaced with a single model call that produces the same structured reasoning implicitly, at substantially lower inference cost. The risk is that the distilled model may learn spurious shortcuts — producing the right final decision but with incorrect intermediate reasoning — which is dangerous in regulated domains where intermediate decisions must be justified. The paper does not evaluate intermediate-reasoning accuracy (only final-answer accuracy), so this risk is unquantified for the general case.

When to Prefer This Method

The paper does not articulate an explicit tradeoff framework against named alternatives — it positions domain-specialized reasoning training against general-purpose reasoning models (DeepSeek-R1, QwQ) and against multi-agent systems, but does not provide decision rules for practitioners choosing between these approaches. The implicit tradeoffs that can be extracted from the paper's results are:

• Prefer domain-specialized reasoning training (DianJin-R1-style SFT + RL on domain data) when: (a) the target domain has available question-answer pairs with verifiable correctness (exam questions, compliance cases with ground-truth labels, numerical problems with computable answers), (b) general reasoning models show negative or negligible transfer on the domain (as DeepSeek-R1-Distill-7B shows −21 points on CFLUE), (c) inference cost matters and a small specialized model (7B–32B) is preferred over larger general models, and (d) the training data can be constructed at acceptable upfront cost, amortized over high inference volume.

• Prefer general-purpose reasoning models when: (a) the target domain is close to the reasoning training distribution (math, science, code) where general reasoning models already excel, (b) domain-specific training data with verified reasoning traces is unavailable or too expensive to construct, (c) the task requires broad reasoning across many domains rather than deep specialization in one, or (d) the deployment scale is small enough that inference cost differences are negligible.

• Prefer multi-agent systems when: (a) the decision workflow is too complex or high-stakes to trust to a single model's implicit reasoning (e.g., medical diagnosis where intermediate decisions have independent clinical significance), (b) the workflow requires dynamic agent composition that cannot be pre-specified in training data (e.g., ad-hoc expert consultation depending on case specifics), (c) the accuracy ceiling of single-call models has been reached and further improvement requires explicit multi-step verification, or (d) the system must be auditable at the level of individual decision nodes with independent accountability for each node's output.

These are extracted decision rules based on the paper's evidence, not rules the paper itself states. The paper does not provide the comparative experiments (DianJin-R1 vs. optimized multi-agent, DianJin-R1 vs. general reasoning models at matched inference cost) that would be needed to make these rules empirically grounded rather than interpretive.