Why One Model Is No Longer the Default

Until about a year ago, the standard move was simple: pick your best model and run everything through it. Today that assumption is costing teams real money — and in some cases, real performance. The pattern emerging from Terminal-Bench 2.1’s top performers is more nuanced: a frontier model plans, cheaper models execute in parallel, and the numbers back it up.

GPT-5.6 Sol sits at 88.8% on the public Terminal-Bench 2.1 leaderboard as a single-agent setup. DeepSeek V4.1 Flash leads at 90.6% — but that delta shrinks when you factor in that Morph’s benchmarks show a mixed-model stack running 40 end-to-end app builds costs 57% less than an all-frontier approach, with nearly identical acceptance rates. At scale, the math changes what “best” means.

This is a practical setup guide. By the end you’ll have a working multi-model pipeline using Claude Code’s built-in tooling, understand when to add local model executors, and know where this pattern breaks down before you find out the hard way.

The Benchmark Context: Terminal-Bench 2.1

Terminal-Bench 2.1 tests agentic coding in real terminal environments — file system operations, shell commands, test runners, and multi-step debugging tasks. It’s closer to what your CI pipeline actually runs than most academic benchmarks. The September 2026 leaderboard, compiled across both vendor-submitted and community-run harnesses:

A few things stand out. First, GLM-5.3-Flash at 84.3% costs a fraction of GPT-5.6 Sol. Second, the gap between the top 6 models is only 2.6 percentage points — within a margin where harness differences can dominate. Third, Cognition’s SWE-2 reported 92.8% but it’s marked unranked on the public board because it runs Devin CLI rather than a standard harness. Harness choice matters more than most leaderboard summaries acknowledge.

The implication: you don’t need the top model for every turn. You need it for decisions. Execution is where you can save.

The Planner-Executor Pattern: Cost Math

Morph benchmarked 40 end-to-end app builds (scaffold, feature, refactor, and production tasks) and found that a typical build consumes roughly 14 million tokens — split approximately 30% on planning turns and 70% on execution turns like file reads, tool calls, and edits. That split is what makes model routing pay off.

Here’s what the numbers look like in practice:

With prompt caching at a 70% hit rate on executor turns — which is realistic for repetitive file-read operations — total savings reach 60%+ versus all-Opus setups. For a team running 20 builds per developer per week, the cost-optimized configuration saves roughly $1,000 per developer monthly.

The acceptance rate drop from Haiku 4.5 as executor is real but manageable. Morph reports roughly 4–7 percentage points lower first-pass acceptance rates, offset by retries averaging under 1.2 additional turns. Whether that tradeoff is worth it depends on your review bandwidth and how tightly you’ve scoped executor tasks.

Step 1: Start with Claude Code’s Built-In opusplan

Before building custom orchestration, use what’s already there. Claude Code ships with a native planner-executor model called opusplan that requires zero infrastructure to get running.

What opusplan Does

opusplan automatically uses Opus 5.5 during Plan Mode (when you’re scoping and decomposing work) and switches to Sonnet 5 for execution turns. You get the expensive model’s reasoning where it matters and the efficient model where it doesn’t — automatically, without writing a line of orchestration code.

Enabling opusplan

Start a session with it via the command line:

claude --model opusplan

Or switch mid-session:

/model opusplan

For 1M context on both planning and execution phases (useful on large codebases):

/model opusplan[1m]

To make it permanent, add it to your settings file at ~/.claude/settings.json:

{
  "model": "opusplan",
  "modelSettings": {
    "claude-opus-5-5": { "effortLevel": "high" },
    "claude-sonnet-5": { "effortLevel": "medium" }
  }
}

Controlling Which Versions the Aliases Resolve To

By default, opus resolves to claude-opus-5-5 and sonnet resolves to claude-sonnet-5. You can pin or override these per environment via environment variables — useful when testing a newer model on staging before rolling to your team:

export ANTHROPIC_DEFAULT_OPUS_MODEL="claude-opus-5-5"
export ANTHROPIC_DEFAULT_SONNET_MODEL="claude-sonnet-5"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="claude-haiku-4-5"

These apply to alias resolution across all Claude Code sessions, not just the current terminal.

Step 2: Add Parallel Workers for Independent Tasks

The single planner-executor pair covers sequential work well. For naturally parallel tasks — running tests in different modules, generating documentation for multiple services, reviewing separate PRs — you want concurrent agents.

Claude Code’s agent spawning is straightforward from a shell script in your CLAUDE.md or directly in a task manifest:

declare -a PIDS
for task in "refactor_auth" "update_docs" "run_integration_tests"; do
  claude --model haiku "Handle ${task} task, output to ${task}_result.json" &
  PIDS+=($!)
done
for pid in "${PIDS[@]}"; do
  wait $pid
done

A few rules that will save you debugging time. Each agent must write to a disjoint output path — conflicts on shared files are the most common failure mode. Use .done sentinel files to signal completion before an aggregator reads results. And validate output contents, not just exit codes: an agent can exit 0 with an empty or malformed JSON output.

Task Contracts in CLAUDE.md

Define worker contracts in your CLAUDE.md to keep agent behavior consistent across your team. A minimal example for a refactor worker:

## Agent: refactor-worker
- Input: file path list in refactor_manifest.json
- Output: write diffs to refactor_${MODULE}_diff.json
- Tests: run pytest tests/${MODULE}/ before and after; capture results
- On failure: write error to refactor_${MODULE}_error.json and exit 1
- Never: modify files outside the module boundary

Explicit output schemas and failure contracts let the aggregator (your Opus planner turn) decide what to retry without needing to inspect log files manually.

Step 3: Add a Local Model Executor (Optional, High Savings)

For teams with data residency requirements or high execution volume, replacing the cloud executor with a locally-served model cuts costs dramatically. Morph’s benchmark showed cloud-only approaches consuming ~150,000 tokens for a multi-file refactor; the planner-executor pattern with local execution uses ~10,000 Claude tokens — a 93% reduction — because only the plan and final diff touch the cloud API.

Which Local Models Work as Executors

The minimum viable executor for multi-file work with tool use is around 14B parameters. Smaller models handle autocomplete but don’t follow complex instructions reliably enough across file boundaries:

Serve the local model via Ollama (simplest for solo developers) or vLLM (better throughput for teams). Both expose an OpenAI-compatible API at localhost, and Claude Code’s MCP integration lets the Opus planner hand tasks off to the local endpoint over a shared tool protocol.

The Latency Tradeoff

This approach is 2–3× slower than cloud-only because of round-trip overhead plus local inference time. It’s the right call for batch jobs, overnight refactors, and documentation generation — not for interactive development where you’re waiting on results. If your loop is interactive, stick with the cloud executor and accept the cost.

Step 4: Configure a Fallback Chain

Production pipelines need fallback behavior. Opus 5.5 hits quota limits at exactly the wrong moment; your executor model may be slower than expected on a large context. Claude Code’s fallback chain handles this cleanly:

{
  "model": "opusplan",
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

The fallback chain tries models in order until one accepts the request, then reverts to the primary model on the next turn. Cap it at three entries — the runtime drops any beyond that, and a long chain obscures which model actually ran your turn, which makes cost attribution and debugging harder.

For organization deployments, add an allowlist in your admin settings to prevent developers from accidentally routing to models outside your approved cost tier or data boundary:

{
  "availableModels": ["opus", "sonnet", "haiku"],
  "enforceAvailableModels": true
}

When Not to Use This Pattern

Multi-model pipelines add orchestration complexity that has real costs. Before building one, rule out the cases where it makes things worse.

Tight context dependency: If each step depends heavily on the full context of the previous step, splitting across models increases the risk of the executor missing intent captured in the plan. A single model with good context management is more reliable here.

Interactive latency budgets: The local-executor variant adds 30–60 second round-trips. If a developer is watching the terminal, that’s intolerable. Cloud-only planner-executor is faster but still 15–30% slower than single-model because of phase transitions.

Small task volume: The setup overhead — CLAUDE.md contracts, output schemas, fallback chains, monitoring — pays off when you’re running dozens of builds per day. For occasional one-off tasks, a single call to Opus is both cheaper and faster when you account for setup time.

Novel or ambiguous problems: The planner-executor split assumes the plan is good enough for a cheaper model to execute without judgment. When the problem is poorly understood and requirements will shift mid-task, you want one strong model staying in context throughout.

What to Measure

If you roll this out to a team, track these metrics from day one — otherwise you won’t know whether the savings are real or whether failed retries are eating the gains:

• First-pass acceptance rate per model configuration (target: within 5 percentage points of your all-frontier baseline)
• Cost per accepted change (tokens billed, not tokens used — cache hits don’t appear in usage logs the same way)
• Retry and escalation rate from executor to planner (above 1.5 average retries signals your executor is underspecified)
• Human review minutes per change — the number that actually tells you whether the output quality held

The DORA-based diagnostic framework covered earlier this year applies directly here: measure deployment frequency and change failure rate, not just token savings, to catch the cases where cheaper execution introduces regressions that cost more to fix than the tokens you saved.

For model evaluation methodology — particularly if you’re considering swapping your planner to a non-Anthropic frontier model — the model evaluation guide published in August covers the task-stratified benchmark approach in detail.

The Direction This Is Heading

The Terminal-Bench 2.1 spread between the top six models is only 2.6 percentage points. That gap will tighten further as mid-tier and open-weight models continue to close on frontier scores — DeepSeek V4.1 Flash already leads the public board at open-weight cost. The natural endpoint is pipelines where model selection is fully dynamic: tasks are profiled, routed, and repriced at runtime based on complexity signals, not set statically in a config file.

That infrastructure doesn’t widely exist yet. For now, the opusplan pattern with a Haiku executor is the fastest path from zero to a working multi-model pipeline that actually reduces your bill. Start there, measure it honestly, and add local execution only once you’ve confirmed the acceptance rate holds.

Further Reading

• Kilo AI Terminal-Bench Leaderboard — live Terminal-Bench 2.1 scores across the public leaderboard, updated as new model results come in
• Morph: Multi-Agent Model Routing — the benchmark data behind the planner-executor cost math, including token distribution and acceptance rate methodology
• Claude Code Model Configuration Docs — official reference for opusplan, fallback chains, effort levels, and organization-level model controls