Claude's Advisor Strategy: Small Models Execute, Large Models Supervise — A New Cost-Saving Paradigm for AI Agents

Stop Blindly Picking the Most Powerful Model

In the AI Agent era, many people have an incredibly simple model selection strategy — just throw the most powerful model at everything. Using Codex? Pick GPT-5.5. Using Claude Code? Go with Opus. But in a blog post published on April 9th, Anthropic introduced a completely new Agent operating paradigm called the Advisor Strategy, which fundamentally overturns this approach: spend less money and actually get better results.

This isn't just a cost-saving trick — it's a deep rethinking of how AI Agents should be organized, with tremendous reference value for both enterprise AI deployment and individual developers.

What Is the Advisor Strategy?

Core Idea: Small Models Execute, Large Models Advise

The traditional Agent operating paradigm is "strongest model leads" — let the smartest model (like Opus) handle overall planning, Sonnet handles subtasks, and Haiku handles simple execution. The underlying assumption of this approach is: the main loop must be driven by the most powerful model.

Here it's important to understand Claude's model family tier design: Opus is the flagship reasoning model, excelling at complex analysis and multi-step reasoning, but with the highest API costs and longest response latency; Sonnet strikes a balance between performance and cost, suitable for most everyday tasks; Haiku is known for extremely low latency and cost, ideal for lightweight tasks. This tiered architecture itself hints at the possibility of multi-model collaboration — different model tiers serving different roles at different stages, rather than a one-size-fits-all approach.

Claude's Advisor Strategy flips this entirely:

• Executor (Main Loop): Handled by Sonnet or Haiku, responsible for end-to-end task execution — calling tools, reading results, iterative reasoning
• Advisor: Handled by Opus, consulted only when the executor encounters critical decisions it cannot understand or resolve, returning plan corrections or stop signals

The Agent's main loop refers to the core execution flow where the Agent continuously runs: receive task → think about next action → call tools (such as code executor, file read/write, API calls, etc.) → observe tool results → think again → continue acting, cycling until the task is complete. This loop might execute dozens or even hundreds of iterations, each consuming model reasoning tokens. Therefore, the model used in the main loop directly determines overall cost — if Opus runs the main loop, every iteration's reasoning cost is high; using Sonnet or Haiku instead can reduce per-iteration costs by several times or even tenfold, with cumulative savings being substantial.

Opus doesn't directly call tools or produce output for users. Its role is more like an external expert consultant — it doesn't do the work itself, only providing direction, course corrections, and stop recommendations at critical junctures.

The Numbers Speak: 12% Cost Reduction with Better Results

The blog post provides specific comparison data:

Approach	SWE-Bench Score	Cost
Sonnet 4.6 / Haiku executing alone	72.1	$1.09
Sonnet 4.6 executing + Opus advisor	74.8	$0.96

Costs dropped by approximately 12%, while SWE-Bench scores actually improved by 2.7 percentage points.

It's worth explaining the significance of the SWE-Bench benchmark. SWE-Bench was released in 2023 by a Princeton University research team, specifically designed to evaluate large language models' ability to solve real-world GitHub Issues. It extracts hundreds of real bug fix and feature request tasks from 12 popular Python open-source projects including Django, Flask, and scikit-learn, requiring models to autonomously generate code patches after understanding problem descriptions. Because tasks come from real software engineering scenarios, SWE-Bench is widely regarded as the gold standard for measuring AI coding Agent capabilities. A score above 72 means the model can independently solve over 70% of real software engineering problems, and on this highly challenging benchmark, a 2.7 percentage point improvement is quite significant.

Spending less money to achieve better results — that's the power of the Advisor Strategy.

Why Is the Advisor Strategy So Inspiring?

From "Smartest Leads" to "Most Stable Leads"

The significance of this strategy goes far beyond saving money. It provides an entirely new Agent operating paradigm:

• Old paradigm: Whoever is smarter takes the lead (strongest model = commander-in-chief)
• New paradigm: Whoever is cheap, stable, and can run the process takes the lead (execution model = main loop)

Think about it — this is remarkably similar to real business environments. Regular employees handle day-to-day work, and when they encounter major decisions they're unsure about, they bring in external experts for a look. The expert doesn't do the work themselves — they only provide direction, corrections, and recommendations to stop. This is essentially a mentor-like role.

It's worth noting that multi-Agent collaboration is not a concept originated by Anthropic. As early as 2023, Stanford University's "Generative Agents" paper demonstrated the possibility of multiple AI roles collaborating on complex tasks. Since then, open-source projects like Microsoft's AutoGen framework, CrewAI, and LangGraph have explored various multi-Agent orchestration patterns, including hierarchical, peer-to-peer, and pipeline approaches. The unique aspect of the Advisor Strategy is its introduction of an "asymmetric collaboration" pattern — the advisor model doesn't participate in the execution flow, only intervening when explicitly consulted. This dramatically reduces inter-model communication overhead while preserving high-quality decision-making capability. This design philosophy shares remarkable similarities with the "Sidecar Pattern" in microservices architecture.

AI Competition Enters the "Intelligent Organization" Phase

From the release of the Advisor Strategy, we can see that AI industry competition is shifting from model capability competition to competition in intelligent organization methods. It's no longer purely about whose model scores highest on benchmarks, but about who can achieve equal or better results at lower cost.

This means a critical direction will emerge: intelligent compute budget allocation. AI cost governance isn't about using less AI, nor is it about lavishly using the most expensive model for everything — it's about establishing a tiered invocation mechanism.

In fact, this direction is rapidly gaining momentum across the industry. Vendors like OpenAI, Google, and Anthropic are all advancing Model Routing technology — automatically dispatching requests to the most appropriate model based on task complexity, risk level, and cost budget. Some third-party platforms like Martian and Unify already specialize in intelligent routing services. Gartner predicts that by 2026, over 60% of enterprise AI deployments will adopt multi-model hybrid architectures rather than relying on a single model. The Advisor Strategy can be seen as a concrete implementation of this trend in the Agent domain.

Practical Guide: How to Choose Model Strategies for Four Key Scenarios

The Advisor Strategy and the traditional "strongest model leads" strategy aren't mutually exclusive — they apply to different scenarios. Here are strategy recommendations for four typical scenarios.

Scenario 1: Direction Unclear → Strong Model Leads

If what you're doing has unclear direction and involves many strategic decisions, such as:

• Enterprise AI transformation direction decisions
• Product strategy formulation
• Video topic selection

For these "can't see the direction clearly" tasks, it's better to use the strong model as the lead, because what's needed is high-quality judgment.

Scenario 2: Direction Clear but Process is Long → Execution Model + Strong Model Advisor

If the direction is already clear but the execution process is long, such as:

• Writing distribution copy for various platforms
• Running test cases in batch
• Generating first drafts of presentations

These tasks can perfectly well let Sonnet or Haiku run continuously, bringing in Opus to correct course only when hitting blockers. This is the ideal application scenario for the Advisor Strategy.

Take Codex as an example — this is OpenAI's cloud-based AI coding Agent product launched in 2025, positioned as a "digital software engineer." Unlike traditional code completion tools, Codex can autonomously complete entire programming tasks in independent cloud sandbox environments: reading codebases, understanding requirements, writing code, running tests, and submitting PRs. Each Codex task instance is essentially a running Agent main loop, with a single task potentially involving hundreds of tool calls and reasoning iterations. In these long-running scenarios, model selection's impact on cost is amplified many times over, and the Advisor Strategy's value is fully demonstrated.

Scenario 3: Simple Task but High-Risk Results → Regular Model Executes + Strong Model Reviews

Some tasks aren't complex themselves, but the results carry high risk — you must bear responsibility for the final output:

• Quotes and proposals for clients
• Wording of important emails
• Officially published documents

Here, let the regular model execute, while the strong model's role isn't to advise but to review and gatekeep. Once it goes out, it's final — AI doesn't bear responsibility for the results, but humans do.

Scenario 4: Error-Prone but High Error Tolerance → Multiple Models in Parallel

If a task is prone to errors but errors are acceptable, such as:

• Generating concept images
• Writing prompt documents
• Producing multiple headlines for A/B testing

In this case, let multiple models run simultaneously. The models don't need an advisor role between them — they just need a reviewer at the end to score the results. The scoring system can be self-evaluation, peer evaluation, or even multi-expert panel evaluation.

Deeper Insight: Agent Systems Are Like Organizations

The philosophy behind the Advisor Strategy essentially reveals a trend: future AI Agent systems will resemble organizations rather than monolithic brains.

An efficient organization doesn't have the most expensive or smartest person do everything. But an organization also can't function without experts and elites. A mature Agent system should:

• Let regular executors continuously push forward routine tasks
• Let experts appear only at the most critical, most valuable, and most error-prone junctures

This philosophy applies not only to Claude's multi-model switching but can also be reused in:

• Codex digital worker scheduling — using lightweight models for the main loop during long autonomous coding tasks, calling the flagship model for key architectural decisions
• Claude Code multi-Agent collaboration — multiple Agent instances processing different modules in parallel, sharing a senior advisor for global consistency review
• Multi-model workflow architecture design — borrowing from the Sidecar Pattern and Gateway Pattern in microservices to build flexible model routing layers
• Enterprise AI deployment methodology — incorporating intelligent compute budget allocation into IT governance frameworks, establishing tiered approval and cost monitoring mechanisms for model invocations

Conclusion

Claude's Advisor Strategy may appear to be just a small model scheduling trick, but it actually marks a paradigm shift in the AI Agent field from "competing on model capability" to "competing on intelligent organization methods." In today's world of increasingly constrained compute resources, whoever can achieve better results at lower cost will hold the advantage in the Agent era.

For every AI practitioner, you can start building such a tiered scheduling system right now — no need to wait for automation tools to arrive. Once you understand the core philosophy of the Advisor Strategy, manual configuration can deliver immediate results.