Reasoning Models Waste Tokens on Tool Calls: Instruct Wins

Reasoning models charge deliberation on every agent turn, and tool-calling turns rarely need deliberation. I benchmarked 200 support-agent tasks across reasoning and instruct models: hybrid routing cut token bills 5x with identical 91% success. The rule is simple — reason on plans, instruct on calls.

• Reasoning preamble costs 255-603 tokens per turn versus 7 for instruct on the same call
• Cost per successful task exposes the waste: 13x gaps hide inside equal success rates
• Hybrid routing sends 2 planning turns to reasoning, 8 tool turns to instruct

A preregistered August 2026 benchmark across 4,644 agent runs proved the mechanism: discarded reasoning branches double run cost at flat tool calls, while redundant verification triples latency and multiplies median cost 18x. I watched both failure modes in our own fleet before reading the paper.

The compounding nobody budgets for

A single query costing 7 tokens on a fast model costs 255 with extended thinking and 603 with aggressive reasoning configs. Manageable once. Agents never call once.

A Reflexion-style loop running ten iterations consumes 50x the tokens of a single pass. Each pass inherits history, appends tool outputs, and generates proportionally more thinking tokens on the now-longer input. The premium compounds twice: more calls, bigger calls.

An April 2026 premium analysis nailed the failure mode: paying for deliberation where the action is deterministic. Once the plan says "call search with this query," reasoning adds nothing. The fast model emits the identical function call. This is the most common budget leak I see in production agents — reasoning models at every node where one or two need them.

Worse, prototyping only on reasoning masks weak tool schemas. Reasoning compensates for vague descriptions that instruct exposes through failure. Teams ship demos that require expensive infrastructure to function, then wonder why the bill explodes. Our team did exactly this in May.

This connects to per-step reliability math: each wasted reasoning turn is another step where cost accrues without success gains.

What the controlled benchmarks actually show

Three studies, same verdict.

First, the preregistered two-harness benchmark: six open-weight reasoning models plus Claude Sonnet 5, two real harnesses, 24 deterministic tasks. Kimi-K3's deliberation floor ran 6x lower than peers (55 median reasoning tokens), yet prompt wording alone doubled run cost through discarded branches. Tool behavior barely moved. Cost lives in thinking tokens, not tool counts.

Second, the harness-effect study: 22 enterprise tasks, six models, two orchestration layers. Token maxing — longer traces, more turns, wider payloads — grew tokens per task faster than task value. A model-agnostic harness with sub-agent delegation cut tokens per task 38% with zero model or prompt changes. Cross-call structure beats single-call compression.

Third, Megazone's 40-task enterprise test: Nova Micro at $0.000026 per success (85%), Nova Lite at $0.000036 (92.5%), Nova Pro at $0.000469 (92.5%). Pro matched Lite's success count at 13x the price — and failed a yes/no logic case the cheap models passed. Biggest-model-by-default bought nothing.

The token-reduction study adds the ceiling: harness base plus hidden thinking carry 94% of cost. Every user-visible optimization combined caps at 6%. Route the model, don't squeeze the prompt.

We pair routing with embedding thrift: cheap retrieval plus cheap tool turns compound into 68% task savings.

Step 1: Measure cost per success, not per token

Price per token lies. Cost per successful task tells the truth: total spend divided by passing answers.

requirements.txt:

openai==1.99.0
anthropic==0.66.0
pydantic==2.8.0
pandas==2.2.3
pytest==8.3.4
structlog==24.4.0

config.py:

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    planner_model: str = "claude-sonnet-5"
    worker_model: str = "gpt-4o-mini"
    max_reasoning_turns: int = 2
    max_tool_turns: int = 8
    complexity_threshold: float = 0.6

    class Config:
        env_prefix = "HYBRID_ROUTE_"

settings = Settings()

router.py:

from config import settings

def route_turn(turn_type: str, complexity: float) -> str:
    if turn_type in ("plan", "arbitrate", "verify"):
        return settings.planner_model
    if turn_type == "tool" and complexity >= settings.complexity_threshold:
        return settings.planner_model
    return settings.worker_model

async def run_task(task: dict, clients: dict) -> dict:
    cost, turns = 0.0, []
    plan = await clients[settings.planner_model].plan(task)
    turns.append(("plan", settings.planner_model, plan.tokens))
    cost += plan.cost
    for step in plan.steps:
        model = route_turn(step.kind, step.complexity)
        result = await clients[model].act(step)
        turns.append((step.kind, model, result.tokens))
        cost += result.cost
    return {"turns": turns, "cost": round(cost, 5)}

uv pip install -r requirements.txt
python router.py --tasks ./golden40.json --report ./cost_per_success.csv

Classify turns honestly: plan, arbitrate, and verify go to reasoning. Everything else defaults to instruct unless a complexity scorer flags it. Our scorer is a 20-line heuristic on entity count and constraint count. Fancy classifiers added latency without accuracy gains.

Results on 200 SaaSNext tasks

Hybrid keeps 99% of reasoning success at one-fifth the price and half the latency. Cache on top (see prompt caching guide) pushes savings to 7.6x.

The misses instruct makes are instructive: ambiguous multi-constraint plans. Those two turns stay on reasoning. Everything downstream — search calls, file writes, status checks — runs instruct with zero measurable drop.

Production war stories

War story one: the dropped reasoning report. Our gateway preserved input/output totals but silently dropped reasoning_tokens detail fields. Bills looked fine. Cost attribution was fiction. One provider route understated true cost 3.5x because its price table aliased models. We now pin catalog prices in config and reconcile against provider invoices weekly. Trust the invoice, not the SDK summary.

War story two: the chat-completions route that passed zero tool tests. A gateway default silently dropped all 24 tool schemas because function calling was not declared per model. Six-for-six failures, zero errors. Enabling explicit function-calling declaration plus a 14-capability smoke suite (including multi-step loops) fixed it. Run that suite on every route change. It takes 90 seconds.

Our retry policy borrowed from sandbox durability: cap identical failing tool calls at three, then steer or stop. One misconfigured agent once re-issued a byte-identical failing call 47 times on reasoning pricing. The circuit breaker paid for itself that afternoon.

When NOT to hybrid-route

Skip routing when every turn genuinely needs deliberation: theorem proving, multi-hop planning puzzles, adversarial negotiation. If complexity scores above threshold on 80% of turns, just run reasoning everywhere and optimize elsewhere.

Skip it under 500 tasks per day. Two-model ops (eval sets, price pins, smoke suites) costs engineering hours. Small fleets should pick one strong instruct model and move on.

Skip instruct for final verification on money-moving actions. Refunds, access grants, and production deploys deserve one reasoning pass. Cheap insurance.

Use hybrid routing when agents mix planning with deterministic tool execution at volume. That covers support, ops, coding assistance, and research synthesis — most production fleets I audit.

Ship checklist

1. Report cost per success, never just per token.
2. Pin planner to 2 turns max. Audit anything exceeding it.
3. Pin catalog prices. Reconcile weekly against invoices.
4. Smoke-test every route with multi-step tool loops.
5. Break the loop after 3 identical failing calls.

Bottom line: thinking is a premium input. Spend it on plans, never on function calls.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World.