Source: Commit d9b875d (easy-learn-ai, 2026-04-10)
Imagine you run a consulting firm.
You have two kinds of employees: recent graduates earning 5,000 a month who can handle large volumes of basic work — research, document organization, first drafts, routine processes — and senior industry consultants earning 50,000 a month who specialize in complex problems: strategic judgment, key decisions, client negotiations.
The smart approach is not to give all the work to consultants, but to let the juniors handle 80% of routine tasks and bring in consultants only for the hard problems.
That's Management 101. But in AI, until recently, this common sense had not actually been implemented.
From "One Model Does Everything" to "Division of Labor"
In April 2026, this pattern got a name: the Advisor Pattern.
Anthropic rolled out a beta feature on the Claude platform: use Sonnet or Haiku for execution, and consult Opus at critical decision points. Officially published numbers: on SWE-bench Multilingual, a 2.7 percentage-point improvement over Sonnet alone, with costs down about 12%.
LangChain quickly shipped an open-source middleware implementation. Community benchmarks were even more dramatic: a Haiku+Opus combo on browsing tasks doubled scores while cutting costs; Sonnet+Opus raised SWE-bench scores while saving money.
Qwen Code v0.14.x productized this pattern: explicit configuration of "main model + lightweight model" division of labor, with flexible routing across different models via OpenRouter, OpenSpec, and similar tools.
This isn't one company's clever trick. The entire industry is converging on this consensus.
Why Now?
The pattern has a simple economic driver:
Model capabilities are tiered, but prices are tiered far more steeply.
- Claude Haiku: cheap, fast, good enough for 80% of scenarios
- Claude Sonnet: mid-priced, strong general capability
- Claude Opus: expensive, slow, but the most reliable for hard problems
- GPT-5.5: twice the price of 5.4, but noticeably better code quality
- Confidence thresholds: the model scores its certainty; below the threshold, it escalates
- Classifier routing: a small classifier first judges the task type, then picks the model
- Feedback loops: evaluate the small model's decision quality afterward and continuously tune its escalation strategy
- Akshay's summary of the Advisor Pattern: https://substack.com/redirect/f2e9e328-077e-404c-b508-da55b2854c54
- LangChain DeepAgents Advisor middleware: https://substack.com/redirect/8dd7407b-1f1c-4a9d-920a-dd8edc053af2
- Anthropic Advisor strategy notes: https://substack.com/redirect/cabf8ccb-d0e4-4d42-9a31-66bffd28470f
- Qwen Code multi-model orchestration: https://substack.com/redirect/6c6b069a-4f0d-4c46-985e-e1970a93198d
When a "good enough" cheap model can handle most tasks and only 10% of steps truly need an expensive model, "use the expensive model for everything" becomes waste — like sending a chief architect to fix a printer.
A deeper reason: agent task complexity is rising.
Early AI applications were single-turn — ask a question, get an answer. Today's agents run dozens of steps, call multiple tools, and process long contexts. If every step uses the most expensive model, the bill spirals out of control.
What Does the "Advisor" Actually Do?
Suppose you ask an agent to: "Analyze this financial report, identify risk points, and give investment advice."
Traditional approach: one Opus model handles everything end to end — reading documents, analyzing data, writing the report. Every step uses the most expensive model, because "what if this step needs deep reasoning?"
Advisor approach: 1. Haiku reads the documents and extracts key figures and sections (no world-class reasoning needed here) 2. When a judgment like "does this accounting policy change constitute a material risk?" arises, Haiku packages the question and sends it to Opus 3. After Opus gives its judgment, Haiku continues execution — formatting, generating charts, drafting emails 4. A final logic check of the whole report calls Opus again
Result: Haiku does 90% of the work; Opus intervenes at only 2–3 critical decision points. Total cost may be about 1/5 of the original, with quality nearly unchanged.
An Interesting Philosophical Question
This pattern raises a deeper question: how does a small model know "I can't handle this"?
If a small model can't correctly assess task difficulty, it may stay silent when it should ask for help, or bother the advisor unnecessarily often — both of which destroy efficiency.
Current solutions include:
These mechanisms themselves are evolving fast. Anthropic's Advisor tool and LangChain's DeepAgents middleware are, at heart, both solving the meta-problem of "when to ask for help."
Practical Impact for Developers
If you're a developer using AI to write code, what does this trend mean?
First, your "model stack" will become as important as your "tech stack." The question is no longer "GPT or Claude?" but "which model version do I use in which scenario, combined via what routing strategy?"
Second, cost optimization has a new dimension. Cost optimization used to mean "reduce tokens" or "use a cheaper API." Now you can optimize through "intelligent routing" — let cheap models do the heavy lifting, and deploy expensive models only where they matter most.
Third, evaluation gets more complex. In the single-model era, benchmarking one model was enough. In the multi-model era, what you benchmark is the "combination strategy" — which task-allocation ratio yields the lowest total cost at acceptable quality.
This Is Not the End Point
The Advisor Pattern is just one stage in agent architecture evolution.
A more distant future may involve models learning "self-routing" — instead of an external system deciding whether to escalate, the model itself decides internally whether a question needs deep thinking or a quick answer. Muse Spark's "compressed thinking" has already demonstrated the embryo of this capability.
Or the boundaries between models may blur further. As open-source models become "good enough" and local deployment costs keep falling, the distinction between "expensive" and "cheap" models may no longer rest on parameter count, but on deployment location (cloud vs. local), response speed (real-time vs. asynchronous), or degree of specialization (general vs. vertical).
Back to the Consulting Firm
Remember the consulting firm analogy at the start?
The AI industry is waking up from the illusion that "everyone is a full-stack consultant" and accepting a more pragmatic reality: division of labor beats going solo.
Cheap models are not "inferior goods" — they are the optimal solution for specific scenarios. Expensive models are not a "cure-all" — they are insurance for critical decisions.
When the whole industry starts designing AI systems with a "team" rather than "individual" mindset, true large-scale application is only just beginning.
---
Further reading