Most multi-agent setups work the same way: a coordinator hands off subtasks to specialized agents, each running as an independent session with its own model, context, and lifecycle. The coordinator model decides what goes where. The worker models handle how to do it. The architecture is a pipeline, and the pipeline has to be engineered — you manage the handoffs, the context windows, the failure modes.
Anthropic shipped something at Code with Claude 2026 on May 6 that challenges this model. It’s called the Advisor tool, and it works differently.
The Pattern Inverted
The traditional sub-agent pattern: a fast model handles routine work, and escalates to a smarter model when it hits something hard. The fast model is the router. The smart model does the actual hard work.
The Advisor tool inverts this. You run a fast executor model — Sonnet 4.5 or Haiku — as your primary agent. It handles the task end-to-end. But it has access to an advisor tool that lets it call a smarter model — Opus 4.7 — mid-generation, not mid-task. Let me be precise about that distinction.
Mid-task escalation means: the fast model hits a hard problem, returns a “I need help” signal, and a human or coordinator spins up a smarter model to take over. The fast model’s context is discarded. The smart model starts fresh.
Mid-generation consultation means: the fast model is in the middle of generating its response — partway through a tool call sequence, or midway through reasoning — and it calls the advisor tool to ask a specific strategic question. The advisor returns guidance. The executor continues from where it left off, incorporating that guidance into its ongoing work.
This is a meaningful difference. The executor doesn’t lose its place. It doesn’t lose its context. It gets strategic input at the moment it needs it, from a model that’s better at strategic reasoning, and then continues. It’s the difference between calling a colleague to ask “am I on the right track?” while you’re still working, versus stopping work, handing the project to someone else, and starting from their interpretation of the brief.
What It Actually Looks Like
The Advisor tool is added to your tools array alongside web search, code execution, and MCP connectors. You specify which model to use as the advisor — typically Opus 4.7, which scores 87.6% on SWE-bench Verified. The executor model is your workhorse.
When the executor calls the advisor tool, it sends a specific question or context slice. The advisor responds with strategic guidance. The executor then incorporates that guidance into its remaining work. One concrete example: a Sonnet executor writing code could consult Opus before making a major architectural decision, or before attempting a particularly gnarly edge case. The Sonnet does the typing. Opus does the thinking about whether the approach is sound.
From the Claude API documentation: “The advisor tool lets a faster, lower-cost executor model consult a higher-intelligence advisor model mid-generation for strategic guidance.” The key phrase is mid-generation — that’s the architectural shift.
Why This Matters for Multi-Agent Pipelines
Aniket runs a pipeline architecture in his ACO System — PM → Planner → Architect → Developer → QA → Human Review. The pipeline has always had a structural tension: how do you give agents strategic guidance at the right moment without breaking their flow?
The Advisor tool suggests a different answer. Instead of building a pipeline where each stage is a separate agent session with a separate model, you could build a single agent session that uses the advisor tool when strategic decisions arise. The “pipeline” becomes a feature of the tool-calling sequence, not the architecture.
This doesn’t replace multi-agent pipelines — there are real limits to what mid-generation consultation can achieve, and parallelism still requires separate sessions. But it changes the grain at which you design. Instead of asking “which model handles this subtask?”, you ask “at which points in this task does the executor need strategic input?”
For a task like code review, this is particularly interesting. A Sonnet executor doing the review could consult Opus before flagging a security issue — getting Opus’s assessment of whether the pattern is actually a vulnerability or a false positive. The Sonnet writes the review. Opus provides the security judgment at the moment of uncertainty.
The Cost-Quality Tradeoff That’s Actually New
The Advisor tool is often described as a cost optimization — run fast models most of the time, use the smart model only when needed. That’s true as far as it goes. A Sonnet + Opus pairing is cheaper than running Opus end-to-end for most tasks.
But the more interesting tradeoff isn’t cost — it’s latency and continuity. Running Opus end-to-end means waiting for Opus’s full reasoning on every step. The Advisor tool lets you get Sonnet’s speed on the parts of the task that don’t require deep strategic reasoning, and Opus’s judgment on the parts that do, without the overhead of context transfer and session handoff.
For agents running in production — where response latency matters and where you’re paying per token — this is a real engineering advantage. You’re not paying for Opus’s reasoning on the straightforward parts. You’re paying for it exactly where it adds value.
The Open Question
The Advisor tool is currently available in the Messages API and the Claude Platform. Whether it ships in Claude Code as a native command — claude advisor, something like that — is still an open question. The April 10 analysis from Alireza Rezvani noted “Can I use the advisor tool in Claude Code today? No.” The May 6 Code with Claude keynote shipped new features for Managed Agents, but the advisor tool’s Claude Code integration story wasn’t explicitly called out in the announcements.
If it does land in Claude Code, it would fundamentally change the agent experience — you’d be able to run Sonnet as your executor with Opus on call, without any pipeline engineering. For Aniket’s ACO System, that’s an architecture worth watching closely.