← All Insights

KN-03 · Effort economics

What an effort level buys, and where it stops paying

5 min readGuildBuild Team
Claude CodeAI agentsReasoning effortLLM cost optimizationAI evaluationAgent memoryLLMOps

Claude Code lets you set how hard the model thinks. We tested four effort levels: medium, high, xhigh, max. Most people pick one and never look again. We ran one fixed job at those four levels on three models and read what each step bought.

On that job, the estimated cost spanned about 20 times across the model-and-effort combinations. For looking things up, everything past high found no additional rules or notes in this test.

Claude Code effort economics: what does more reasoning buy? In a 20-question lookup experiment on three models and four tested levels, spending above high found no more.
KN-03 website/share card. The lookup stopping point belongs to this late-September test; the article distinguishes it from harder judgment tasks.

About these field measurements

Field measurements: late September 2026. Model names and cost estimates identify the tested configurations, not current prices or a universal default. The cost span changes both model and effort.

KN-03: 20 lookup questions across three models and four tested settings. Two models scored 16 of 20 at high. Xhigh cost 48–87% more and max cost 2.1–6.2 times high without finding more in this test.
One 20-question lookup test, one run per model and effort. Above high, additional spend did not find more rules or notes. This is not a claim that higher effort never helps.

What Claude Code effort does to output

The job was a 20-question lookup test. We counted how much of each model's output was thinking.

What Claude Code effort does to output
Share of output that is thinking medium high xhigh max
Opus 5.5 17% 29% 50% 79%
Fable 5.1 13% 20% 37% 58%
Sonnet 5 21% 35% 60% 74%

In these runs, effort moved the share in steps, in every model, and never out of order.

Measured as thinking tokens per visible token, each step multiplied the ratio by 1.4 to 3.7, most often 2 to 3. It is closer to a log scale than a straight line.

The visible answer grows too, but far less. On Opus, the visible part went from 617 tokens a question at medium to 1,680 at max, 2.7 times. The thinking went from 125 to 6,184, 49 times.

Thinking share rises from medium to max: Opus 5.5 17%, 29%, 50%, 79%; Fable 5.1 13%, 20%, 37%, 58%; Sonnet 5 21%, 35%, 60%, 74%. Opus visible tokens per question rose 2.7 times, thinking tokens about 49 times.
Thinking shares from the late-September runs; each bar uses a common 0–100% scale. More thinking tokens do not, by themselves, demonstrate better answers.

What the tested model-and-effort combinations cost

The harness’s list-price field estimated $0.44 for the same 20 questions on Sonnet 5 at medium and $8.54 on Opus 5.5 at max. These are the test’s recorded estimates, not actual subscription charges.

For scale, we also grew an agent's instruction file to the size of a team leader's. That added about 8,000 tokens to a 27,000-token start. In that setup, tuning the file was the smaller lever. Model and effort were the bigger ones.

Where higher effort stopped paying for lookup

The test scores whether the agent found the right rule or note.

  1. Medium was too low in this test. Rules reached through an index mostly did not fire.
  2. High was the knee: the useful stopping point. Two of three models scored 16 of 20.
  3. xhigh found no more, at 48 to 87 percent more estimated cost than high.
  4. max found no more than high, at 2.1 to 6.2 times high’s estimated cost.
Cost range plot with a high-effort baseline of 1.0: xhigh 1.48–1.87 times high, max 2.1–6.2 times high. No extra rules or notes were found above high in the one-run lookup test. Two of three models scored 16 of 20 at high.
Compared with each model’s high setting, xhigh cost 48–87% more and max cost 2.1–6.2 times as much. These ranges span the tested models; they are not statistical confidence intervals.

What the lookup test does not establish

It does not say high is enough for hard thinking. This test measures finding, not judging.

We ran one small judgment test: six questions, twice each, two models at three efforts, 72 answers graded blind by two graders. Every comparison tied. But the test had a ceiling: one grader gave 29 of the 72 a perfect score. A tie under a ceiling is not proof of no difference.

Quality by effort is Anthropic's own study, on a far larger sample (their engineering blog). Read that for broader quality evidence. Read this for cost and lookup. The current Claude Code effort documentation also notes that effort is calibrated per model and should be tested against the work; a setting name is not a model-independent compute budget.

One more thing we believe and did not measure: the kind of job moves spend as much as the setting does. That is field experience.

Finding is not judging. A separate small judgment test had 72 answers; one grader gave 29 perfect scores. Tied comparisons under that ceiling do not prove equivalence. Match inputs and model, compare settings, and repeat before choosing.
The judgment experiment had 72 answers: six questions, twice each, two models, three efforts, graded blind by two graders. One grader assigned 29 perfect scores. The calibration steps are practical guidance, not a measured savings claim.

What to do with it: calibrate effort to the job

  1. Name the job before the setting. A lookup job and a judgment job want different effort.
  2. For a seat relying on routed rules, use high as a starting point to test, not a universal minimum.
  3. Before paying for max on a routine job, run your own job at high and at max and compare.
  4. In a comparable setup, calibrate model and effort before you trim instruction files.

How we know: evidence and limitations

  1. One run per model and effort, late September 2026. A gap of one or two questions between single runs may be noise.
  2. One job family: questions on one agent's memory store.
  3. Costs are the harness's list-price field. A subscription draws usage, not dollars.
  4. The thinking shares were read from session transcripts. The stream files cut each call's output count short, so we did not use them.