Why Some AI Models Work Great On Low Effort And Others Don't

Every coding agent I use has a setting for this now. Claude Code has /effort, Codex has model_reasoning_effort, and OpenCode has /variants. In opencode I cycle through variants with a keybind. Low, medium, high, and then something at the top like xhigh or max.

And for the longest time I had no idea what it was doing when I turned that up. My assumption was that I'm giving the model more brainpower. More CPU, a bigger engine. Higher effort, smarter model. That's what the word "effort" makes you think, right?

Nope. The model doesn't get bigger or faster or smarter. Every layer, every weight, all of it stays exactly the same. The only thing that changes is how long it talks to itself before it answers you.

Once it clicked for me, a bunch of stuff I had been confused about for a while made sense. Things like, "Why my cheap fast model sometimes keeps up with the expensive one?", "Why cranking effort to max sometimes makes things worse?", and "Why the same setting acts completely different depending on what's behind it?" started making sense.

What An Effort Level Actually Is

Firstly, what does "thinking" even mean here?

When you ask a reasoning model something, it doesn't answer you straight away. It writes out a pile of text you sometimes see (depending on the harness/agent you use), working the problem, second-guessing itself, trying something and backing out of it. That's the "thinking", or the reasoning trace. Then it writes the answer you actually get based on that.

So thinking is the model writing more text before the text you asked for. That's all it is. Which means an effort level controls how much of that scratch text gets written. The interesting thing is how it controls it, and this is where I was wrong.

I figured there was a real limit in there somewhere. A counter, a ceiling, something in the code cutting it off. There isn't. And we know there isn't, because OpenAI released a model family openly (gpt-oss) and you can just go look at the plumbing. The effort level is a line of English in the system prompt:

Reasoning: high

Their model card says it plainly, that they "train the models to support three reasoning levels: low, medium, and high. These levels are configured in the system prompt by inserting keywords such as "Reasoning: low"."

The model reads "Reasoning: high" the same way it reads everything else you sent it. Nothing special fires in the code. It just goes along with the instruction, because during training it saw thousands of examples where those words came before long, careful thinking.

It's closer to telling a coworker "hey, take your time on this one" than to turning up a thermostat.

Anthropic's older API had budget_tokens, where you pass a real number, which really sounds like a hard limit. Buried in those same docs is a line about how changing that number breaks prompt caching "because the budget value is rendered into the prompt." So you thought you were setting a limit, but in fact, you were editing text.

Why It Can't Be A Hard Limit

Why don't the labs just enforce it properly? Count the tokens, stop at the limit, done.

Two reasons, and the first one really surprised me.

Models can't count their own tokens. The people behind the s1 paper actually tried training a model to hit exact token targets, asking for a thousand tokens of thinking, then sixteen thousand. What came back was roughly the same length every time. There's no odometer running in there. The model has no more idea it's on word 4,000 of 8,000 than you know which syllable you're on right now.

So they tried limiting steps instead, and the model got around that almost immediately. When told to use few steps, it wrote a handful of huge ones. Told to use many, it wrote a pile of tiny ones. Same amount of thinking either way. The paper's own words are that the model "learns to hack its way around the compute constraint."

The other reason is that a hard cutoff would be useless anyway. Stop a model mid-thought and you don't even get a shorter answer, you get no answer.

So every lab landed on the same design. Train the habit, don't enforce the limit. Teach it to be short or thorough when asked, then hope for the best.

Which is why these settings feel a bit fragile in practice. You're leaning on a habit, not flipping a switch. Anthropic's docs even mention in passing that Opus 4.7 "respects effort levels more strictly" than Opus 4.6, and nothing about the API changed between the two. They just got better at training it to listen.

Why More Thinking Costs More Money

Those hidden thinking tokens are still tokens. You pay for them at the output rate, same as the answer, they just never get shown to you (although you can see thinking in some harnesses). So a model that thinks for three pages before writing one paragraph bills you for three pages and a paragraph.

More thinking means more waiting. When an agent is coding for you and the harness is looping the model over and over, the gap between low and high can easily be three times the wait (per turn). In a loop that might run for dozens of turns.

Artificial Analysis makes this easy to see, because they now score every effort level as if it were a separate model. Here's Claude Opus 5 across all five of its settings:

Low to high buys you 8 points and roughly triples the bill. High to max buys 2 more points and nearly doubles it again. The bottom of the ladder is where the value is, and the top is where the money goes.

Anthropic isn't hiding this either. In Artificial Analysis' writeup of the launch, the spread across Opus 5's effort settings on one agentic benchmark came to "407 Elo points, with output token usage ranging around 8x from low to max effort." Eight times the tokens between the cheapest setting and the dearest one, on the same model, doing the same work.

And then there's a third cost. Since effort is baked into the prompt, switching it mid-conversation wipes your prompt cache. Anthropic spells this out, that "because effort shapes the rendered prompt, changing it between requests does not preserve cached prefixes from earlier turns." So if you get clever and drop to low effort for the easy turns of a long session, you can end up paying more, because every switch throws the cache away. Pick a level, and stay there.

Why Some Models Are Great On Low Effort

Okay, the actual question.

If thinking is where the reasoning happens, a model that barely thinks should be way worse than one that thinks a lot. And yet I notice some models perform better with thinking turned way down, while some fall apart.

Two things going on here, and they're related.

The thinking already happened

Some labs literally train the fast mode on the slow mode's homework.

NVIDIA's Nemotron 3 Nano does it by cutting the thinking short on purpose during training. They "randomly truncate 3% of reasoning traces to different reasoning budgets, before continuing with the original post-reasoning response", so the model gets practice at producing the full answer off a half-finished thought. DeepSeek's V4 work goes further and trains separate models for different effort levels, each with its own length penalty, then combines them all into one through distillation. Either way, the long careful thinking happened once, back in training, and got squashed into the weights.

Think of a senior engineer glancing at a stack trace and naming the bug in four seconds. They're not skipping the reasoning. They did that reasoning years ago across a few hundred similar bugs, and now it's instinct. A junior dev looking at the same trace has to talk it through, check the docs, walk the call stack, and get to the same place out loud.

Some models never needed the trace much anyway

The second thing is a pattern that's hard to unsee once you've spotted it. The worse a model is, the more it gains from higher effort. The better it already is, the less the setting does.

GPT-5.6 makes this easy to check, because OpenAI shipped it in three sizes and Artificial Analysis scored every one at every effort level. Same generation, same training, same ladder. The only real difference is how big the model is:

The smaller the model, the more the effort setting is carrying it. Luna nearly doubles its score across the ladder. Opus 5, which starts where Luna finishes, gains barely half as much.

Because a small model at max effort costs about the same as a big model at low effort, you can compare them directly:

Same score, and the small model thinking hard is the cheaper way to get there. Model size and effort are two separate knobs that partly do the same job, and past a point it's cheaper to buy the thinking than the parameters.

For a strong model, thinking is a small fix on top of good instincts. For a weak one, thinking is where most of the work happens, so take it away and you've taken away most of the model.

Which gives you a handy rule when you're picking a model. If something needs high effort before it's usable, that's not really about the effort setting. The ability isn't in the weights, and you're paying tokens every single turn to make up for it.

Anthropic pointed out that Opus 4.5 at medium effort "matches Sonnet 4.5's best score on SWE-bench Verified, but uses 76% fewer output tokens."

When High Effort Makes Things Worse

A paper from Anthropic Fellows and Anthropic staff built tasks where thinking longer drives accuracy down, and found that different model families fail in their own particular ways. Claude models get "increasingly distracted by irrelevant information". OpenAI's o-series models "resist distractors but overfit to problem framings", which means latching onto an approach they've memorised that doesn't fit the actual question.

A separate group of researchers, in a paper actually called "Do NOT Think That Much for 2+3=?", found reasoning models burning silly amounts of thinking on basic sums, working out the same answer over and over, writing a dozen separate solutions to something a child could answer. On the easiest problems, almost none of those thinking tokens did anything useful.

It's the junior dev handed a two-line fix and three days to do it. Work expands to fill the space you gave it.

Anthropic ran this experiment on real users by accident, and the writeup is worth reading properly. In their April 2026 postmortem on Claude Code quality complaints, they explain that they'd lowered the default effort from high to medium to fix speed. Their internal tests said the quality drop was slight. Users noticed straight away and started reporting that Claude Code "felt less intelligent", and Anthropic admits "neither our internal usage nor evals initially reproduced the issues identified." They called it "the wrong tradeoff" and put it back.

What I take from that is that benchmarks average away exactly the rare, hard work where effort matters most. Your own gut on this is better evidence than a leaderboard.

What Actually Happens When You Pick An Effort Level

So you type /effort high in Claude Code. What actually leaves your machine?

I went digging through the source of these tools rather than guess, and the answer is almost disappointingly small. One string changes in the request. Usually nothing else.

In opencode the system prompt gets put together before your chosen variant is even looked up, and the variant only ever gets merged into the options. It never touches your prompt or your tool definitions. Codex builds its instructions and tools from the prompt, then works out the reasoning setting separately in a function called build_reasoning. Claude Code writes one field and leaves everything else alone.

opencode has to translate, and you can read the whole mapping in reasoningEffort() in transform.ts. "high" needs to become reasoning.effort for OpenAI, output_config.effort for Anthropic, thinkingConfig.thinkingLevel for Google, and something else again on Bedrock. Same word you picked, four different shapes going out.

Codex is tidier, since it only talks to one API. Its ReasoningEffort enum is worth a look though, because it carries more levels than the docs admit to, including Ultra and a Custom(String) catch-all for effort levels the server knows about and the client doesn't yet.

Effort settings don't carry over across providers, and going by Anthropic's own advice, not even across model generations. The high you carefully tuned for one model is a different amount of thinking on another. Swap models while keeping your settings and you've quietly changed two things at once.

The magic words are just words now. Claude Code's ultrathink doesn't set a budget anymore. In the current build it adds a note to your message saying the user asked for deeper reasoning this turn, and that's all it does. think harder and megathink, which used to map to different budgets, don't exist at all. Claude Code ships minified so there's no source to link, but the model config docs cover how /effort, the --effort flag, CLAUDE_CODE_EFFORT_LEVEL, and the effortLevel setting all stack up.

The very top of the ladder isn't really an effort level. Claude Code's ultracode sets effort high and adds instructions changing how it hands work to subagents. Anthropic's own slash command reference gives it away, noting that "Ultracode is not a distinct level and reports as xhigh." Codex's ultra does something similar, sending max and switching subagents from opt-in to on by default. Those two are modes dressed up as effort levels, which is why they feel different rather than just slower.

And the prompt does get rewritten, only not on your computer. Anthropic says effort "shapes the rendered prompt" on their end. Your client sends a short string, and that string becomes prompt text inside their systems. Same trick gpt-oss showed us in the open, you just can't watch it happen.

How I Pick Now

I've stopped treating this as a quality slider and started treating it as a question about the task.

Medium is my default and I mostly leave it alone. The jump from medium to high is the worst value on the ladder, costing a lot more for a small gain on most work. Both OpenAI and Anthropic now say roughly this in their own docs, which is telling, given they'd both make more money if I maxed everything out.

I go up when the work needs real step-by-step reasoning. A nasty debugging session where the cause is nowhere near the symptom, a migration touching many layers, anything I'd sketch on paper before starting. I go down for mechanical stuff like renames, boilerplate, formatting, simple lookups.

One habit that's saved me more than any amount of effort tuning is that if a model is going in circles at high effort, the fix is almost never more effort, it's a smaller task. Both the research and my own experience point the same way, that breaking work into separate focused turns beats asking one turn to think harder. Better tools and clearer instructions beat it too. Sometimes, fixing the setup around the model wins over turning up the model.

Conclusion

Effort levels look like plumbing and behave like a suggestion. You're changing a phrase in a prompt that the model was trained to take seriously, and it answers by writing more or less to itself first.

Which is why the same setting acts so differently from one model to the next. How much the thinking helps comes down to whether the ability got baked into the weights during training, or has to be worked out loud every single time. Models that did their thinking during training barely need it. The ones that didn't can't work without it.

Not unlike what I found digging into context windows, where a big number on the spec sheet turned out to say very little about whether the model could actually use it.

So pick a level on purpose and leave it there, instead of letting it drift or trusting whatever the default happens to be this month. And before you reach for max on everything, run the same task twice, once low and once high, then compare what the second one cost you. Going by the numbers above, there's a fair chance you're paying double for two points.