Short answer

Nobody outside Anthropic can tell from a chart whether Opus 5.5 changed on November 3. What the evidence so far shows is that the thinking summaries changed style, and those are written by a separate summarizer model. In one sample of 458,000 responses, reasoning tokens per response went up slightly, from 369 to 413. Check your own setup first: on Opus 5.5 the default effort is medium, and a top-level effortLevel in your user settings is ignored, so run /effort high with Opus 5.5 active. Then rerun a fixed set of your own tasks and compare pass rates over time.

Since November 7, a lot of Claude Code users have been asking the same question: did Anthropic quietly make Opus 5.5 worse? The trigger was a chart posted on X showing that the thinking text in one developer's sessions changed style on November 3. The Hacker News thread about it, "Is Opus 5.5 nerfed? Thinking patterns changed on November 3", was still on the front page on November 10 with close to 800 points and nearly 500 comments.

The question is fair, and nobody outside Anthropic can answer it for certain from a chart. What you can do is find out whether your setup changed, and then measure your own results instead of reading tea leaves in thinking summaries. Several things in Claude Code and the Claude API changed around the same dates, and some of them change how much Opus 5.5 reasons on your machine without the model itself changing at all.

This post walks through what was claimed, what the counter-data shows, what Anthropic's documentation says about thinking summaries and effort, and then three small scripts: one that shows where your effort level comes from, one that pulls daily numbers out of your own Claude Code transcripts, and one that reruns a fixed set of tasks so you can compare pass rates over time.

What was claimed

On November 7, Shane Melaugh posted on X that he had Gemini 4 Argon analyze 1,400 of his Claude Code sessions, and that "on November 3, something definitely happened." The model name had not changed, but the way the model's reasoning read had shifted sharply. By November 9 the post had about 2,700 likes and around 468,000 views, according to a roundup on llms.blog.

The chart in the post tracked the daily share of visible thinking blocks with certain habits. Blocks starting with "I'm..." jumped to 61.3% after the marked date of around 18:00 UTC on November 3. Blocks using "I should" or "I need to" fell. The chart's own footer said that visible summaries show a behavior shift and are not proof that the model weights changed. That footnote got far less attention than the headline question.

Replies on X and Hacker News split the usual way. Some users said Opus 5.5 felt dumber since last week, even at high effort, or that it burned through their 5-hour limit faster. Others suspected quantization or a cost cut. Skeptics on Hacker News pointed out that a change in how thinking text reads says nothing about the quality of the code, and that only evaluations can show degradation.

The counter-data: the summaries changed, the work did not (for one large sample)

A few hours later Theo, who runs T3 Chat, quoted the post with his own numbers. He looked at 458,000 Opus 5.5 responses from October 9 to November 7 and compared them before and after the switch on each of his accounts. His summary was that Anthropic appeared to be rolling out a change to the reasoning summarizer account by account, and that he saw no sign of lost capability.

The before and after figures he shared, as reported by llms.blog:

MeasureBeforeAfter
Summaries starting with "I'm..."27%61%
Summaries using "I should" / "I need to"47%13%
Median summary length325 characters440 characters
Reasoning tokens per response369413
Reasoning share of output tokens46%49%
Output speed111 tokens/s112 tokens/s
Tool calls per response1.031.06

The wording of the summaries moved a lot, which matches the Melaugh chart. The amount of reasoning went up slightly, from 369 to 413 tokens per response, and speed and tool use barely moved. His accounts switched on different days between October 30 and November 4, which is what you would expect from a staged rollout and less of what you would expect from a single model swap.

That is one person's data, from one product, and it does not rule out problems in other workloads. It does show that "the thinking reads differently" and "the model got worse" are separate claims that need separate evidence.

Long-running trackers point the same way so far. LiveNerf, an open-source project that runs a frozen panel of 78 hard questions against Opus 5.5 through Claude Code every day with a pinned CLI version and exact-match grading, reported no change in its comparison windows through late October, and i10X reported that its November 4 update also showed no change. On the other side, i10X also cites a single power user's GitHub issue (#105112) where the share of answers the user had to correct rose from 5.2% of 5,738 before October 19 to 25.4% of 900 after. That is a measured complaint, but a different date and a different kind of measure from the November 3 chart.

As of the coverage through November 9, Anthropic had not made a public statement about the complaints.

Why thinking text is a weak signal

Anthropic's extended thinking documentation explains why a change in thinking text is so hard to read. When thinking is shown in summarized form, "the thinking text you receive is a summary of Claude's full thinking process rather than the raw chain of thought." The documentation also says the summarization "is processed by a different model from the one you target in your requests," and that the thinking model never sees the summary.

So when the style of the summaries changes, the most direct explanation is a change in the summarizer, which is a separate model. The documentation also says you are charged for the full thinking tokens, not the summary tokens, so the length of the summary you read tells you little about how much reasoning you paid for.

There is a second detail that matters for Claude Code users. On the API, Opus 5.5 returns thinking blocks with the display set to "omitted" by default, which means an empty thinking field. You only get readable summaries if you ask for them. In Claude Code, the showThinkingSummaries setting defaults to false, and the settings reference says this "changes only what you see, not what the model generates." If you turned summaries on at some point and are now comparing them with what you remember from before, you are comparing outputs of a summarizer, not of Opus 5.5.

What actually changed around November 3 in Claude Code

The Claude Code changelog and npm release times show several changes close to the dates people are arguing about. None of them is a model change, but each can change how hard Opus 5.5 works in your sessions.

  • Version 2.1.317, published to npm at 23:57 UTC on November 2 (already November 3 in Asia): "Changed subagents and teammates on a different model from the main conversation to use that model's saved effort level or its default, instead of the session's effort level." If your main session runs at high effort and a subagent runs on another model, that subagent may now run at a lower default.
  • Version 2.1.318, published at 21:55 UTC on November 3: removed an earlier fix that kept the model's earlier thinking when resuming a conversation started on 2.1.286 or earlier. That thinking can now be dropped on resume.
  • Version 2.1.316, October 31: added CLAUDE_CODE_SUBAGENT_EFFORT to set the effort subagents run at when nothing else names one.
  • Version 2.1.280, September 22: an effort level saved before /effort became per-model no longer applies to newly released models such as Opus 5.5. They start at their default until you pick a level.

That last change explains a lot of "it feels lazier" reports by itself. Many people set an effort level months ago and never touched it again.

The default effort trap

The Claude API effort documentation is direct about this: "Claude Opus 5.5 supports all five effort levels, and medium is the default (Claude Opus 5 and earlier Opus models default to high, so a request that omits effort runs one level lower than it did on Claude Opus 5)." The five levels are low, medium, high, xhigh and max. On Opus 5.5, adaptive thinking is always on and can't be turned off, so effort is the main control for how much the model reasons.

Now combine that with the Claude Code settings reference. The top-level effortLevel key in your user settings file (~/.claude/settings.json) still applies to Opus 5, Fable 5.1 and earlier models, but "Opus 5.5 and models released after it ignore it and start at their own default until you save a level for them." In project, local and managed settings, and with --settings, the key still applies to every model.

If you set "effortLevel": "high" in your user settings a while ago, moved to Opus 5.5, and never ran /effort again, you are probably running at medium. You would notice that as shorter reasoning on hard problems and more mistakes on multi-step tasks, which is exactly what a lot of the complaints describe. This was true before November 3, though, so it does not explain a sudden change on that date. It does mean that many people comparing "now" with "launch week" are comparing different settings.

The order of precedence matters when you fix it. According to the settings and environment variable references:

  1. CLAUDE_CODE_EFFORT_LEVEL beats everything: --effort, /effort, modelSettings and effortLevel. A maxEffortLevel cap still applies.
  2. --effort beats the settings keys for one session.
  3. Within one settings file, a model's entry under modelSettings beats the top-level effortLevel.
  4. Across files, the highest-precedence file that sets a level for that model decides, so managed settings outrank a level you saved in user settings.

Step 1: see where your effort level comes from

This read-only script prints the effort-related environment variables, the relevant keys in your user, project and local settings files, and any subagent definitions that have no effort field. It flags the case where your user settings have a top-level effortLevel but no per-model entry for Opus 5.5. Run it from the root of your project. It changes nothing.

#!/usr/bin/env bash
# Shows where Claude Code could get its effort level for Opus 5.5.
# Read-only: it prints settings, it changes nothing.
# Run it from the root of your project.
MODEL="${1:-claude-opus-5-5}"

echo "== Environment =="
echo "CLAUDE_CODE_EFFORT_LEVEL=${CLAUDE_CODE_EFFORT_LEVEL:-<unset>}"
echo "CLAUDE_CODE_SUBAGENT_EFFORT=${CLAUDE_CODE_SUBAGENT_EFFORT:-<unset>}"
echo "ANTHROPIC_MODEL=${ANTHROPIC_MODEL:-<unset>}"

python3 - "$MODEL" <<'PY'
import json, os, sys, glob
model = sys.argv[1]
files = [
    ("user", os.path.expanduser("~/.claude/settings.json")),
    ("project", ".claude/settings.json"),
    ("local", ".claude/settings.local.json"),
]
print("\n== Settings files ==")
for scope, path in files:
    if not os.path.exists(path):
        print(f"{scope:<8} {path}: not found")
        continue
    try:
        s = json.load(open(path))
    except Exception as e:
        print(f"{scope:<8} {path}: cannot parse ({e})")
        continue
    top = s.get("effortLevel")
    per = (s.get("modelSettings") or {}).get(model, {})
    note = ""
    if scope == "user" and top and not per.get("effortLevel"):
        note = "  <-- user-level effortLevel is ignored by Opus 5.5"
    print(f"{scope:<8} {path}: model={s.get('model')!r} "
          f"effortLevel={top!r} modelSettings[{model}]={per or None}{note}")

print("\n== Subagents with no effort field ==")
found = False
for path in glob.glob(".claude/agents/*.md") + glob.glob(os.path.expanduser("~/.claude/agents/*.md")):
    head = open(path, encoding="utf-8", errors="ignore").read().split("---")
    front = head[1] if len(head) > 2 else ""
    if "effort:" not in front:
        model_line = next((l.strip() for l in front.splitlines() if l.strip().startswith("model:")), "model: <not set>")
        print(f"{path}  ({model_line})")
        found = True
if not found:
    print("none")
PY

The script was tested against a sample folder with a user file holding only a top-level "effortLevel": "high", a project file with a per-model entry, and two subagents, one with an effort field and one without. It flagged the user-level key as ignored for Opus 5.5 and listed the subagent with no effort. The subagent check is a plain text search of the frontmatter, so treat its output as a list to look at, not a verdict.

Step 2: set effort explicitly where it counts

Once you know where the level comes from, set it in a place Opus 5.5 reads. The simplest way in an interactive session is to run /effort high (or xhigh) while Opus 5.5 is the active model. Claude Code saves that level under modelSettings for that model. You can also write it by hand. The settings reference gives this shape:

{
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}

For subagents, add an effort field to each definition in .claude/agents/. The subagent reference says the field "overrides the session effort level, but not the CLAUDE_CODE_EFFORT_LEVEL environment variable." A reviewer agent might look like this:

---
name: swift-reviewer
description: Reviews Swift changes for crashes, threading and App Store risks
model: claude-opus-5-5
effort: high
---

If you would rather set one level for every subagent that has none, use CLAUDE_CODE_SUBAGENT_EFFORT=high (version 2.1.316 or later). For a CI job or a script where you need the same result on every machine, pass --effort high on the command line or set CLAUDE_CODE_EFFORT_LEVEL.

Pin the model too. Use the full ID claude-opus-5-5 where you can, so an alias change can't move you to another model without you noticing. If you work in areas where a safety classifier sometimes flags requests, Claude Code can switch models automatically after a flag; CLAUDE_CODE_DISABLE_REFUSAL_FALLBACK=1 turns that switch off so you know every reply came from the model you picked.

Higher effort costs more. On API billing that means more output tokens; on a subscription it means you reach your limits sooner. Use high for multi-step debugging and reviews and keep cheaper levels for routine edits. You can also cap a model with maxEffortLevel under modelSettings if you share a budget with a team. Max Reasoning Effort Costs Up to 42x More on Easy Tasks has the numbers on what the top levels cost.

Step 3: pull daily numbers from your own transcripts

Claude Code keeps session transcripts as JSONL files under ~/.claude/projects/. Each assistant reply carries the model name, token usage and the tool calls it made. That is enough to check, for your own work, whether output tokens or tool use per reply changed around November 3.

One detail matters here: a single reply can appear on several lines of the transcript with the same message ID, one line per content block. Counting lines inflates the numbers, so the script merges lines by message ID first.

#!/usr/bin/env python3
"""Daily numbers for one model from local Claude Code transcripts.
Reads ~/.claude/projects/*/*.jsonl and prints, per UTC day:
assistant replies, median output tokens, tool calls per reply.
One reply can be written as several lines with the same message id,
so lines are merged by id before counting."""
import json, glob, os, statistics, sys
from collections import defaultdict

MODEL = sys.argv[1] if len(sys.argv) > 1 else "claude-opus-5-5"
root = os.path.expanduser("~/.claude/projects")
replies = {}  # message id -> [day, max output tokens, set of tool_use ids]

for path in glob.glob(os.path.join(root, "*", "*.jsonl")):
    with open(path, encoding="utf-8", errors="ignore") as f:
        for n, line in enumerate(f):
            try:
                d = json.loads(line)
            except json.JSONDecodeError:
                continue
            if d.get("type") != "assistant":
                continue
            m = d.get("message") or {}
            if m.get("model") != MODEL:
                continue
            day = (d.get("timestamp") or "")[:10]
            mid = m.get("id") or f"{path}:{n}"
            r = replies.setdefault(mid, [day, 0, set()])
            out = (m.get("usage") or {}).get("output_tokens")
            if isinstance(out, int):
                r[1] = max(r[1], out)
            for c in m.get("content") or []:
                if isinstance(c, dict) and c.get("type") == "tool_use":
                    r[2].add(c.get("id") or len(r[2]))

days = defaultdict(list)
for day, out, tools in replies.values():
    if day:
        days[day].append((out, len(tools)))

print(f"{'day':<11} {'replies':>8} {'median_out':>11} {'tools/reply':>12}")
for day in sorted(days):
    rows = days[day]
    med = statistics.median(o for o, _ in rows)
    tpr = sum(t for _, t in rows) / len(rows)
    print(f"{day:<11} {len(rows):>8} {med:>11.0f} {tpr:>12.2f}")

Save it as opus-daily.py and run python3 opus-daily.py, or pass another model ID as the first argument. It was tested on a real Claude Code transcript and on a synthetic file with three days of fake replies, a broken line and a non-assistant line; it skipped the junk and printed the expected medians.

Read the output with care. Output tokens per reply depend on what you asked that day, so a week of refactoring and a week of small fixes will look different whatever the model does. Look for a step change that holds across several days of similar work, and check whether it lines up with the day you updated Claude Code or changed a setting. If your median output tokens dropped on the same day your effort level fell back to medium, you have your answer, and it is not a nerf.

Step 4: rerun the same tasks and compare pass rates

The only test that answers "is it worse at my work" is to give it the same work again. You don't need a benchmark suite. Ten small tasks from your own repo, each with a check that passes or fails, run three times each at a fixed model and effort, will tell you more than any chart on X.

Good tasks for an iOS project are ones with a clear pass condition: add a missing Codable field and make an existing test pass, fix a known off-by-one in a date helper, add the Restore Purchases button to a paywall view so a UI string check finds it, or rename a type across files so the project still builds. Keep each task small enough to finish in one run. Write Your Acceptance Criteria Before You Prompt shows how to phrase checks like these.

The script below expects a folder per task, tasks/<name>/prompt.txt and tasks/<name>/check.sh, where the check exits 0 on a pass. Each run happens in a throwaway git worktree so your branch is never touched, and the results go into a CSV with the date, model, effort, pass or fail, output tokens and the cost estimate Claude Code reports in its JSON output.

#!/usr/bin/env bash
# Run the same small tasks against a pinned model and effort, and log results.
# Layout: tasks/<name>/prompt.txt and tasks/<name>/check.sh (exit 0 = pass).
# Each run happens in a throwaway git worktree, so your branch is untouched.
# Usage: ./regress.sh [model] [effort] [runs]
set -u
MODEL="${1:-claude-opus-5-5}"
EFFORT="${2:-high}"
RUNS="${3:-3}"
LOG="regress-log.csv"
REPO="$(git rev-parse --show-toplevel)" || exit 1
[ -f "$LOG" ] || echo "date,task,run,model,effort,pass,output_tokens,cost_usd" > "$LOG"

for dir in tasks/*/; do
  task="$(basename "$dir")"
  for run in $(seq 1 "$RUNS"); do
    wt="$(mktemp -d)/wt"
    git -C "$REPO" worktree add -q --detach "$wt" HEAD
    out="$(cd "$wt" && claude -p "$(cat "$REPO/$dir/prompt.txt")" \
            --model "$MODEL" --effort "$EFFORT" \
            --permission-mode acceptEdits --output-format json 2>/dev/null)"
    tokens="$(echo "$out" | jq -r '.usage.output_tokens // 0' 2>/dev/null || echo 0)"
    cost="$(echo "$out" | jq -r '.total_cost_usd // 0' 2>/dev/null || echo 0)"
    if (cd "$wt" && bash "$REPO/$dir/check.sh" >/dev/null 2>&1); then pass=1; else pass=0; fi
    echo "$(date -u +%F),$task,$run,$MODEL,$EFFORT,$pass,$tokens,$cost" >> "$LOG"
    echo "$task run $run: pass=$pass tokens=$tokens"
    git -C "$REPO" worktree remove --force "$wt"
  done
done

It needs git, jq and Claude Code. The loop, the worktree cleanup and the CSV output were tested with a stub claude command that writes a file and prints a fake JSON result. It has not been run against the real Opus 5.5 for this post, so try it on two or three tasks before you trust a full run. Because the check script runs in the worktree, a task that needs a build should call xcodebuild or swift test inside check.sh.

Two cautions. --permission-mode acceptEdits lets Claude write files in the worktree without asking, which is the point of the test, but shell commands still need approval or an allow rule, so add --allowedTools entries if a task needs to run tests itself. And the run uses whatever hooks, MCP servers and CLAUDE.md files your project has. That is realistic, but if you change one of them between runs, you have changed the test.

To see pass rates by day once you have a few runs logged:

awk -F, 'NR>1 {n[$1]++; p[$1]+=$6} END {for (d in n) printf "%s %d/%d passed\n", d, p[d], n[d]}' regress-log.csv | sort

Run the set once now at your chosen effort, again next week, and again after each Claude Code update. Keep at least one run at medium as well. If the pass rate at a fixed model and effort falls and stays down across several runs, you have real evidence worth posting in a GitHub issue, with the tasks attached so someone can reproduce it. If it stays flat, the model didn't change for your work, whatever the summaries say.

How big a drop is real?

Ten tasks run three times each gives you 30 results per round. That is enough to see a collapse and too few to see a small slide, because the same model at the same settings does not pass the same tasks every time. Before you post "the pass rate fell from 90% to 80%" anywhere, check how often a gap that size shows up from run-to-run noise alone.

The script below does that with a one-sided Fisher exact test. You give it the passes and runs from your earlier round and from your later one. It answers one question: if nothing had changed, how often would the earlier round look this much better than the later one? It uses only Python's standard library.

"""Is a drop in pass rate bigger than run-to-run noise? One-sided Fisher exact test.

Usage: python3 passrate.py 27 30 24 30
       (passes and runs before, then passes and runs after)
"""
import sys
from math import comb

a, n1, c, n2 = map(int, sys.argv[1:5])
k = a + c  # total passes across both periods


def prob(x):
    # Chance that x of the k passes land in the "before" runs
    # if both periods share one true pass rate.
    return comb(n1, x) * comb(n2, k - x) / comb(n1 + n2, k)


p = sum(prob(x) for x in range(a, min(n1, k) + 1))
print(f"before {a}/{n1} ({a / n1:.0%}), after {c}/{n2} ({c / n2:.0%})")
print(f"chance of a gap this large from noise alone: {p:.1%}")

Run with Python 3.12 on four made-up rounds, it printed these figures:

BeforeAfterChance of a gap this large from noise alone
9 of 107 of 1029.1%
27 of 3024 of 3023.6%
54 of 6048 of 6010.0%
27 of 3018 of 300.8%

A fall from 27 to 24 passes out of 30 happens by chance almost one time in four, so it shows nothing yet. The same ten-point fall across 60 runs per round is still a one-in-ten event. A fall from 27 to 18 is under 1%, and that is worth reporting. A common working rule is to treat anything above 5% as not shown yet and collect more runs.

Two habits keep this honest. Decide which rounds you will compare before you run them, because checking after every single run and stopping at the first scary number will find a "drop" sooner or later. And compare like with like: the same tasks, the same model ID, the same effort, the same Claude Code version on both sides unless the version is the thing you are testing.

Match what you see to a cause

Most of the complaints in the threads fit one of the explanations above. This table puts the symptom next to the cause this post found for it and the place to check.

What you noticeLikely causeWhere to check
Shorter reasoning and more mistakes on multi-step tasks since you moved to Opus 5.5Your old effortLevel is ignored and the model runs at its medium defaultStep 1 script, then /effort high with Opus 5.5 active
Subagents got worse after an update in early NovemberSince 2.1.317, a subagent on a different model uses that model's saved or default effortAdd an effort field to the subagent, or set CLAUDE_CODE_SUBAGENT_EFFORT
A resumed session seems to have lost its earlier reasoning2.1.318 removed the fix that kept earlier thinking for conversations started on 2.1.286 or earlierCompare with a fresh session on the same task
The thinking text reads differentlyThe summaries come from a separate summarizer model, and its style changedIgnore the wording and run the task set in Step 4
Results differ between your terminal and CIAn environment variable or a managed settings file sets a different level, and both outrank your saved oneStep 1 script on both machines

If none of the rows fits and your pass rate still fell by more than noise, you may have found a real regression. That is the case the next section is for.

What to put in a report if the drop holds

A report that someone else can rerun gets read. One that says "it feels dumber" gets a reply asking for details. If your numbers hold across several rounds, include these in the GitHub issue:

  • The output of claude --version for each round, and the dates of the rounds.
  • The full model ID and the effort level, plus where the level was set (flag, environment variable or settings file).
  • The CSV from the task runner, with every run and not only the failures.
  • The task folders themselves, prompt.txt and check.sh, with anything private removed.
  • Whether your hooks, MCP servers or CLAUDE.md files changed between the rounds.
  • The figure from the noise check above, so readers can see you tested for it.

What to do this week

If your sessions have felt worse since early November, work through this list in order. Each step takes a few minutes and removes one explanation.

  1. Run the effort check script. If your user settings have only a top-level effortLevel, Opus 5.5 is ignoring it. Run /effort high with Opus 5.5 active, or add a modelSettings entry.
  2. Look at your subagents. Since version 2.1.317, a subagent on a different model uses that model's saved or default effort. Add an effort field to the ones that do real work, or set CLAUDE_CODE_SUBAGENT_EFFORT.
  3. Stop judging the model by its thinking summaries. They are written by a separate summarizer, Opus 5.5 hides them by default, and you pay for the full thinking either way.
  4. Pin claude-opus-5-5 by full ID in scripts and CI, and pass --effort explicitly there.
  5. Run the transcript script to see whether your own output tokens or tool calls changed on a specific day, and compare that day with your Claude Code update history.
  6. Build five to ten tasks from your repo and start logging pass rates. A month of that log is worth more than any thread.

If you want ready-made pieces for that last step, the Opus 5.5 Coding Workflow & Cost Kit on JR Devhub's Gumroad store is a small kit for working with Opus 5.5 in Claude Code: a 13-page PDF guide on planning, testing, code review and cost accounting, five editable Markdown templates plus a CLAUDE.md starter, an editable spreadsheet for estimating Claude API token charges, and two Swift packages (a flawed starter and its fix) with the same 12-test suite. It does not include a regression runner or predict subscription limits, and it is an independent product, not affiliated with Anthropic.

FAQ

Did Anthropic confirm that Opus 5.5 was changed on November 3?

No. Coverage through November 9 found no public statement from Anthropic about the complaints. The model ID stayed claude-opus-5-5 throughout the period the charts cover.

Does a change in thinking summaries mean the model thinks less?

Not by itself. Anthropic's documentation says summaries are written by a different model, and you are billed for the full thinking tokens. In Theo's sample, reasoning tokens per response went up slightly after the switch, from 369 to 413.

Why does my effortLevel setting not work on Opus 5.5?

In your user settings file, the top-level effortLevel key only applies to Opus 5, Fable 5.1 and earlier models. Opus 5.5 starts at its own default, which is medium, until you save a level for it under modelSettings, usually by running /effort with Opus 5.5 active.

Is max effort the fix?

Usually not. Higher levels cost more tokens and time, and on easy tasks the extra reasoning rarely helps. Try high first, and measure with your own task set before you leave anything at xhigh or max.

Sources