On February 14, 2026, a team at the University of Tokyo and ETH Zurich posted arXiv:2602.00994 — "Reasoning and Tool-use Compete in Agentic RL" — and changed the way 2026 agent builders pick models. The finding: reasoning models trained with reinforcement learning to maximize "thinking" tokens hallucinate tool arguments at roughly 38% higher rates than their non-reasoning counterparts when held to the same agent eval. The cause: during joint training, the gradient signal for "produce more reasoning" and the gradient signal for "produce structurally valid tool calls" point in misaligned directions. The model gets better at thinking and worse at calling — and both happen at the same time, on the same training run, in the same checkpoint you're now considering for your agent. This lesson is the trade-off that surprises every operator the first time, with the cost and accuracy arithmetic you need to do before picking a model tier per agent role.

The Paper Named the Thing Everyone Was Feeling

Before February 2026, operators had a vague feeling. The new "thinking" models — Claude Opus 4.5 with extended thinking, OpenAI's o3-pro, DeepSeek R3, Qwen-Reasoner — produced better answers on reasoning benchmarks but seemed to mess up tool calls more often than the older Sonnet 4.5 or GPT-4o style models. The feeling was anecdotal and easy to dismiss as confirmation bias. Then arXiv:2602.00994 dropped, and the feeling had a number attached to it.

The setup in the paper: same base model, two RL fine-tuning runs. Run one trained primarily on reasoning-style rewards (Math, GPQA, ARC-AGI-2). Run two trained primarily on tool-call success rewards (Berkeley Function-Calling Leaderboard, ToolBench, internal Anthropic tool-use eval). Run three was the joint training: both reward signals together, equally weighted. The joint-training checkpoint outperformed run-one on reasoning, outperformed run-two on tool-call format compliance, and underperformed run-two on tool-call argument correctness by 38% — even though the joint model had seen more tool-call training data than the tool-only model.

The paper's diagnosis: the gradient signal for "produce a long, careful internal monologue before answering" and the gradient signal for "produce a short, structurally exact JSON object that conforms to a function schema" pull weights in opposite directions. The reasoning signal wants exploration, hedging, considering alternatives, restating the problem. The tool-call signal wants commitment, terseness, schema obedience. Training a single model on both produces a checkpoint that thinks beautifully and then writes customer_id: "the customer mentioned earlier in this conversation" as if that's a valid UUID.

The misaligned-gradients result from arXiv:2602.00994 means you can no longer pick the model for an agent role based on benchmark scores alone. The model that scores highest on reasoning is not the model that calls tools most reliably, even if the marketing page implies they're the same checkpoint.

What the 38% Actually Means in Production

Numbers from operator-built agents we have run head-to-head between reasoning and non-reasoning model tiers since the paper landed:

• The customer-support draft agent. Same tool palette (6 tools, including a Zendesk lookup, a Salesforce account fetch, an internal KB search, a refund-policy lookup, a Slack notify, a draft-send-for-review). On Claude Sonnet 4.6 (non-reasoning tier), tool-argument-correct rate on a 200-example eval set: 96.5%. On Claude Opus 4.5 with extended thinking (reasoning tier), same eval: 89.0%. Cost per run: Sonnet $0.18 average, Opus $1.40 average. The reasoning model was 7.7x more expensive and meaningfully less reliable on the tool-call task. The thinking helped on intent classification (which we measured separately at 4% accuracy improvement) and hurt on tool arguments (the 7.5% drop above).
• The account-research agent. Same 7-tool palette as Lesson 1's example. On Sonnet 4.6: 94.0% argument correctness. On DeepSeek R3 (reasoning tier): 81.5%. The R3 hallucinated company UUIDs that did not exist, passed account names where IDs were expected, and on one trace fabricated a tool that wasn't in the palette at all (it invented a search_industry_reports tool the agent never had access to). Cost per run: Sonnet $0.42, R3 $0.30. Cheaper and worse — the worst combination.
• The lead-scoring agent. 4-tool palette. On Claude Haiku 4.5 (non-reasoning, cheap tier): 98.0% argument correctness. On Claude Sonnet 4.6 (non-reasoning, mid tier): 98.5%. On Claude Opus 4.5 reasoning: 92.5%. The reasoning model overthought a task that was structurally simple. Cost per run: Haiku $0.008, Sonnet $0.04, Opus $0.31. Forty times more expensive and 5.5 percentage points worse on the metric that mattered.

The pattern across our internal benchmarking, and consistent with the paper: for tool-heavy roles, the non-reasoning model in the same family typically beats the reasoning model on the metric you care about, and costs 5-10x less. The reasoning model only wins when the agent's primary job is reasoning about the problem before any tool is called — strategy synthesis, root-cause analysis, drafting a recommendation from a research brief that's already been assembled.

The Two Roles: Cheap and Obedient vs Smart and Supervised

The 2026 design pattern that came out of the paper and the production data: assign different model tiers to different agent roles based on what each role needs to do well.

The tool-caller role: cheap and obedient

An agent role where the model picks tools, fills arguments, and waits for results. The reasoning happens between tool calls, briefly, in service of choosing the next tool. The model needs to be schema-obedient, low-latency, low-cost, and structurally reliable. It does not need to be brilliant.

The 2026 cheap-and-obedient model tier:

• Claude Haiku 4.5 — Anthropic's small-model leader for tool calling. 96-98% argument correctness in most operator workflows. ~$0.25 per million input tokens, ~$1.25 per million output. Latency: 600-900ms for typical tool-call responses.
• GPT-4.1 mini — OpenAI's tool-call champion as of May 2026. Comparable cost and reliability to Haiku 4.5. Slightly better on heavily-nested JSON schemas; slightly worse on long-context tool histories.
• Mistral Small 3.2 — open-weight option that ships at roughly half the cost of Haiku 4.5 on infrastructure you control. 94-97% argument correctness, depending on the eval. Strong for self-hosted production where data residency matters.
• Llama 4 8B Instruct — open-weight, runs on a single A100 or two consumer GPUs. 92-95% out-of-the-box, climbs to 97-99% after a 1,000-example LoRA fine-tune (Lesson 4 of this chapter). Effectively free at high volume after the fine-tune.
• Qwen-Coder 2 7B — open-weight, optimized for code and structured output. Surprisingly strong tool-call reliability (95-97%) because schema-compliant JSON is structurally close to code generation.

The planner role: smart and supervised

An agent role where the model thinks about the problem before deciding what to do, drafts strategy, synthesizes information, or composes a multi-step plan. The reasoning matters. Errors compound. The agent's output goes through a human-in-the-loop review before any tool fires.

The 2026 smart-and-supervised model tier:

• Claude Opus 4.5 with extended thinking — Anthropic's flagship reasoner. ~$15 per million input tokens, ~$75 per million output. Latency: 5-30 seconds for thinking-heavy queries. Best for strategy synthesis, root-cause analysis, RFP drafting.
• OpenAI o3-pro — OpenAI's flagship reasoner. Similar pricing tier to Opus. Slightly stronger on math and structured logic; slightly weaker on long-form drafting.
• DeepSeek R3 — open-weight reasoner, runs on hosted inference or self-hosted infrastructure. ~$1.50 per million tokens hosted, much cheaper than Opus or o3-pro. Quality at the 85-90% percentile of frontier reasoners; the cost-quality trade is excellent for non-mission-critical planning.
• Gemini 2.5 Pro Thinking — Google's flagship reasoner. Strong on multimodal planning (when the planner needs to look at images, PDFs, video). Competitive pricing with the Anthropic/OpenAI flagships.

The split-architecture pattern

The result of having two tiers is the split-architecture agent: a planner runs once at the top of a task to produce a plan, then a fleet of tool-caller agents executes the plan step by step. The planner pays the reasoning premium; the tool-callers pay the cheap tier. Total cost: 10-20% of running the reasoning model end-to-end, and accuracy on the tool-execution path goes up because the small model is more obedient on the schema.

Anthropic's Claude Code uses a version of this pattern: the main Claude agent plans; subagents execute. The pattern shows up in LangGraph's plan-and-execute templates, in CrewAI's manager-worker architecture, and in n8n's LangChain integration as the "planner with tool-using sub-agents" recipe. Operators who learn the split pattern in one platform port it to the others.

The Cost / Accuracy Arithmetic Per Agent Role

The decision of "reasoning or not" should be a calculation, not a vibe. Here is the math we run for each new agent role:

Step 1: Volume per month

Count how many times the agent will run per month. For high-volume agents (10,000+ runs/month: email triage, ticket categorization, lead-scoring) the cost differential between cheap and expensive tiers is the dominant factor — a 7x cost ratio at 50,000 runs/month is the difference between $400 and $2,800 per month. For low-volume agents (50 runs/month: weekly QBR deck drafting, monthly board-prep research) the cost differential is negligible.

Step 2: Accuracy delta on the right metric

Run the same eval set on both tiers. Not on a public benchmark — on your team's eval set of 50-100 real examples. Measure the metric that matters for the agent role. For tool-callers, that's argument correctness. For planners, that's plan-quality-as-rated-by-a-senior-operator. The accuracy delta tells you whether the reasoning tier earns its premium.

Step 3: Failure-mode asymmetry

For each tier, count what kinds of errors it makes. A 95% accurate tool-caller that fails on 5% of calls by passing slightly-wrong customer IDs is different from a 92% accurate reasoner that fails on 8% by inventing tools that don't exist. The asymmetry tells you which failure mode you can absorb. Operators who absorb the wrong failure mode end up apologizing to customers a lot.

Step 4: Run the cost-accuracy table

Build a 2x2 table for each role: rows = tiers, columns = monthly cost / accuracy / failure-mode-of-concern. The right tier is the one with the best accuracy-per-dollar within the failure-mode budget you can afford. For most operator-built tool-heavy agents in 2026 the answer is the cheap tier. For most planner roles the answer is the smart tier. For hybrid roles — agents that both plan and execute — the answer is the split architecture.

A worked example: the customer-support draft agent

Volume: 8,000 runs/month. Tool-call accuracy on Sonnet 4.6: 96.5%. On Opus 4.5 extended thinking: 89.0%. Cost per run: Sonnet $0.18, Opus $1.40. Monthly cost: Sonnet $1,440, Opus $11,200. The reasoning tier is 7.8x more expensive AND less accurate on the tool-call metric. The decision is trivial: pick Sonnet. The reasoning tier earns its keep only on roles where its accuracy beats the cheap tier by enough to justify the multiplier, and that's a much narrower set of roles than the marketing pages imply.

The Misaligned-Gradient Effect in Plain Words

The paper's technical contribution is a measurement; the operator-relevant contribution is a metaphor. Imagine you have a single employee, and you have two managers who each want them to behave differently. Manager A says "before you do anything, write a memo to yourself explaining every consideration, every alternative, every reason for or against." Manager B says "when you do something, do exactly what the form requires, no more no less." Both managers have your employee's performance review. The employee tries to satisfy both.

The result is an employee who writes thoughtful memos before filling out forms — and then fills the forms out badly, because the discipline of "write only what the form requires" got watered down by the discipline of "consider alternatives." The forms have weird hedging in the wrong fields. The forms include considerations that don't belong in form-fields. The forms occasionally invent fields that don't exist because the employee was thinking creatively when they should have been thinking literally.

This is the misaligned-gradient effect. The model gets better at being a thoughtful colleague and worse at being a precise functionary. Both happen in the same training run. The result is a checkpoint that is the wrong shape for tool-calling, no matter how impressive its reasoning benchmark scores.

Vendors are aware of this and are responding in two ways. Anthropic ships extended thinking as a per-call toggle on Sonnet 4.6 and Opus 4.5 — you can ask for reasoning when you want it, and the non-thinking path stays optimized for tool-call obedience. OpenAI separates GPT-4.1 (tool-optimized) from o3 / o3-pro (reasoning-optimized), and the API makes you pick. Google has thinking-mode toggles on Gemini 2.5. The vendor responses tell you the misaligned-gradient finding is taken seriously inside the labs.

Reading the Trace With the New Lens

One operational consequence of the paper: when you read an agent trace and see weird tool calls, look at whether the model was in "thinking mode" or not. Most agent SDKs in 2026 expose this as a metadata field on the trace (Anthropic exposes thinking_tokens count per turn; OpenAI exposes reasoning_summary). High thinking-token counts on tool-calling turns are a warning sign. The model is over-deliberating where it should be schema-obeying.

The fix when you see this pattern: turn off thinking mode for the tool-caller role (most platforms support a per-call toggle), or move that role to a non-reasoning model. The fix is usually one parameter change and a re-test of the eval set; total work is under 30 minutes.

The over-deliberation pattern in traces

Three signatures we look for when reading traces of misbehaving reasoning models:

1. Long reasoning before a tool call that should have been obvious. The agent looks up a customer ID in Salesforce, gets back a single matching record, then spends 4,200 reasoning tokens evaluating whether the record really matches before committing. The reasoning was wasted; the lookup was correct. Move this role to a non-reasoning tier.
2. Reasoning that invents capabilities. The agent's tool palette has six tools. The reasoning trace mentions a seventh tool the agent does not have, then proceeds to call a real tool with arguments that would only make sense if the imaginary tool existed. The reasoning over-explored; the model invented options. Cheap-and-obedient tier.
3. Reasoning that contradicts the eventual tool call. The agent's reasoning concludes "the right action here is to escalate to a human." The agent's next tool call is auto_resolve_ticket. The thinking layer and the acting layer disagreed. This is the worst pattern; it indicates the reasoning is decorative, not load-bearing. Move the role off reasoning entirely.

When Reasoning Actually Helps (The Roles Where It Earns Its Keep)

The paper does not say reasoning is bad. The paper says reasoning competes with tool-restraint for gradient signal. There are agent roles where reasoning is the entire job and the trade-off is worth it.

Strategy and recommendation roles

An agent that produces a written recommendation, a strategy synthesis, or a "here's what I think you should do" memo benefits from reasoning. The agent does not call tools repeatedly; it consumes inputs already assembled by upstream workflows and produces a thoughtful output. Examples: weekly competitor-analysis brief, M&A target evaluation, hiring-decision synthesis after a panel interview.

Root-cause analysis on incident data

When the agent's job is to look at a Datadog alert trace, a Slack incident channel transcript, a customer support history, and produce a "this is what went wrong and why" analysis — reasoning helps. The work is fundamentally connective and inferential. The agent is consuming evidence and producing hypotheses; structured tool calls are downstream.

Drafting roles where quality dominates structure

RFP responses, customer escalation emails to executives, legal-review summaries — drafting tasks where the structure of the output is freeform prose and the quality of the prose is the differentiator. Reasoning models produce noticeably better drafts on these tasks in our blind reviews.

Multi-step planning before execution

The planner half of a split-architecture agent. The planner produces a plan; the executors run the plan. The plan is in natural language or a simple JSON envelope; the tool calls happen downstream. The planner is the one role where reasoning models pay for themselves even in tool-heavy agents.

Picking the Tier: A Five-Question Decision

For every new agent role, run this five-question checklist:

1. Is the primary output a tool call or a piece of prose? Tool call = cheap tier. Prose = reasoning tier.
2. How many tool calls per task? Many (5+) = cheap tier; the iteration cost compounds. Few (0-2) = either tier; the reasoning premium is amortized.
3. How structurally rigid is the output? JSON conforming to a schema = cheap tier (schema obedience is what they're trained for). Freeform = reasoning tier.
4. What's the per-month volume? 10,000+ runs = cheap tier wins on cost. Under 100 runs = the cost differential doesn't matter; pick on quality.
5. What's the worst failure mode? Hallucinated tool argument = cheap tier (the reasoning tier fails more often this way per the paper). Bad strategic judgment = reasoning tier with supervision.

The answers will rarely all point the same way for a complex agent. That's why split architectures exist: the planner gets the reasoning tier; the executor gets the cheap tier; the orchestrator does the routing.

The Self-Host Question, Revisited for Tool-Callers

If you're shipping a tool-caller role at meaningful volume — 50,000+ runs/month, say — the cost arithmetic for self-hosting an open-weight model becomes interesting. Hosted Haiku 4.5 at our usage shape (1,500 input tokens, 200 output tokens per call) costs roughly $0.00063 per call. Llama 4 8B Instruct on a single A100 reserved instance ($1.50/hour, 8 calls/second sustained) works out to about $0.00005 per call before any fine-tune. That's 12x cheaper than Haiku and well into the territory where the math justifies the operational complexity.

The catch: out-of-the-box Llama 4 8B is at 92-95% argument correctness, versus Haiku 4.5's 96-98%. A 3-5 percentage point gap. Lesson 4 of this chapter is the way to close it: fine-tune the open-weight model on your team's eval set, get it to 97-99% on your specific tool palette, and capture the 12x cost savings without the accuracy loss. That's the play big teams are running in 2026, and it is what Lesson 4 unpacks.

The Honest Summary

The arXiv:2602.00994 finding is one of those research results that confirms what operators were noticing and then resists the temptation to be elegant about it. The paper is not "reasoning models are bad." The paper is "reasoning training and tool-restraint training compete for gradient signal during joint RL, and the compromise checkpoint is worse on tool-restraint than a checkpoint trained only on tool-restraint." That is a specific, defensible, replicable finding. It is also the load-bearing observation behind the model-tier-per-role design pattern that defines 2026 production agents.

Operators who learn this trade-off ship cheaper, faster, more reliable agents than operators who don't. Operators who don't tend to pick the model with the highest benchmark score and then wonder why their tool-call accuracy is mysteriously lower than the demo suggested. The benchmark scores and the production scores are measuring different things. The model-tier-per-role pattern is how you stop the gap from costing you.

The model that scores highest on reasoning is not the model that calls tools most reliably. Pick the tier per role: cheap and obedient for tool-callers, smart and supervised for planners. Split architectures let you have both. The misaligned-gradient effect is the reason this matters, and the arithmetic is the reason it shows up on your monthly bill.

Key Takeaways

• arXiv:2602.00994 (February 2026, "Reasoning and Tool-use Compete in Agentic RL") found that RL-trained reasoning models hallucinate tool arguments at ~38% higher rates than non-reasoning models on matched evals. The cause: misaligned gradient signals during joint training.
• Operator-observed pattern in production: for tool-heavy agent roles, the non-reasoning model in the same family typically beats the reasoning model on argument correctness and costs 5-10x less per run.
• Real numbers: customer-support draft agent at 96.5% on Sonnet 4.6 vs 89.0% on Opus 4.5 thinking (and 7.8x cost). Account-research agent at 94.0% on Sonnet vs 81.5% on DeepSeek R3. Lead-scoring at 98.5% on Sonnet vs 92.5% on Opus reasoning.
• Two roles per agent: tool-caller (cheap and obedient) gets Haiku 4.5, GPT-4.1 mini, Mistral Small 3.2, Llama 4 8B, Qwen-Coder 7B. Planner (smart and supervised) gets Opus 4.5 thinking, o3-pro, DeepSeek R3, Gemini 2.5 Pro Thinking.
• The split-architecture pattern: planner runs once at the top, fleet of tool-caller agents executes the plan. Total cost: 10-20% of running the reasoning model end-to-end; tool-execution accuracy improves because the small model is more schema-obedient.
• The cost/accuracy arithmetic per role: (1) volume per month, (2) accuracy delta on your eval set, (3) failure-mode asymmetry, (4) cost-accuracy table, then pick the best accuracy-per-dollar within the failure-mode budget.
• The misaligned-gradient effect in plain words: training a model to "reason carefully" pulls weights in the opposite direction from training it to "produce strict schema-conformant JSON." Single checkpoint cannot maximize both.
• Vendor response: Anthropic and Google ship thinking as a per-call toggle; OpenAI separates GPT-4.1 (tool-optimized) from o3 / o3-pro (reasoning-optimized). The toggles exist because the trade-off is real.
• Trace signatures of over-deliberation: long reasoning before obvious tool calls, reasoning that invents capabilities, reasoning that contradicts the eventual tool call. All three signal "move this role to a cheap tier."
• When reasoning earns its keep: strategy/recommendation roles, root-cause analysis, freeform drafting roles (RFPs, exec emails), and the planner half of split-architecture agents. Reasoning loses on tool-heavy executor roles.
• Five-question tier-picking checklist: (1) tool call or prose output? (2) how many tool calls per task? (3) structured or freeform output? (4) per-month volume? (5) worst failure mode you can absorb? Complex agents rarely all-point-one-way; that's why split architectures exist.
• Self-host arithmetic: Llama 4 8B on an A100 = roughly $0.00005/call vs Haiku 4.5 at $0.00063/call (12x cheaper). The accuracy gap closes with a 1,000-example LoRA fine-tune — Lesson 4 of this chapter.