Claude Code’s Multi-Model Division of Labor: Sonnet Writes Code, Haiku Searches Files, Opus Only Makes the Call

Claude Code can run three models at the same time.

Anthropic shared a usage pattern: the main session runs Sonnet 5.5, file exploration is handed to Haiku 5.5, and Opus 5.5 only steps in as an advisor at key moments. The command is very short:

claude --model sonnet --advisor opus

The division of labor is:

Sonnet 5.5 runs the session and writes code
Haiku 5.5 explores files and documentation in parallel
Opus 5.5 stands by as an advisor and is consulted only for key judgments
Day-to-day turns no longer consume Opus

Opus steps in at three moments:

Before the plan is locked
When the same error appears twice
Before declaring the task complete

In one sentence: Sonnet builds, Haiku explores, Opus reviews.

The original post expands the structure into a tree:

Sonnet 5.5 runs the main session and edits code
search maps the repository on Haiku 5.5
grep finds call sites on Haiku 5.5
docs pulls the API reference on Haiku 5.5
Opus 5.5 stands by as an advisor and reads the full conversation record when consulted
JEV handles micro-branches with millisecond-level routing

In the source material, JEV is a lower-level fast-routing layer: forks that do not need a thinker—such as which file to choose, which tool to use, whether to retry or stop—are handed to JEV for millisecond-level processing. Only forks that require a large model to make a judgment go up a level.

There is a key insight here: the point of a multi-model setup is to split work by judgment density. Saving on Opus costs is just a result. Many setups only swap models without changing the workflow, so the expensive layer is still present every turn. A commenter summed it up even more directly in a reply: “build the harness first, model tuning comes last.”

The original post provides a prompt that can be pasted directly into Claude Code:

Rebuild my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. No edits until I say go.

The last point is worth keeping: look at the diff first, then say go. Treat configuration changes the same way as code changes.

The original post includes a workflow demo:

Original post link: https://x.com/N01ennn/status/2116455210587709511

advisor documentation: https://code.claude.com/docs/en/advisor