Claude's New Multi-Agent Patterns: Advisor and Orchestrator Modes Cut Costs by 10x

Two Patterns, Dramatically Different Costs

Anthropic engineers recently shared detailed cost breakdowns of two multi-agent patterns they use internally: the Advisor pattern and the Orchestrator pattern. The data reveals that choosing the right pattern can reduce token costs by 10x or more for complex coding tasks — a finding with massive implications for teams running AI agents at scale.

Both patterns use Claude models (Opus 4.7, Sonnet 4.6, or Fable 5) in different configurations. The difference isn't which model you use — it's how you structure the interaction between multiple model instances to solve complex problems.

The Advisor Pattern: Expert Consultation Without Full Context

In the Advisor pattern, a lightweight "router" agent (typically Claude Sonnet 4.6 at $3/$15 per million tokens) handles the main conversation. When it encounters a problem requiring deeper expertise — complex algorithm design, security review, architectural decisions — it consults a specialist "advisor" agent (Claude Opus 4.7 at $5/$25 or Fable 5 at $10/$50).

The critical cost optimization: the advisor receives only a compressed summary of the context, not the full conversation history. A typical coding session might accumulate 50,000+ tokens of context. The advisor sees only a 2,000-5,000 token distillation of the relevant problem.

Cost example — refactoring a 500-line module:

The Advisor pattern achieves 3.5-4.5x cost reduction while maintaining quality for the decisions that matter most. The router handles routine file edits and navigation; the advisor provides strategic guidance only when needed.

The Orchestrator Pattern: Parallel Execution with Cheap Workers

The Orchestrator pattern takes a different approach: a planning agent (Opus 4.7 or Fable 5) breaks a large task into independent subtasks, then dispatches them to multiple cheap worker agents (Sonnet 4.6 or even Haiku at $0.25/$1.25) running in parallel.

This pattern shines for tasks with natural parallelism: migrating multiple files, writing tests across a module, updating API endpoints, or applying a consistent refactoring pattern across a codebase.

Cost example — adding tests to 20 API endpoints:

The cheapest orchestrator configuration achieves 11x cost reduction versus a single premium agent — while also completing 5-7x faster due to parallelism. The tradeoff: individual worker quality is lower, so the planner must produce very specific, unambiguous task descriptions.

When to Use Each Pattern

Use Advisor when: The task requires deep reasoning at specific decision points but is otherwise routine. Examples: code review with architectural feedback, debugging complex race conditions, designing a database schema while implementing CRUD operations.

Use Orchestrator when: The task has natural parallelism and individual subtasks are well-defined. Examples: bulk migrations, test generation, documentation updates, applying consistent style changes across files.

Avoid both (use single agent) when: The task is deeply sequential with each step depending on the previous result, or when total token usage would be under 10K tokens anyway — the overhead of multi-agent coordination isn't worth it for small tasks.

Implementation Cost: Building the Patterns

The patterns themselves require engineering investment. Anthropic's data suggests 2-4 days of development to implement a robust Advisor pattern with proper context compression, and 3-5 days for an Orchestrator with parallel dispatch, error handling, and result aggregation.

For teams processing 100+ agent tasks/day, the ROI is immediate. At 50 tasks/day using Opus 4.7 directly ($0.78/task = $39/day), switching to the Advisor pattern ($0.22/task = $11/day) saves $840/month. The Orchestrator pattern for parallelizable work saves even more.

Tools like Claude Code's built-in sub-agent spawning already implement a lightweight version of the Orchestrator pattern. The forthcoming Claude Agent SDK will make both patterns available as first-class primitives, eliminating most of the implementation overhead.

Monthly Budget Impact for a 10-Developer Team

Consider a team where each developer triggers ~20 complex agent tasks per day:

Naive single-agent (Opus 4.7): 10 devs x 20 tasks x $0.78 x 22 workdays = $3,432/month

Advisor pattern (mixed): 10 devs x 20 tasks x $0.22 x 22 workdays = $968/month

Hybrid (Advisor + Orchestrator for batch work): ~$600-750/month

That's a reduction from $3,432 to under $750 — a 78% cost cut without downgrading model quality for the decisions that matter. The key insight: most tokens in a coding session are context (reading files, conversation history), not reasoning. Multi-agent patterns attack the context cost, not the intelligence cost.

The Bottom Line

Anthropic's internal data confirms what many teams are discovering: the era of "throw everything at the biggest model" is over. Strategic model routing — using cheap models for routine work and expensive models only for critical decisions — is now the primary lever for controlling AI coding costs. The Advisor and Orchestrator patterns formalize this into repeatable architectures that any team can implement.