Claude Code already lets you pick cheaper models. Most people never change it.

Keep Claude for Judgement. Let Cheaper Models Do the Busywork.

A two-minute change: keep the strong model for judgement, and let the repetitive work run on a cheaper one — without leaving Claude Code or writing a line of glue code.

X·Trillion Engineering
4 June 2026 · 4 min read

Most people install Claude Code, pick a model once, and never touch the setting again. Everything then runs on that one model — the careful architectural decisions and the mechanical busywork alike, all billed at the same rate.

That is convenient, and for a lot of work it is fine. But a coding session is mostly mechanical: searching the codebase, reading files, applying an agreed change, fixing a typo and re-running a check. Only a handful of moments genuinely need the strongest model.

You can keep those moments on the top tier and push the rest down a tier — and the controls to do it are already in front of you.

The main model: /model

The fastest lever is the model your main session runs on. Type /model for an interactive picker, or set it directly:

/model sonnet      # Switch the main session to Sonnet
/model opus        # Move back to Opus for heavy reasoning

You can name a model alias — opus, sonnet, haiku or fable — which always resolves to the current version available to your account. Alternatively, use a full model ID such as claude-sonnet-4-6 if you want to pin an exact version.

The same value can be set without opening Claude Code at all:

# A single session
export ANTHROPIC_MODEL="claude-sonnet-4-6"

Or set a durable default in settings.json:

{
  "model": "sonnet"
}

That alone is useful. But switching the whole session is a blunt instrument: you lose the strong model exactly when you need it.

The sharper tool is to split the work.

The real lever: subagents on a cheaper model

Claude Code can delegate parts of a task to subagents — focused helpers with their own prompt, tools and, crucially, model.

A subagent is simply a Markdown file inside .claude/agents/. The model is specified in one line of front matter:

<!-- .claude/agents/formatter.md -->

---
name: formatter
description: "Formats and lints changed files. Use after edits."
model: haiku
tools: Read, Edit, Bash
---

You format and lint code. Apply the project's style. Do not change
behaviour. Report what you changed in one line.

The formatting work now runs on Haiku while your main session remains on Opus or Sonnet.

The model field accepts the same aliases and full model IDs as /model, plus one special value: inherit. This simply uses whichever model the main conversation is running. If you omit the field, inherit is the default.

You may already be doing this

Claude Code ships with a built-in Explore subagent that runs on Haiku by default.

Every time Claude searches your codebase, that work may already be happening on the cheaper tier. The bulky search output also stays outside your main context window, potentially saving tokens twice over.

Splitting work by model is not exotic. It is how the tool already behaves.

Turn the whole fleet down at once

To make every subagent run cheaply for a session — regardless of what each agent file says — use a single override:

export CLAUDE_CODE_SUBAGENT_MODEL="haiku"

This sends all subagent work to Haiku.

Set it back to inherit to restore the normal per-agent model resolution:

export CLAUDE_CODE_SUBAGENT_MODEL="inherit"

This is useful during a large mechanical sweep, when you want the main thread to orchestrate while the workers stay cheap.

Do not just force everything onto Haiku

The point is not that cheaper is always better.

A weaker model in the wrong place can produce confident but incorrect work that costs more to unpick than it saved. The effective pattern keeps judgement where judgement is needed:

• Main session on a strong model: plans the work, decides what to delegate and reviews what comes back.
• Subagents on a cheaper model: handle bounded, testable and reversible tasks such as searching, formatting, applying an agreed edit and running checks.

Because the strong main thread decides when to delegate, the intelligence remains where it earns its price while the volume runs cheaply.

That is the whole idea:

Match each unit of work to the cheapest model that can perform it reliably — not to the cheapest model you can find.

You can go a long way using the built-in controls alone.

The next two articles push the idea further. Part 2 examines why this saves so much — it is as much about context as model pricing. Part 3 shows how to route work to a non-Claude model entirely, with a cheap open-model worker handling the iteration and Claude reviewing the result.