At a glance: Claude Opus 4.8’s effort parameter has five levels —
low·medium·high·xhigh·max— that tune reasoning depth and token consumption in one move. Drop simple tasks to a lower level to save cost, and push coding and agent work up toxhighto protect quality. Map task difficulty to effort levels ahead of time and your automation cost becomes predictable.
I run a one-person business with Claude open all day. Handling my blog publishing pipeline, code edits, and document review in a single window, I found that the variable dividing cost wasn’t only “which model you use.” Even on the same Opus 4.8, how deeply you make the model think per task drove the end-of-month bill. Until I learned to handle the effort parameter properly, I was running even simple classification tasks at the top level and bleeding tokens.
This isn’t a launch-news recap. It focuses on the practical decision of mapping effort levels to task difficulty, and how to layer that onto autonomous work like Dynamic Workflows.
What the effort parameter is
Effort (Effort Control) is a control that adjusts the model’s reasoning depth and overall token spend in one move. Per Anthropic’s official docs, you set it inside output_config.effort across five levels — low·medium·high·xhigh·max — and it’s a fully supported feature with no separate beta header required. The default is high, so if you omit the value it runs at high.
Lower effort leads to fewer, more consolidated tool calls, shorter preambles, and concise confirmation replies. The result is fewer output tokens. Higher effort does the opposite: the model deliberates more deeply and verifies more thoroughly before it answers.
You have to look at the pricing structure alongside this to understand why effort is a cost lever. Per the official model overview, Opus 4.8 is $5 per million input tokens and $25 per million output tokens. The key point is that the output price is five times the input price. Most of the cost comes from “how much, and how deeply, the model talks” — and effort presses directly on exactly that spot. (Prices can change, so I’d recommend confirming the exact values on the official model overview page as of the time you read this.)
Mapping effort levels to task difficulty
The branching rule I ran for over a month and settled on is simple. Split tasks by difficulty, then assign an effort level to each cell.
| Task type | Recommended effort | Why |
|---|---|---|
| Classification, labeling, short extraction | low |
Almost no reasoning needed. Cuts both latency and cost |
| General summaries, document conversion | medium |
A comfortable balance of quality and cost |
| Analysis, multi-step reasoning | high |
Safe default for tasks where intelligence matters |
| Coding, agent work | xhigh |
Recommended by the official docs for coding/agents; Claude Code default |
| Accuracy over cost | max |
Tasks where being wrong is expensive. Opus-family only |
The official docs point to xhigh as the best setting for most coding and agent work, and recommend at least high for tasks where intelligence matters. They state that max should be used only when accuracy is more important than cost, and that low is appropriate for subagents or simple tasks. Note that max and xhigh work only on Opus 4.6 and later and on Sonnet 4.6; on some older models they throw an error.
I use this mapping as-is in my publishing pipeline. The step that quickly screens keyword candidates into “positive/negative/neutral” drops to low, while the in-depth review of a body draft goes up to high. Dropping the simple steps to low barely moved the results. When I’m cost-sensitive, the safest approach was to go down one level and start testing from medium.
Pairing it with adaptive thinking
Handling effort alone isn’t the whole story. Opus 4.8 changed the way it thinks itself.
Opus 4.8 supports thinking: {type: "adaptive"}. The old budget_tokens, which specified a fixed token budget, has been removed — include it and you get a 400 error. With adaptive thinking, the model decides its own depth of thought per task, so there’s no need to hand-tune a budget. The structure is: effort sets the ceiling on overall spend, and adaptive thinking adjusts per-task depth on its own within that ceiling.
Going a step further, there’s task budget (beta). When you tell the model, via output_config.task_budget, how many tokens to give an entire agent loop (minimum 20,000 tokens), it watches the remaining amount as a countdown and prioritizes and wraps up its work on its own. This differs from the hard cap max_tokens. max_tokens is a per-response hard limit the model isn’t aware of, whereas task_budget is an advisory the model does perceive. It fits well when you want to tame cumulative cost in long autonomous work.
At first I pinned effort to xhigh and ran everything through it, even simple tasks — then got a shock at the end of the month when output tokens came in far higher than expected. Only after splitting tasks by difficulty and branching effort did the cost curve flatten out.
Layering it onto autonomous work like Dynamic Workflows
Where effort control shines most is autonomous work. Dynamic Workflows, released alongside Opus 4.8, is a feature where Claude splits a large task into small pieces on its own and runs several subagents in parallel within a single session. You can delegate wholesale the kind of work that would take you half a day alone — auditing an entire codebase, or batch-processing hundreds of files.
The catch is that running many agents drives token consumption up. This is where effort branching becomes a cost safeguard. Keep the main loop that drives the whole task at a high level, since quality matters there, but ask that the sub-steps handling simple checks inside it drop to a lower level. The official docs, too, recommend low for subagents and simple tasks.
There is one thing worth stating clearly, though. Some communities are passing around talk that an “Opus 5” or “Claude 5” is coming soon. That is not an official announcement yet. Anthropic’s materials only mention a ‘Mythos’-series model run in a separate, limited program; nothing has been confirmed as an official next-model release. So rather than putting work off for next-model rumors, there’s far more real benefit in deciding where and how to apply the effort of the 4.8 you already have in hand.
Closing checks for a solo operator
The stronger the tool, the more you need to know its limits to use it. Here’s the checking order I settled on.
- Split tasks by difficulty first. Effort is only meaningful when applied differently per task. The moment you apply the same level to every task, cost leaks or quality drops.
- When cost is suspect, go down one level and compare. Many tasks hold their results when dropped from
hightomedium. Step down one level at a time and watch quality and cost together. - For autonomous work, separate the main and sub levels. Split the main loop high and the simple sub-steps low, and even a large task becomes cost-predictable.
In short, effort control is the key lever for “how cleverly you use the same Opus 4.8” in workflow automation. Separate from the choice of stepping the model down (cost savings), the most practical thing for a solo operator is that you can adjust reasoning depth to task difficulty even within the same model. Automation handles execution; planning and reviewing which level to apply to which task is the human’s job. A tool reducing cost and cost optimizing itself are two different things.
Sources: Anthropic official docs — the effort parameter (platform.claude.com/docs/en/build-with-claude/effort), model overview, and the adaptive thinking guide. Pricing and parameter specifications are as of the publication date (2026-06-12); confirm the latest values in the official docs. Some features such as Dynamic Workflows and task budget are in beta/preview, and their detailed behavior may change.
Sources: Anthropic docs — Effort parameter, Anthropic docs — Model overview, Anthropic docs — Adaptive thinking