# How to Choose Effort Levels for Claude Opus and a Planner Model > Source: > Published: 2026-11-12 00:00:00+00:00 # How to Choose Effort Levels for Claude Opus and a Planner Model A guide to splitting planning and execution between a frontier reasoning model and a cheaper model, with effort-level tips for coding workflows. ## What’s the right way to split work between a top-tier model and a cheaper one? The short answer: use the most capable, most expensive reasoning model to plan, research, and make architectural decisions, then hand off a well-defined plan to a cheaper model to actually write and iterate on code. This “planner plus workhorse” split shows up repeatedly in how top labs and practitioners structure agent workflows, and it matters more now that the newest frontier models cost significantly more per task than the previous generation. Getting the effort level right on each model is just as important as picking which model does which job. ## TL;DR - **Frontier reasoning models excel at open-ended, high-ambiguity work** like architecture decisions, resolving conflicting approaches, and synthesizing a long back-and-forth into a clear plan. - **Cost scales fast with model tier and effort level** , so routing every task to the top model burns through usage limits quickly without a proportional quality gain on simpler work. - **The core workflow is a two-session pattern** : one session with the expensive model produces a handoff document (a plan.md), then a fresh session with a cheaper model reads that document and executes. - **Effort level matters as much as model choice** , and the jump from medium to high reasoning often delivers a bigger quality gain than jumping from high to max, at a fraction of the cost increase. - **Well-defined tasks erase the gap between a frontier model and a cheaper one** , which is why doing the planning work up front is what makes it safe to execute with a less expensive model. - **Orchestration tooling (cookbooks, custom workflows, in-session advisor features) exists to automate this split** , though some built-in advisor patterns have been shown to be inefficient compared to a clean two-session handoff. Remy. ## Why not just use the best model for everything? Because the best model is often dramatically more expensive per task, and that expense doesn’t buy you much on tasks that are already well scoped. Benchmarked cost-per-task figures for the newest frontier reasoning tier can run several times higher than a strong previous-generation model at a comparable effort setting. In some cases, the frontier model isn’t even more “efficient” in the sense of needing fewer tokens to get the job done. It’s simply a bigger, more capable, more expensive model that happens to do a better job on hard, ambiguous problems. On tasks that are narrow and clearly specified, independent testing has shown the frontier model and a cheaper model land close to equivalent in score, with the frontier model costing substantially more to get there. This matters in practice because coding agents can burn through a usage allowance surprisingly fast if every request routes to the top-tier model by default. People running the most expensive model on every task inside a coding agent have reported exhausting an entire usage window in well under half an hour. ## Where does the expensive model actually pay off? It pays off on long-horizon, open-ended work: deciding on an application’s architecture, resolving a stuck back-and-forth where a cheaper model keeps proposing partial solutions, or synthesizing a messy planning conversation into something concrete. This is the use case where a top reasoning model separates itself clearly from the pack on benchmarks that measure open-ended, multi-step reasoning. A common pattern: when a cheaper model gets stuck going in circles on a design decision, hand the entire conversation transcript to the frontier model with a prompt like “here’s the problem, here’s how we’ve been thinking about it.” The frontier model is often able to converge on a workable solution quickly, in a way that the cheaper model couldn’t, because it’s built to handle exactly that kind of ambiguity and back-and-forth reasoning. That’s the model’s strength. It is not generally a better choice for well-defined, narrow execution tasks, where cost rises without a meaningful quality gain. ## How do you structure the two-model workflow in practice? The simplest version is a two-session pattern inside whatever coding agent or harness you’re using: 1. **Planning session.** Start a session with the frontier model. Have it load context from the codebase, search for relevant information, and work through the harder architectural or design decisions with you. 2. **Handoff document.** Once the plan is solid, have the model write it down in a simple markdown file (a plan.md works fine). This becomes the single source of truth for what needs to happen next. 3. **Execution session.** Start a brand new session, switch the active model to the cheaper one, and have it read the handoff document and execute: writing code, running tests, iterating on implementation details. *Enterprises have Remy.* The reason this works is that the planning session removes the ambiguity. Once a task is well defined, a cheaper model can execute it just as well as the frontier model would, because the hard decisions are already made. You’re not sacrificing quality by switching models for execution, you’re just no longer paying a reasoning premium for work that doesn’t need it. There are a few ways to implement this beyond manually swapping models between sessions. Prompt engineering cookbooks from model providers describe this same orchestration pattern (big model plans, small model executes) as a general best practice. Custom workflow builders can automate the handoff, running the planning step with the frontier model and then automatically kicking off a second node with the cheaper model to build and iterate. Some coding agents also offer an “advisor” feature, where the cheaper model handles execution but periodically calls on the more capable model for advice on harder sub-decisions. That pattern is appealing in theory, but it has been shown in practice to not save much on cost compared to a clean, deliberate handoff, since advising calls can be made more often than necessary. ## What effort level should you actually use? This is where a lot of people overspend without realizing it. Reasoning effort levels (typically something like medium, high, extra high, and max) scale cost steeply, but the benchmark gains don’t scale the same way. For the frontier reasoning model, there is often a large quality jump moving from medium to high effort on complex coding tasks, large enough to justify the extra cost even though it can mean roughly tripling the price per task. But moving beyond high effort tends to show diminishing or flat returns. Going from high to the next tier up can show essentially no improvement, and pushing to the maximum effort setting might only add a small single-digit gain on benchmark scores, while costing substantially more per task. Given that gap, high effort is generally the sensible default for the frontier model rather than max. For the cheaper execution model, the calculus is different because by the time it’s running, the task should already be well defined thanks to the planning step. That means you don’t need to push its effort level as high to get strong results, since the ambiguity that effort level is meant to compensate for has largely already been resolved upstream. The practical takeaway: treat effort level as its own lever separate from model choice. A frontier model on high effort is often close in capability to the same model on max effort, at a meaningfully lower cost, so defaulting to max “just to be safe” is usually wasted spend. ## Frequently Asked Questions ### Should I ever use the most expensive model for simple tasks? Generally no. On narrow, well-defined tasks, independent benchmarks show a cheaper model performing close to equivalent to the frontier model, so the extra cost doesn’t buy a meaningful quality improvement. ### What’s a handoff document and why does it matter? It’s a simple markdown file (often called plan.md) where the planning model writes down the decisions it made: architecture, approach, steps to take. The execution model reads this file at the start of its own session, which turns an ambiguous task into a well-defined one before any code gets written. ### Does raising effort level always improve output quality? *Nothing gets lost.* No. Gains tend to be large moving from lower to mid-high effort settings, then flatten out. Pushing to the maximum effort setting typically adds only a small benchmark improvement while increasing cost substantially, so it’s rarely the best default. ### Can I automate the planning-then-execution handoff? Yes. Workflow tools that chain model calls, prompt engineering cookbooks describing orchestration patterns, and in-agent advisor features all offer ways to automate the split, though a manual two-session handoff is often more cost-efficient than built-in advisor features that call the expensive model too frequently. ### How do I know if a task needs the frontier model at all? If the task is open-ended, involves architectural tradeoffs, or requires synthesizing conflicting information or a stalled conversation into a decision, it’s a good candidate. If the task is already clearly scoped (a specific bug fix, a defined feature with clear requirements), a cheaper model is usually sufficient.