Extended Thinking: When to Enable It (and When Not To)

AI Integration

•October 23, 2026•6 min read•By Daily Miranda Pardo

Your AI agent takes 18 seconds to respond. The model is good, the server is fine. The problem is you enabled extended thinking on every call, assuming more reasoning always means better results.

It doesn't. And that mistake costs teams latency, money, and users who abandon the interface before seeing the response.

What Extended Thinking Actually Does

Extended thinking is a mode available in recent Claude models where the model generates an internal reasoning block (<thinking>) before producing the final response. You don't see it in the output, but the model works longer and uses more tokens.

The result is measurably better on tasks requiring complex reasoning: mathematics, code with multiple constraints, analysis of ambiguous situations with trade-offs. On those tasks, quality improves in a real, noticeable way.

The problem is what it doesn't improve: extracting fields from a form, classifying user intent, calling a tool with obvious parameters, generating a formatted response from a template. For those tasks, thinking doesn't change the output — it only adds between 3 and 30 extra seconds and multiplies cost.

If you have thinking: { type: "enabled", budget_tokens: 8000 } set globally on your client, you're paying that cost on every request, the vast majority of which don't need it.

Why Global Thinking Is the Most Expensive Mistake

When I talk to CTOs running AI agents in production who complain about cost or latency, one of the first questions I ask is whether they have thinking enabled. The answer is usually "yes, we added it to get the best results."

The reasoning makes sense in theory. The problem is it doesn't discriminate.

A typical agent makes dozens of different types of calls:

Classify whether user intent is "support" or "sales"
Extract name, email, and company from free text
Decide which tool to call given clear context
Write a structured response following a template
Reason about a complex contract with contradictory clauses
Plan steps for a long process with dependencies

Only the last two cases justify extended thinking. The rest adds latency and cost with zero benefit.

The Right Pattern: Complexity-Based Routing

The solution isn't to disable thinking — it's to enable it selectively. You need a decision layer that evaluates each call before executing it.

// lib/thinking-router.ts

type TaskType =
  | "extraction"
  | "classification"
  | "tool-call"
  | "generation"
  | "reasoning"
  | "planning";

interface TaskConfig {
  type: TaskType;
  inputLength?: number;
  hasConstraints?: boolean;
  requiresMultiStep?: boolean;
}

function needsThinking(task: TaskConfig): boolean {
  // Never for simple extraction or classification
  if (task.type === "extraction" || task.type === "classification") {
    return false;
  }

  // Never for direct tool calls
  if (task.type === "tool-call") {
    return false;
  }

  // For generation: only if it has complex constraints
  if (task.type === "generation") {
    return (task.hasConstraints ?? false) && (task.inputLength ?? 0) > 2000;
  }

  // Reasoning and planning: almost always justify thinking
  return task.type === "reasoning" || task.type === "planning";
}

// Usage in your agent
async function callModel(prompt: string, task: TaskConfig) {
  const useThinking = needsThinking(task);

  const response = await anthropic.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: useThinking ? 16000 : 4096,
    ...(useThinking && {
      thinking: {
        type: "enabled",
        budget_tokens: 8000,
      },
    }),
    messages: [{ role: "user", content: prompt }],
  });

  return response;
}

With this pattern, 80–90% of your calls stay fast (under 1 second). Only calls that genuinely require complex reasoning activate thinking.

The Real Cost of Global Thinking

Concrete numbers with Claude Sonnet 5.5 at current pricing:

Call	Without thinking	With thinking (8k budget)
Classification 200 tokens	~€0.0006 · 0.8s	~€0.006 · 6s
Extraction 500 tokens	~€0.0015 · 1.0s	~€0.015 · 8s
Complex planning	~€0.009 · 2s	~€0.030 · 18s

For the first two tasks, thinking is 10x more expensive and 6–8x slower. For complex planning, the extra cost may be justified if it improves plan quality.

If your agent makes 1,000 calls per day and 70% are classification and extraction, enabling thinking globally can add between €3 and €8 of extra daily cost just for those calls — with zero improvement in results.

How to Measure the Impact Before Deciding

Don't make the call by gut feel. Before implementing the router, instrument your current calls to understand how many would actually benefit from thinking:

// middleware/thinking-logger.ts
export function withThinkingAudit<T>(
  taskType: TaskType,
  fn: () => Promise<T>
): Promise<T> {
  const start = Date.now();

  return fn().then((result) => {
    const duration = Date.now() - start;

    console.log(
      JSON.stringify({
        task_type: taskType,
        duration_ms: duration,
        thinking_recommended: needsThinking({ type: taskType }),
        timestamp: new Date().toISOString(),
      })
    );

    return result;
  });
}

One week of data gives you the real distribution of task types in your agent. That lets you calculate the exact savings before touching production code.

When Extended Thinking Is Worth It

To be clear: I'm not saying extended thinking is bad. It's a powerful tool for the right cases.

Scenarios where it justifies the latency cost:

Contract or legal document analysis where clauses contradict each other
Project planning with task dependencies and resource constraints
Complex code generation with multiple requirements that must hold simultaneously
Problem diagnosis where the agent needs to reason through possible causes before acting

In all these cases, the additional reasoning produces qualitatively better outputs. Users will wait 15–20 seconds because the result is worth it.

The Architecture Decision That Compounds

This is exactly the kind of architectural decision that separates agents that scale cleanly from ones that become unmanageable as usage grows.

It's not visible at first. With 50 calls a day, the difference between global and selective thinking is cents. At 5,000 calls per day, it's the difference between a manageable operational cost and a bill that eats the product's margin.

In the AI integration projects we build at DAILYMP, we review these decisions from the initial design. It's far cheaper to get it right upfront than to refactor the architecture when the bill already hurts.

If you have an agent in production and aren't sure how thinking is configured — or you're planning to add it and want to get it right — we can review the architecture together and give you a concrete diagnosis.

Message me on WhatsApp and we'll take a look.