Think Longer, Act Smarter: Why Coding Agents Need Behavior-Preserving Reasoning

A coding agent can fail in two very different ways.

One failure is obvious: it does not think enough. It sees an error report, guesses the wrong file, edits too early, and then spends the rest of the trajectory debugging its own mistake. Anyone who has watched an autonomous coding agent wander through a repository has seen this little tragedy. The machine is busy, but not necessarily useful.

The other failure is less obvious and more fashionable. The agent thinks too much. It produces a long internal explanation, elaborates hypotheses, expands the search space, and delays contact with the actual environment. It sounds more intelligent. It may even look more “reasoning-capable” in a demo. Then it runs out of context, stops calling tools, or forgets that software repair is not a philosophy exam.

That second failure is the real target of M2A: Synergizing Mathematical and Agentic Reasoning in Large Language Models.¹ The paper is not just another “make the model reason longer” story. Its useful contribution is sharper: mathematical reasoning can help coding agents only if the added reasoning does not overwrite the interaction behavior that makes an agent an agent.

In plainer business language: the goal is not to install a smarter monologue engine. The goal is to improve the inspect-act-observe loop.

The mistake is treating reasoning as one generic asset

The intuitive idea behind many reasoning upgrades is simple. Mathematical reasoning models are good at long, structured thinking. Coding agents need reasoning. Therefore, add mathematical reasoning data or merge in a reasoning model, and the coding agent should improve.

This is tempting. It is also exactly the kind of tempting idea that makes evaluation budgets quietly disappear.

The paper separates two behavior patterns that are often lumped together under the word “reasoning”:

That difference matters because a coding agent is not rewarded for beautiful thoughts. It is rewarded for resolving a repository issue. On SWE-Bench Verified, that means reading an issue, inspecting a real codebase, changing the right files, and submitting a patch that passes tests. The reasoning has to be operationally timed.

The paper’s accepted framing is therefore correct: this is a behavior-preserving capability integration problem. The difficult part is not “can we inject more reasoning?” It is “can we inject reasoning without damaging the transition points where the agent stops thinking and starts interacting?”

That is the mechanism-first core of M2A.

M2A protects the agent’s switching behavior before adding reasoning

M2A starts from a useful observation: agent behavior is most visible around transition markers.

In a ReAct-style coding agent, the important moments are not only the words inside a reasoning trace. They are the switches:

• entering a <think> block;
• exiting a </think> block;
• starting a tool call;
• ending or returning from the tool-call structure.

These markers encode the agent’s behavioral grammar. They are where the model decides whether to keep reasoning, call a tool, wait for an observation, or make an edit. If a reasoning upgrade disturbs those representations, the model may become smarter in the abstract but worse as an agent. A very elegant way to lose money.

M2A’s method has three main stages.

First, it calibrates an agent-critical behavior subspace. The authors collect hidden-state activations around behavior-transition markers from code-agent trajectories. This calibration set is not used for supervised fine-tuning; it is used to identify representation directions that appear important for the think-act-observe pattern.

Second, it projects the mathematical reasoning update into the null space of that protected subspace. Conceptually, if $\Delta W_{reason}$ is the reasoning task-vector update and $P_{null}$ is the projection that removes components interfering with agent-critical directions, then the merged reasoning update becomes:

$$ \widehat{\Delta W}{reason} = \Delta W{reason} P_{null} $$

The point is not the formula itself. The point is the constraint behind it: for hidden states lying in the protected agent-behavior subspace, the projected update should introduce no perturbation. In other words, add reasoning where it does not trample the behavior switchboard.

Third, M2A adds adaptive layer-wise merging. Null-space projection alone is not enough because reasoning and agent task vectors can have different magnitudes and different compatibility across layers. M2A therefore rescales the reasoning update layer by layer and uses a similarity-aware layer mask so that only more compatible layers receive the reasoning injection.

This produces a final merge rule that is easy to interpret operationally:

$$ W^{(l)}{merge} = W^{(l)}{agent} + M_l \alpha_l \widehat{\Delta W}^{(l)}_{reason} $$

Here, $M_l$ decides whether a layer participates in the merge, while $\alpha_l$ controls the calibrated merge strength for that layer. The global merge strength, $\beta$, becomes a control knob for reasoning intensity.

That last point matters. In ordinary model merging, the merge coefficient often behaves like a small lever attached to a large machine with unclear wiring. Turn it slightly, and nothing happens. Turn it more, and the model falls into long-response collapse. M2A tries to make the lever correspond to a smoother behavior change.

The main result is not just 51.2%; it is 51.2% without losing the loop

The headline result is strong but easy to misread. Applied to Agent-8B, a Qwen3-8B-based coding agent fine-tuned on 30k coding-agent trajectories, M2A improves SWE-Bench Verified resolved rate from 44.0% to 51.2%. That is a +7.2 percentage-point absolute gain, or +16.4% relative improvement.

But the result is interesting because of what does not happen.

This table is the article in miniature.

Multi-task SFT gives the model longer reasoning traces but lowers performance. That supports the paper’s claim that mixing math and agent data can transfer the superficial style of long reasoning without transferring useful agentic competence. Task Arithmetic and SLERP improve the score somewhat, but they nearly halve the average interaction steps while tripling reasoning length. These methods seem to buy performance by making the agent think more in fewer turns, not by preserving the agent’s normal operating rhythm.

M2A’s improvement is different. It increases average reasoning length from 253.3 to 327.4 tokens per step, but average interaction steps remain high: 178.0 versus the base agent’s 175.3. The model is not simply becoming a longer single-turn reasoner. It is still interacting.

That is why the 51.2% number should not be read as “model merging beats SFT.” It should be read as: behavior-preserving merging improved a coding agent because it added reasoning without damaging the multi-turn interaction process.

A small but important detail: the authors also compare against several larger public coding-agent systems. M2A-Agent-8B does not beat the largest 32B systems in the table, but it performs above several larger or more heavily trained baselines. This is useful evidence for efficiency, not a license to declare small models solved. Please do not print the victory banner yet; procurement departments already have enough decoration.

The ablations show which mechanism is doing the work

The paper’s ablation study should be read as a mechanism test, not as a decorative appendix-style ritual.

The full M2A method reaches 51.2% on SWE-Bench Verified. Removing the similarity-aware mask reduces performance to 49.8%. Removing merge coefficient calibration reduces it to 47.7%. Removing null-space projection reduces it further to 45.6%.

The largest drop comes from removing null-space projection. That is the key evidence behind the mechanism-first interpretation. If the method were merely a clever way to add a bit of reasoning weight, removing the projection should not hurt so much. Instead, the drop suggests that reasoning injection becomes much less useful when it can interfere with the behavior subspace.

The other two components are still meaningful. Merge coefficient calibration prevents reasoning-task vectors from dominating layers just because their magnitudes are larger. The similarity mask prevents updates in layers where the agent and reasoning task vectors point in less compatible directions. Together, they turn a crude merge into a more controlled integration.

This matters for business teams because it changes the implementation question. The question is not only “which model is smarter?” It becomes “which parts of the model update are allowed to touch which behavior-critical functions?” That is closer to engineering than model astrology, which is always a relief.

The merge-strength sweep turns reasoning into a managed behavior, not a mood

One of the more practically interesting parts of the paper is the merge-strength analysis. M2A uses $\beta$ as the global control for injected reasoning strength. The authors divide the sweep into low, medium, and high reasoning regimes, using $\beta = 0.8$ and $\beta = 1.2$ as empirical transition points.

The pattern is intuitive:

• In the low-reasoning regime, the model behaves much like the base agent but does not gain enough reasoning depth.
• In the medium regime, the model adds useful reasoning while keeping interaction steps close to the base agent.
• In the high-reasoning regime, reasoning length keeps growing, but performance no longer improves, and prompt-length failures become more visible.

This is one of the paper’s best practical insights. More reasoning is not monotonic value. It is a dosage problem.

The appendix comparison with standard merging methods sharpens this point. For Task Arithmetic, SLERP, TIES-Merging, and DARE, the merge coefficient is fragile: performance may improve around a narrow sweet spot, then collapse as reasoning traces jump toward response-length limits. In those methods, the coefficient is formally a control parameter but behaviorally a hazard.

M2A’s claim is more modest and more useful: within the tested setting, $\beta$ produces a smoother and more predictable change in reasoning length. It does not eliminate tuning, and the regime boundaries are empirical. But it makes reasoning strength closer to a managed engineering variable.

For a company deploying agents, that distinction is not academic. A controllable reasoning knob supports staged rollout, regression testing, cost control, and domain-specific tuning. A fragile knob supports incident reports.

The trajectory analysis explains what “better reasoning” means in code repair

The trajectory-level analysis is where the paper becomes less benchmark-shaped and more operational.

M2A does not merely generate more tokens. It changes where reasoning appears in the workflow. Compared with the base agent, M2A shows:

This pattern supports the authors’ phrase: a shift from trial-and-error editing to evidence-grounded action.

That phrase could have been marketing fluff. Here, the table gives it substance. The agent searches and inspects more before the first edit. It reasons more at the moment of editing. It edits fewer times. It touches slightly fewer files. This is not simply “longer chain-of-thought.” It is a change in the timing and selectivity of action.

The appendix case studies make the same point concretely. In a Sphinx issue, the base agent wanders through broad exploration, repeatedly revises hypotheses, consumes context, and terminates after exceeding the maximum prompt length. M2A identifies the semantic mismatch between :return: and :returns:, patches the relevant logic, and verifies the result. In a scikit-learn issue, the base agent recognizes that multi_class matters but overwrites an existing fit_intercept argument. M2A adds multi_class while preserving the existing constructor behavior.

Those examples are qualitative, so they should not be overweighted as proof. Their likely role is explanatory: they illustrate the trajectory statistics. Still, they help translate the mechanism into something engineering managers can recognize. Better agent reasoning is not a longer memo. It is a better sequence: understand, localize, patch, verify.

The appendix tests robustness, not a second thesis

Several appendix tests are worth interpreting carefully because they clarify what the paper is and is not claiming.

The epoch sweep for Multi-Task SFT is a robustness check against an obvious objection: perhaps the multi-task model underperformed because the training schedule was poorly chosen. The results do not support that objection. At 2, 3, 4, and 5 epochs, Multi-Task-8B gets 40.0%, 41.1%, 40.1%, and 39.2% resolved rate. More epochs do not fix the mismatch.

The calibration set size ablation tests how many code-agent trajectories are needed to estimate the protected behavior subspace. Using 50 trajectories already improves over the base agent, while 100 trajectories gives the best reported result at 51.2%; 200 and 300 trajectories do not improve further. This suggests that, in the tested setting, the behavior-critical directions can be estimated from a relatively small calibration set. It does not prove that 100 is universally sufficient for other agents, tool formats, or domains.

The calibration window radius ablation tests whether the marker neighborhood is fragile. Radius 3 gives 51.0%, radius 5 gives 51.2%, and radius 10 gives 49.5%. The useful interpretation is not that radius 5 is magic. It is that local transition neighborhoods appear robust enough to support the method, while excessively large neighborhoods may include task-specific or less relevant tokens.

The implementation appendix also matters. M2A does not explicitly materialize every full null-space projector. The authors use a block-wise, matrix-free implementation and apply projection across attention and feed-forward blocks. This is an implementation detail, but a commercially relevant one: methods that are beautiful only when written as dense matrix equations tend to become less beautiful after the infrastructure bill arrives.

What this means for business teams building agents

The direct result is about a specific technical setting: Qwen3-8B, OpenHands, SWE-Bench Verified, coding-agent trajectories, mathematical reasoning transfer, and training-free model merging.

The business inference is broader but should stay disciplined.

First, agent upgrades should be evaluated by behavioral process metrics, not only final answer quality or reasoning length. For coding agents, that means tracking search actions, file inspections, edit counts, patch locality, test execution, context growth, termination reasons, and interaction steps. A model that produces longer reasoning but fewer useful actions may be less deployable, even if it looks smarter in transcripts.

Second, companies should treat reasoning enhancement as process integration, not capability stacking. Adding a reasoning model, adding math data, or increasing chain-of-thought length may change the agent’s operating rhythm. The relevant question is whether the agent still observes the environment at the right times.

Third, training-free or low-training-cost methods can matter because agent training is expensive. The paper reports M2A calibration and merging using 8 H200 GPUs with 50 GB peak memory per GPU, compared with SFT stages using 32 H200 GPUs and 140 GB peak memory per GPU. That does not make M2A cheap in absolute terms. It makes it cheaper relative to full additional SFT or RL in this experimental setup.

Fourth, the method suggests a useful deployment pattern: tune reasoning intensity under controlled rollouts. Start with conservative $\beta$ values, evaluate process metrics and resolved-rate changes, then move into a medium-reasoning regime if interaction behavior remains healthy. The exact thresholds from the paper should not be copied blindly. The idea of behavior-governed tuning should.

A practical evaluation checklist would look like this:

The boring metrics are the useful ones. Agents fail in workflows, not in vibes.

Where the evidence stops

The paper is strongest as evidence for a mechanism in one demanding coding-agent setting. It is not yet broad proof that M2A will generalize across all agent types, model sizes, tool protocols, or enterprise workflows.

Several boundaries matter.

The main evaluation uses Qwen3-8B-derived models and SWE-Bench Verified under OpenHands. SWE-Bench Verified is a serious benchmark, but it is still a software-engineering benchmark. A browser agent, financial analysis agent, research assistant, or robotic planning system may have different behavior markers and different failure modes.

The evaluation setting is also resource-intensive. The paper reports self-hosted OpenHands evaluation with long context settings, Docker backend, maximum 400 steps, and 8 H200 GPUs for evaluation. That is not the environment of a small internal automation team running agents on a modest cloud budget.

The merge-strength regimes are empirical. $\beta = 0.8$ and $\beta = 1.2$ are useful transition points in the paper’s sweep, not laws of nature. Businesses should treat them as evidence that a controlled regime exists, not as copy-paste configuration values.

Finally, stronger coding agents introduce operational and security risks. The paper itself notes the need for sandboxed execution, access control, logging, human oversight, and security-oriented evaluation. This is not decorative caution. When an agent can modify code, run commands, and interact with repositories, failure is no longer just text on a screen. It can become a broken build, an insecure patch, or a quiet compliance problem.

The real lesson is to protect the loop

M2A’s best contribution is not that it makes a Qwen3-8B coding agent score 51.2% on SWE-Bench Verified. That result matters, but it is only the visible tip.

The deeper lesson is architectural: agentic reasoning is not just internal reasoning plus tools. It is a behavior pattern. The model must know when to think, when to inspect, when to edit, when to wait for evidence, and when to stop. Mathematical reasoning can help that process, but only when integrated without damaging the transitions that make the process work.

This is why mechanism-first reading matters. A plain summary would say M2A combines math and agentic reasoning through model merging and improves performance. True, but incomplete. The important part is that M2A treats reasoning transfer as controlled surgery on behavior-critical representations, not as a bulk import of cleverness.

For AI teams, that is the practical takeaway. Do not ask only whether the agent thinks more. Ask whether it still acts properly.

Because in software engineering, as in business, a brilliant employee who never checks the repository before making changes is not a genius. It is a risk with good prose.

Cognaptus: Automate the Present, Incubate the Future.