Reasoning Tokens

Reasoning tokens are the AI's internal thought process, the unseen cognitive labor performed before delivering a visible response. When you ask Claude Opus 5 to "design a robust API schema for a new microservice," it doesn't just pull an answer from thin air. It internally generates schema variations, evaluates them against best practices, simulates data flows, identifies security flaws, and synthesizes the optimal design. All that behind-the-scenes deliberation, discarded paths, self-correction, and deep analysis, that's what gets tallied as reasoning tokens. These tokens are billed at the standard output rate, making them a significant, often hidden, component of your AI spend. Anthropic's "extended thinking" documentation confirms you are charged for "full thinking tokens" even when the API returns only a "condensed summary." The number you pay for and the number you can read are fundamentally different. Our telemetry from 157,670 Claude Code API responses (April-July 2026) showed this stark reality: on prose-only turns with Opus 5, we recorded just 2.7 visible characters per billed output token, versus roughly 4.0 for plain English text. Nearly a third of your paid output tokens never reach your terminal. They represent the model's cognitive effort and commitment to a well-considered response, even if you only see the final result.

Reasoning tokens are not the visible text on your screen. They are not the words, sentences, or code blocks that stream back to you. This is a crucial distinction. Many designers mistakenly believe asking for a shorter answer will significantly reduce their output token bill. While brevity might shave off a few visible tokens, it does little to impact the underlying reasoning tokens that constitute the bulk of your output spend. The model still performs the same internal cognitive heavy lifting; it just summarizes its findings more concisely. Furthermore, reasoning tokens are not a bug, a hidden fee, or a scam. This is the product working exactly as designed. Modern, capable AI models like Claude Opus or Fable are built for complex, multi-step reasoning. That internal process is their core value proposition. You are paying for the intelligence, the deliberation, the problem-solving capacity, not just the final word count. Nor are reasoning tokens something you can eliminate by simply toggling a display setting. Anthropic's adaptive thinking documentation explicitly states that billed thinking tokens do not change with the `display` setting. Turning off the "thinking panel" in your interface might make your terminal quieter, but your invoice remains identical. The model still thinks; you just don't see its intermediate steps. It is not a measure of the *length* of the response, but the *depth* of the thought process.

Consider a real-world scenario: you're a product designer using Claude Code to architect a new feature. Your prompt: "Design a robust, scalable notification system for a social media platform, considering push, email, and in-app notifications, with user-configurable preferences and a fallback mechanism for service outages." When submitted to a high-tier model like Claude Opus 5, here's what happens behind the curtain, generating reasoning tokens: The model first decomposes the request. It then accesses vast knowledge on distributed systems, messaging queues, preference database design, and error handling. It internally sketches architectural patterns, centralized, microservices, hybrid, evaluating each against your requirements: "robust" (fault tolerance, retries), "scalable" (millions of users), "user-configurable" (complex preferences), "fallback" (circuit breakers). It might simulate failure modes or data consistency issues, checking for common pitfalls like rate limiting, spam prevention, or GDPR compliance. Only after this extensive internal deliberation does it assemble the final, coherent response you see: a detailed architectural diagram, component breakdown, API endpoints, and a discussion of trade-offs. The visible output might be a few hundred lines of markdown and code. But reasoning tokens represent the thousands of internal steps, discarded ideas, and complex evaluations leading to that polished answer. Setting the `effort level` to "high" explicitly tells the model to spend more internal cycles, generating more reasoning tokens, even if the final output length is similar. If you had the "thinking panel" enabled in Anthropic's workbench, you might see some intermediate thoughts, but whether you see them or not, you are billed. The depth of the thinking is the variable, not the display.

Understanding reasoning tokens means making deliberate choices about your AI budget. **When to embrace and pay for them:** Actively seek and pay for higher reasoning token counts when the task demands deep cognitive effort, nuanced understanding, and robust problem-solving. This is where models like Claude Opus 5 or Fable 5 truly shine. If you're asking the AI to architect complex systems, perform critical analysis (e.g., legal review, intricate code debugging), generate creative, novel solutions (e.g., innovative product features, strategic marketing campaigns), or synthesize information from vast, disparate sources (e.g., consolidating insights from dozens of research papers), then the depth of internal processing directly correlates with output quality, accuracy, and completeness. You are paying for the AI's "intelligence" to be fully engaged. Shortchanging this process by forcing shorter answers will likely degrade the very value you sought. This is also when you might intentionally set a higher `effort level` in your prompts, prioritizing thoroughness over speed or cost. **When not to overpay for them (or when to optimize):** Conversely, avoid generating excessive reasoning tokens when the task is straightforward, repetitive, or requires minimal deliberation. Using a high-tier model for low-cognitive tasks is like using a supercomputer to run a calculator app. For simple data reformatting (JSON to YAML), basic summarization of short passages, routine content generation (boilerplate emails), or translation of common phrases, opt for models optimized for speed and lower cost, such as Claude Sonnet 5 or Haiku 4.5. Their input rates are significantly lower, and their internal reasoning processes are designed to be more efficient for less complex problems. Trying to reduce reasoning tokens by asking for shorter answers is a false economy; the real saving comes from choosing the right model and managing your *input context* effectively, ensuring the model only processes what's strictly necessary. As our article highlights, shortening the answer targets only 12% of your bill, while managing context targets 87%. The "AI token diet trap" is real: don't degrade output quality to save pennies on reasoning tokens when the real cost is in your context window.

Reasoning tokens are the invisible, billed cognitive effort an AI model expends, representing the depth of its thought process rather than the length of its visible reply.