[FEATURE] Users should pay for results, not internal reasoning inefficiency

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Claude Code currently charges based on the amount of internal reasoning/thinking performed by the model.

The problem is that users cannot determine whether this additional reasoning was actually necessary or simply the result of:

An inefficient planning strategy
Multiple retries
Internal loops
Excessive searching
Future implementation bugs or suboptimal algorithms

From a user's perspective, they are paying for the final result, not for the model's internal execution process.

For example:

Model A solves a task with 2,000 reasoning tokens.
Model B solves the exact same task with 50,000 reasoning tokens.

The user receives the same output but pays significantly more simply because the system consumed more internal computation.

This creates a fairness issue because users have no visibility or control over the internal reasoning process.

Proposed Solution

Reasoning cost should be separated from user responsibility.

Possible approaches:

Charge only for input/output tokens.
Include a predefined reasoning budget within each request.
Absorb internal planning overhead as part of the provider's implementation cost.
At minimum, distinguish between user-requested work and internal system overhead so that users are not billed for avoidable inefficiencies.

The goal is to align pricing with the value delivered rather than the amount of internal computation.

Alternative Solutions

Currently there is no practical workaround.

The only workaround is to avoid using features that require extensive reasoning or to manually limit the model's work, which reduces the usefulness of Claude Code.

Priority

High - Significant impact on productivity

Feature Category

Other

Use Case Example

Example scenario:

I ask Claude Code to analyze and fix a bug.
Claude internally performs many searches, retries, and planning steps.
Eventually it produces the correct answer.
However, I have no way to know whether the additional reasoning was necessary or caused by internal inefficiency.
I am still charged for all of those reasoning tokens.

In another version of Claude with a better planner, the same task might require only a fraction of the reasoning tokens while producing the identical result.

The cost difference should not be borne by the user when the output is effectively the same.

Additional Context

Imagine taking a taxi.

The optimal route is 10 km.

The driver accidentally drives 30 km because they get lost.

Most customers would expect to pay for the intended trip, not for the driver's inefficiency.

Similarly, customers should pay for the value they receive rather than internal computation that they cannot observe or control.

This request is not asking to reduce compute costs. It is asking for a pricing model that better aligns incentives between the provider and the customer.