beckon
Beckon blog

Claude Code Effort Levels Tested: Medium vs High vs Xhigh vs Max

ยท Beau Johnson

In shortOn a 16 bug codebase, Opus 5.5 in Claude Code fixed 14 bugs at medium, high and xhigh, and 16 only at max, which took about 13 times longer than medium. Medium (the default) suits everyday work; max is worth it for order-dependent bugs like race conditions.

In this video I give Claude Opus 5.5 the same 16 bug codebase in Claude Code four times, once at each effort level: medium, high, xhigh and max. Same prompt, same repo, same rules. Only max ever found all 16, and it took about 13 times longer than medium. If you use AI coding agents every day and have never touched the effort setting, this is for you, because medium is what you've been getting.

What I cover in this video

  • 0:00 Four effort levels, one bug hunt, and why the default matters
  • 0:46 What an effort level actually is, and how to set it in Claude Code
  • 3:05 The test: Tallyhouse, 16 hidden bugs, 11 decoys and hidden tests
  • 4:36 The race, including max starting its own background agent
  • 6:06 The scoreboard, medians of three rounds
  • 7:39 The charts: score per minute and per 100K tokens
  • 8:24 How it lines up with Artificial Analysis
  • 9:55 Which effort I'd use for which job

What an effort level actually is

Effort isn't a different model. It's the same Opus 5.5, and you're telling it how much it's allowed to spend on your problem. Anthropic calls it a behavioral signal, not a strict token budget, and it affects everything the model writes: the thinking, the tool calls and the final answer. Lower effort means fewer tool calls. Higher effort means it reads more, tests more and checks its work more.

There are five levels: low, medium, high, xhigh and max. I left out low because this is a hard job and that's not what low is for. On Opus 5.5, thinking is always on, so effort is basically the one dial you get.

In Claude Code you open a slider with:

/effort

or set it directly:

/effort high

You can also pass --effort when you launch. One catch: max only lasts for the session you're in unless you set it with the CLAUDE_CODE_EFFORT_LEVEL environment variable. Otherwise you're back to your default next time, and on Opus 5.5 that default is medium, in both the API and Claude Code. Older Opus models defaulted to high, so Opus 5.5 starts one notch lower. Codex has its own reasoning effort setting, and Cursor lets you add it to the model name, so everyone picks a level every day, and most people pick it blind.

I run all of this in Beckon, which puts Claude Code, Codex and Cursor side by side on one canvas. I hold a key and talk to them, Beckon talks back when they finish, and every project keeps its own memory.

The test: 16 hidden bugs

Tallyhouse is an invoicing and client portal backend for small agencies that we built: about 3,000 lines across 42 files, with 16 planted bugs. Most are cross file, so the cause is in one file and the symptom shows up in another. Think one customer seeing another customer's data, a double charge when two requests land at the same time, tax that rounds off by a penny, or a report cache that goes stale. We also added 11 decoys, code that looks wrong but isn't.

The prompt never says how many bugs there are. It says to find and fix every real bug, explain each one in bugs.md, and that false reports cost points. With one bug every level fixes it and you learn nothing, which is why there are 16.

Scoring and rules

  • One hidden test per bug decides what's fixed. The agents never see them.
  • 14 more hidden tests check that a fix didn't break something that already worked.
  • Two third party judges (Grok 4.7 and Mistral Large 4) read the bug report against a hidden answer key. Two points per bug fixed and explained, so 32 is perfect.
  • Same prompt word for word, a fresh repo every run, web search off, a 60 minute limit, zero nudges, sandboxed runs.
  • All four levels ran three times. The scoreboard shows medians.

For reference, Sonnet 5.5 got 14 of 16 when we first built this test.

The race and the scoreboard

In round one, medium read the readme and tests, got to work, wrote its own test for every bug and finished at 4:31 with 14 of 16. High was a little more careful and finished at 7:47, also 14. Xhigh made 55 tool calls, even started the real server and hit it with requests, and finished at 13:12 with 14 again.

About 20 minutes in, max did something none of the others did: it started a second agent in the background with one job, run its own bug hunt on the same codebase. When the reviewer reported back, max took five of its findings. Two were the bugs every other level missed:

  • A stale cache: if a payment comes in while the revenue report is loading, it saves the old number and keeps showing it for the next 10 minutes.
  • A refund: it reopens a paid invoice, but payment reminders never turn back on, so the client owes money again and nobody tells them.

Every line of that code looks fine. You only see it when things happen in a certain order. Max wrote its final answer at 48 minutes, then waited on a backup timer it had set for itself, finishing at 55:46 with 16 of 16. That's the first perfect score we've seen on this test.

Medians across three rounds

  • Bugs fixed (of 16): medium 14, high 14, xhigh 14, max 16
  • Regressions: 0 in all 12 runs
  • Judge points (of 32): 28, 28, 27.5, 31
  • Time: 4:13, 7:10, 15:41, 55:46
  • Output tokens, thinking included: about 24.7K, 39.1K, 98.5K, 366K
  • Tool calls: 17, 34, 77, 214

Medium and high fixed the exact same 14 bugs every round. Xhigh was the least consistent: 14, 13, 15. Max went 16, 15, 16, and the two perfect rounds were the two where it started that second agent.

Where the curve flattens

Bugs fixed is flat until max, then one big step. Time roughly doubles at each level, then max blows up to almost an hour. Score per minute: medium about 6.5 points, high about 4, xhigh under 2, max about 0.5. Score per 100K output tokens: about 113, 72, 28 and 8.5. The two extra bugs are worth three points on the median, and they took about 50 extra minutes.

On the Artificial Analysis Intelligence Index (checked November 5), Opus 5.5 scores 48 at medium, 52 at high, 57 at xhigh and 59 at max. Their biggest jump is high to xhigh, which bought us nothing, and xhigh to max adds only two points there, while on ours it was the only step that moved. Where we agree is tokens: medium writes about 42.5M output tokens to run their index, max about 218M, roughly five times more for 11 more points. Speed is about 110 tokens per second at every level, so max isn't slower per token, it just writes far more. Time to first answer token is about 18 seconds at medium and almost 6 minutes at max. On Terminal-Bench 4.0, xhigh and max tie at 60%. If you want background on those benchmarks, see Coding Agent Benchmarks Explained.

Which effort for which job

  • Medium: most of your day. Features, everyday bug fixes, anything with tests it can run. 14 of 16 every round in about 4 minutes, and it's already the default.
  • High: didn't buy anything over medium here. I'd still reach for it on a big refactor across many files, but that's my take, not something this test proved.
  • Xhigh: Anthropic says it's built for long jobs over 30 minutes. On this bug hunt it took about twice as long as high and the results bounced around.
  • Max: the bug that's been fighting you, like a race condition. Kick it off, walk away for an hour, and remember it only lasts for that session.

Key takeaways

  • Opus 5.5 defaults to medium in Claude Code, one notch lower than older Opus models.
  • Medium, high and xhigh all landed on 14 of 16. Only max found all 16, at about 13 times the time and almost 15 times the output tokens.
  • No level broke a single regression test in any of the 12 runs.
  • Max's edge came on order-dependent bugs, and its perfect rounds were the ones where it started a second agent to hunt independently.
  • One codebase and three rounds: it's a vibe check, not a verdict.

FAQ

What is the default effort level for Opus 5.5 in Claude Code?

Medium, in both the API and Claude Code. Older Opus models defaulted to high, so if you never change the setting you're running medium.

How do I change the effort level in Claude Code?

Type /effort to open a slider, or /effort high to set it directly. You can also pass --effort at launch. Max only lasts for the current session unless you set it with CLAUDE_CODE_EFFORT_LEVEL.

Is max effort worth it for coding?

In my test, max was the only level to find all 16 bugs, but it took about 55 minutes versus about 4 for medium. It's worth it for bugs that only show up when things happen in a certain order, like race conditions, not for everyday fixes.

Does a higher effort level use a different model?

No. It's the same model. Anthropic describes effort as a behavioral signal for how many tokens Claude spends, and it affects the thinking, the tool calls and the final answer.

Run your agents in Beckon

A workspace for your coding agents. Get more work done in less time.

Download BeckonSubscribe on YouTube
Full video transcript

0:00I gave Opus 5.5 the same 16 bug codebase at four different effort levels. And the only one that ever found all 16 was max. It also took about 13 times longer than medium. Same model, same prompt, same repo. The only thing we changed was one setting. Medium was done in about 4 minutes, high in about seven, X high in about 15, and max just kept going. In two of the three rounds, it even started a second agent to check its own work. And here's something most people don't think about in Cloud Code. Opus 5.5 runs at medium by default. So, if you never touch this setting, medium is what you've been getting. So, in this video, we're breaking down what an effort level

0:46actually is. The race, the scoreboard, the charts, where the curve flattens out, and which level I'd use for which job. Let's jump right into it. So, what is an effort level exactly? It's not a different model. It's the same Opus 5.5, and you're telling it how much it's allowed to spend on your problem. Anthropic calls it a behavioral signal, not a strict token budget. And effort covers more than thinking time. Anthropic says it affects everything the model writes, the thinking, the tool calls, and the final answer. Lower effort means fewer tool calls. Higher effort means it reads more, tests more, and checks its work more. There are actually five levels: low, medium, high, X high, and max. We left out low because

1:32this is a hard job, and that's not what low is for. And on Opus 5.5, thinking is always on. You can't turn it off. So effort is basically the one dial you get. In Claude Code, you set it with /effort. You get a slider or you just type /effort high. You can also pass it when you launch. One catch, max only lasts for the session you're in. Next time you open Claude Code, you're back to your default. And like I said, that default is medium. Older Opus models defaulted to high. So Opus 5.5 actually starts one notch lower than the last one did. And Cloud Code isn't the only one. Codeex has its own reasoning effort setting, and Cursor lets you add it right to the model name. So everybody picks a level every single day and most

2:18people are picking it blind. This is where I run my coding agents. Beckin puts cloud code, codecs, and cursor side by side on one canvas. I hold a key and just talk to them. And Beckan talks back when they finish. Every project keeps its own billboard and memory. If you build with agents, try Beckan. Hey, Beckin.ai. So here's the test. It's a codebase we built called Tally House. It's an invoicing and client portal backend for small agencies. About 3,000 lines across 42 files, and we planted 16 real bugs in it. Most of them are cross- file, so the causes in one file and the symptom shows up in another. One customer seeing another customer's data, a double charge when two requests land at the same time, tax that rounds off by a penny, a report

3:05cache that goes stale. Then we added 11 decoys. Code that looks wrong but isn't. And the prompt never says how many bugs there are. It just says find and fix every real bug. Explain each one in a file called bugs.md. And false reports cost points. Now, we could have done one bug, but with one bug, every level fixes it, and you learn nothing. That's why we went with 16. Here's how it's scored. Hidden tests decide what's fixed. There's one hidden test per bug and the agents never see them. 14 more hidden tests check that a fix didn't break something that already worked. Then two third party judges read the bug report against a hidden answer key. That was Grock 4.7 and Mistral large 4 from labs

3:50that aren't in this test. Two points for every bug that's fixed and explained. So 32 is a perfect score. And the rules, same prompt word for word. A fresh copy of the repo every run. Web search off, a 60-minute limit, zero nudges, and every run is sandboxed, so it can't see the hidden tests. The only thing that changes is the effort flag. One run doesn't prove anything. So, we ran all four levels three separate times. Everything on the scoreboard is the median. And for reference, Sonnet 5.5 got 14 of the 16 when we first built this test. So, this is round one. All four started at the same second. You can see Medium reads the readme, reads the tests, and gets right to work. Once its

4:36fixes are in, it writes its own test for every bug. Medium is done at 431, 14 out of 16. High is a little more careful. A few more test runs, a few more checks, done at 7:47, also 14 out of 16. XH High keeps going. 55 tool calls. It even starts the real server and hits it with requests. Done at 1312. and 14 out of 16 again. And Max is still working. Now, here's what this is all about. About 20 minutes in, Max does something none of the others did. It starts a second agent in the background and gives it one job. Do your own bug hunt on this same codebase. Max keeps fixing things on its own. Then the reviewer reports back and

5:21Max takes five of its findings. Two of those are the bugs every other level missed. One is a cache. If a payment comes in while the revenue report is loading, it saves the old number and keeps showing it for the next 10 minutes. The other is a refund. It reopens a paid invoice, but the payment reminders never turn back on. So, the client owes money again, and nobody tells them. Every line of that code looks fine. You only see it when things happen in a certain order. Max wrote its final answer at 48 minutes. Then, it sat there waiting on a backup timer it had set for itself, which is a very opus thing to do. 5546 on the clock. 16 out of 16. That's the first perfect score we've ever seen on this test. So, here's the scoreboard. And these are the

6:06medians of three rounds. Bugs fixed on the hidden tests. Medium 14, high 14, X high 14, and max 16. Regressions zero. Not one level broke anything that already worked in any round. The judges points out of 32. Medium 28, high 28, XH high 27 and a half, and max 31. Time medium took 413, high 710, XH high 1541, and max 5546. Output tokens, and that includes the thinking. Medium about 25,000, high about 39,000, X high about 99,000, and max about 366,000.

6:52That's almost 15 times medium tool calls 17, 34, 77, and 214. And the API equivalent cost of these runs, we ran them on a subscription. So this is what claude code says each run would have cost on the API. Medium about $160, high about $225, XH high about $4.40, and max about $16. Now, here is what I'm talking about. Medium fixed the exact same 14 bugs in all three rounds. High the exact same 14 every time. X high was actually the least consistent of the four. 14 then 13 then 15. And Max went 16 15 16. The two rounds it got all 16 were the two rounds

7:39it hired that second agent. So let's put it on a chart. Bugs fixed is flat. 14 14 14 14 14 and then it jumps at max. So it's basically one big step at the very end. Time is a different story. Every step up roughly doubles the time. 4 minutes 7 15 and then max blows it up to almost an hour. Tokens look the same just steeper. Now look at it as score per minute. Medium earns about 6 and a half points for every minute it runs. High about four. X high under two and max about half a point a minute and score per 100,000 output tokens. Medium about 113, high about 72, X high about

8:2428, max about 8 1/2. So the two bugs Max picked up are worth three points on the median out of 32. And it took about 50 extra minutes to get them. If those are the bugs that have been costing your customers money, that's a great trade. If it's a Tuesday afternoon bug fix, it's not. So, is that just our test? Let's check it against Artificial Analysis. They run models through a whole set of evals, and they list Opus 5.5 at every effort level. As of November 5th on their intelligence index, medium scores 48, high 52, XH high 57, and max 59. So, on their chart, it climbs the whole way. And the biggest jump is high to X high. On our test, XH

9:10high bought us nothing. And from XH high to max, they only see two more points. On ours, that was the only step that moved. But here's where we agree. Look at the tokens. To run their whole index. Medium writes about 42 1.5 million output tokens. Max writes about 218 million. That's about five times more for 11 more points. And the speed is the same at every level, about 110 tokens a second. So, Max doesn't write any slower per token. It just writes way more before it answers. Time to the first answer token, medium, about 18 seconds. Max, almost 6 minutes. And on their coding numbers, Terminal Bench 4 has X high and max tied at 60%. So, extra

9:55thinking doesn't help on every kind of task. Take that for what you will. Their index isn't cla code. It's a mix of tasks run through the API. Ours is one code base in claude code. Two very different tests, and both say the top of the dial costs way more than it gives back most of the time. So, which effort should you actually use? Here's my rule of thumb from this test. Medium for most of your day. Features, everyday bug fixes, anything with tests it can run. It got 14 of 16 every single round in about 4 minutes. And it's already the default, so you don't have to do anything. High. Honestly, didn't buy anything over medium on this test. Same 14 bugs, about 3 more minutes. I'd still reach for it on a bigger job, like a

10:40refactor that touches a lot of files, but that's my take, not something this test proved. XH High. Anthropic says it's built for long jobs, over 30 minutes. On a bug hunt like this one, it took about twice as long as High, and the results bounced around. So, I'd save it for the long runs it's made for. And max is for the bug that's been fighting you, the race condition. The thing that only breaks when two things happen in a certain order. That's exactly the kind of bug where Max pulled ahead of every other level. Kick it off, go do something else for an hour, and check back. Just remember, it only lasts for that session. For me, I'm leaving clog code on medium for daily work. And when something's been broken for 2 days, I'm switching to max and walking away. And like I said, this is one code base and

11:25three rounds. It's a vibe check, not a verdict. So, what level do you actually run on? And did you even know medium was the default? Let me know down below. And if you learned something here, drop a like so more builders run into this one. Have a blessed day.