Claude Code /advisor Deep Dive: The Strategic Brain of Agentic Coding

TL;DR: The /advisor command (released April 9, 2026) is Claude Code /advisor Recipes: 5 Use Cases with Real Output (May 2026)">Claude Code /advisor vs claude-code-router: Which Routing Strategy Wins (May 2026)">Claude Code's new strategic brain. It allows a low-cost "Executor" (Sonnet/Haiku) to call a high-intelligence "Advisor" (Opus) for high-level planning. It slashes costs by up to 80% while keeping "Opus-level" quality for complex agentic tasks. Here is the deep dive.

Feature	Executor Model (Sonnet/Haiku)	Advisor Model (Opus 4.7)
Role	Does the grunt work (editing, running tests)	Provides the high-level plan & course correction
Inference Cost	$3.00 / $15.00 (Sonnet 3.7)	$5.00 / $25.00 (Opus 4.7)
Context Usage	Full conversation (1M tokens)	Full conversation (Plan only output)
Best For	Speed and volume	Rigor and complex reasoning

What is the Claude Code /advisor Command?

Released into public beta on April 9, 2026, /advisor is a multi-model orchestration strategy built directly into the Claude Code CLI and desktop apps. It solves the "Economic Dilemma of AI Agents": Using Opus for every single turn is too expensive, but using Sonnet for complex planning often leads to "looping" or logic errors.

With /advisor, Claude Code splits the personality: the Executor handles the terminal, file system, and syntax, while the Advisor (Opus) acts as the Senior Architect overseeing the "mission."

How It Works: The "Server Tool Use" Loop

The mechanism is elegant. When you enable advisor mode, the Executor doesn't just "guess" the next move. When it hits a strategic milestone or a roadblock, it triggers a special server_tool_use block.

1. The Trigger: The Executor (Sonnet) realizes the task requires high-level reasoning.
2. The Handoff: Anthropic's backend sends the entire transcript to Opus (The Advisor).
3. The Strategy: Opus generates a concise "course correction" or "master plan" (usually 400-700 tokens).
4. The Execution: This plan is injected back into Sonnet as an advisor_tool_result.

# Enable advisor mode in Claude Code CLI
claude-code --advisor=opus-4-7

# Or use it inline for a specific complex task
/advisor "Help me architect a migration from Redux to Zustand in this monorepo"

The Economics: Why This is a Game Changer

Building agents in 2026 is a game of token management. A typical refactor might take 50 turns. At 100k context, an all-Opus session would cost ~$15-$20. By using the Advisor strategy, where Opus only speaks for 5% of the total output tokens, that same session drops to ~$4-$6.

The "Near-Solo" Benchmark: Anthropic's data shows that Sonnet + Advisor Opus achieves ~94% of the performance of Opus Solo, but at the cost-profile of Sonnet.

Advanced Use Cases

1. Handling "Looping" in Large Refactors

We've all seen AI agents get stuck in a "trying-to-fix-linting-error" loop. The Advisor recognizes the pattern and tells the Executor: "Stop trying to fix the semicolon; the underlying issue is the type definition in /types/global.d.ts. Go there first."

2. Architecture-Aware Coding

When working in a 500k token monorepo, Sonnet often loses the "big picture." The Advisor maintains the high-level map, ensuring that code added to /apps/web follows the design tokens defined in /packages/ui.

3. Self-Healing Pipelines

When combined with the new Routines feature, /advisor can run autonomous tasks (like upgrading React versions) overnight. If the build fails, the Advisor analyzes the error log and provides the fix strategy, while Sonnet executes the hundreds of file edits required.

// Example of an Advisor-informed planning block in a Routine
const routine = await claude.routines.create({
  name: "Dependency Upgrade",
  strategy: "advisor-led", // Uses Opus for planning
  executor: "claude-3-7-sonnet",
  on_failure: "retry-with-advisor-plan"
});

The Controversy: "Hidden Latency" and Hidden Costs

Is it perfect? No. Here is the catch you won't see in the marketing slides:

• Dual Inference Latency: Because you are waiting for an Opus inference pass during a Sonnet session, turns can feel sluggish. A typical Advisor turn adds 8-12 seconds of "thinking" time.
• Context Doubling: Every time the Advisor is called, you are billed for the full context window again on the Opus side. If your context is 200k tokens, calling /advisor 10 times adds 2 million Opus input tokens to your bill. If used poorly, it Builders Can Actually Use in 2026 (No Allowlist Required)">can actually be more expensive than just staying in Sonnet.

Should You Use It?

✅ Use /advisor if:

• You are doing "Long Horizon" tasks (tasks taking >15 minutes).
• You are working in a complex, unfamiliar codebase.
• You are doing structural refactoring (moving folders, changing state managers).
• You are seeing Sonnet get "confused" or repetitive.

❌ Stick to standard mode if:

• You are doing "Grepping" or simple bug fixes.
• You are writing unit tests for a single file.
• You need instant, low-latency responses for "vibe coding."

How to Get Started

Update your Claude Code CLI to version 2.4.0+ and ensure your API key has access to the advisor-2026-04-09 beta flag.

# Update Claude Code
npm install -g @anthropic-ai/claude-code@latest

# Run with Advisor
claude-code --advisor