Fine-tuning reasoning models on typical business data causes their chain-of-thought reasoning to disappear completely, because most datasets record only final answers, not the step-by-step thinking that reasoning models are trained to produce. Research from Crusoe Energy shows that when a model learns from data containing no reasoning traces, it learns to stop reasoning altogether.

What Exactly Is a Reasoning Model, and Why Does It Matter?

Reasoning models like DeepSeek-R1 and Qwen-Thinking work differently from standard language models. Instead of jumping directly from a question to an answer, they generate intermediate thinking steps first, often hidden in tags like .... These steps allow the model to work through complex problems methodically, accumulating results as it goes. For math problems, coding tasks, and logical reasoning, this approach produces more accurate answers than models that try to leap directly to conclusions.

The key insight is that every intermediate token costs a full forward pass through the model. The same mechanism that makes reasoning powerful, intermediate results written into context for later tokens to use, is what makes it computationally expensive. This trade-off becomes critical when deciding whether reasoning is worth the cost for your specific task.

What Happens When You Fine-Tune a Reasoning Model on Business Data?

Here's where the problem emerges. When a company wants to specialize a reasoning model on their own data, they typically provide labeled examples that contain only outcomes. A support ticket paired with its classification. A clinical note with its billing code. A contract clause with its risk rating. The reasoning that produced those labels exists only in the minds of the people who created them, never making it into the dataset.

When researchers tested this scenario, the results were stark. Fine-tuning Qwen3-4B-Thinking, a reasoning model, on banking77, a customer-support intent classification dataset, caused the model's valid reasoning rate to drop from 100% before fine-tuning to exactly 0% after. Not a single generation contained any reasoning block at all. This wasn't a gradual fade; the reasoning disappeared completely.

Why Does the Reasoning Collapse So Completely?

The collapse happens because of how the training process works mechanically. Reasoning models are designed to emit an opening tag like at the start of their response. When the training data contains no reasoning content to fill that space, the model sees an empty reasoning block as the correct answer to predict. The loss function used in standard supervised fine-tuning, called cross-entropy, rewards the model for assigning high probability to every token in the training target, including those empty blocks.

In other words, the model isn't losing the ability to reason through some passive process called catastrophic forgetting. Instead, it's being actively trained, row after row, to predict that no reasoning comes next. The complete disappearance of reasoning is the expected outcome of the training objective itself, not a side effect.

How to Preserve Reasoning When Fine-Tuning Models

• Synthetic Trace Generation: Automatically generate reasoning steps for existing business data using a larger reasoning model, then include those synthetic traces in the fine-tuning dataset to teach the smaller model to reason through problems.
• Selective Fine-Tuning: Use parameter-efficient methods like adapters or LoRA (Low-Rank Adaptation) that modify only a small portion of the model's weights, reducing the model's tendency to completely overwrite its reasoning behavior.
• Mixed Training Data: Combine business data with reasoning-annotated examples from other domains to maintain the model's ability to generate intermediate thinking steps while learning domain-specific patterns.
• Pre-Flight Verification: Before investing in full fine-tuning, run a simple test to check whether your training data contains any reasoning traces, and if not, decide whether the cost of reasoning is worth paying for your specific use case.

The research indicates that the choice among these approaches depends on what you actually need. If your task genuinely requires step-by-step reasoning to arrive at correct answers, then preserving the trace matters. But if the task is pattern matching, where the model simply needs to recognize correlations in data, then paying for reasoning capability may not be worth the computational cost.

Should You Even Pay for Reasoning in the First Place?

This question often gets overlooked, according to the research. For many enterprise use cases, the answer may be no. If you're classifying support tickets or assigning billing codes, the model may not need to show its work. It just needs to be accurate. In those scenarios, fine-tuning a standard model without reasoning capability might be more efficient than fighting to preserve reasoning you don't actually need.

The broader implication is that reasoning models represent a different class of tool than traditional language models. They excel when the problem requires working through intermediate steps, but they're not a universal upgrade. Understanding when reasoning is necessary, and when it's just an expensive overhead, is becoming essential as more organizations experiment with these models.

What This Means for Reasoning Model Adoption

Reasoning models like DeepSeek-R1 have gained significant attention as open-weight options available through platforms like Ollama, which lets users run models locally without sending data to external servers. The model is part of a broader ecosystem of reasoning models now available to developers, including Qwen-Thinking variants and others.

For organizations considering reasoning models for internal fine-tuning projects, the research suggests a critical first step: honestly assess whether your use case requires reasoning at all. If it does, plan to either generate synthetic reasoning traces for your data or accept that you'll need to use a larger reasoning model as a teacher to distill reasoning into a smaller one. If it doesn't, a standard model may serve you better and cost less to run.