Advisor and Orchestrator Patterns:
Multi-Agent Cost Optimization for Autonomous Agents

The Cost Problem in Autonomous Multi-Agent Systems

Autonomous agent systems like the ones Clawgency implements for OpenClaw deployments rarely consist of a single model call. A customer-service agent, for example, looks something up in the CRM, searches a knowledge base, drafts a reply, and logs the interaction – four to ten model calls for a single task is nothing unusual. If every one of those calls runs through the most capable model available, the bill scales linearly with volume, regardless of whether that particular subtask actually needs that level of capability.

On pure model pricing: Anthropic's currently published API prices (as of July 15, 2026, platform.claude.com/docs/en/about-claude/pricing) show a price ratio of roughly 5:1 to 10:1 between the flagship model Fable 5 ($10 input / $50 output per million tokens) and a faster model like Sonnet 5 ($2 input / $10 output, pricing through August 31, 2026). That gap multiplies across every agent step, every session, every month.

The Advisor Pattern: Expensive Model Only at Decision Points

In April 2026, Anthropic introduced its own advisor tool in the blog post "The advisor strategy": a faster, cheaper model handles the entire workflow. A more capable model is only consulted as an "advisor" at select, critical decision points – not on every step. In Anthropic's own benchmark, this combination improved results on SWE-bench Multilingual by 2.7 percentage points over using the expensive model alone, at 11.9% lower cost per task.

Technically, the advisor tool is implemented as a standalone tool-call pattern: the cheaper model can invoke the advisor tool mid-workflow whenever it hits a point where it's uncertain or needs a higher-quality judgment call. The rest of the session keeps running on the cheaper model unchanged.

A note of caution on numbers circulating online: for newer model pairings (Sonnet 5 as the working model, Fable 5 as advisor), higher figures are sometimes quoted, such as "92% of Fable 5's performance at 63% of the cost" on a benchmark referred to as "SWE-bench Pro". We couldn't trace that figure to any official Anthropic source, so we're not reporting it as an established fact – only the 2.7 percentage points and 11.9% cited above, which trace directly back to Anthropic's own announcement.

The Orchestrator Pattern: Plan Expensive, Execute Cheap

A second, even better-documented pattern comes from the official Claude Cookbooks repository (github.com/anthropics/claude-cookbooks, notebook managed_agents/CMA_plan_big_execute_small.ipynb): the expensive flagship model handles planning only – it breaks a task down into subtasks. Several instances of a cheaper model then work through those subtasks in parallel as workers.

That's a different kind of "parallel" than the one in our article on Git Worktrees and parallel AI agents: there, several agents split independent development tasks across multiple worktrees – throughput through task parallelization. Here, several instances of the same cheap model work in parallel on subtasks of a single task planned by the expensive model – cost optimization through role separation, not more tasks completed at once.

On the BrowseComp benchmark, this setup reached 86.8% accuracy at $18.53 per task, versus 90.8% accuracy at $40.56 when the flagship model solves the entire task alone – roughly 96% of the original performance at about 46% of the cost. These figures can be traced directly to the cookbook, not just paraphrased.

An additional, mechanically traceable cost lever: each sub-agent runs its own prompt cache. Repeated context (system prompt, shared reference data) isn't billed again at full price for every worker as a result.

What's Verified, and What Isn't

A quick summary of which figures in this article trace back to a primary source – and which don't:

How This Transfers to OpenClaw Agents

OpenClaw agents, as Clawgency implements them for DACH businesses, consist of configurable roles each with its own model backend. The advisor/orchestrator principle transfers directly:

• For customer-service agents: standard requests (FAQ answers, status lookups) run on a fast, cheap model. Escalations, ambiguous requests, or cases with high business risk get handed off to a more capable model as an advisor – directly analogous to Anthropic's pattern.
• For document processing and batch tasks: a planning step (which documents, what order, which exceptions) runs on a more capable model, while the actual extraction/classification runs in parallel across several cheaper worker instances – a direct orchestrator pattern.
• Cost transparency as a prerequisite: without logging per agent role and model combination, any optimization is guesswork. That's why we build it into every OpenClaw implementation by default.

# Illustrative OpenClaw agent role configuration (example syntax, not a reference implementation)

role: customer-service-standard
model: fast-cheap
escalation:
  condition: ambiguous_request OR high_risk
  model: high-capability        # advisor pattern

role: document-review-planning
model: high-capability          # plans, doesn't execute itself
workers:
  count: 5
  model: fast-cheap              # orchestrator pattern

A Worked Example: Verifying 20 Facts

From the Claude Cookbooks example, directly transferable to many OpenClaw use cases (research, data reconciliation, document review): the task of verifying 20 facts cost $1.61 and took 194 seconds in the orchestrator setup. The same task, solved by the flagship model alone, cost $4.00 and took 608 seconds – not just 2.5 times more expensive, but roughly 3 times slower as well. Over 80% of the tokens consumed in the orchestrator setup ran on the cheaper worker rate.

Where This Approach Hits Its Limits

• Not every task splits cleanly. Some agent tasks are demanding end-to-end and can't be broken into "simple" and "critical" subtasks without risking quality.
• Splitting the work is architecture, not a config toggle. The workflow has to be structured from the start so roles and subtasks can actually be separated.
• Caching must be checked explicitly – see the "Orchestrator pattern" section above.
• Treat the 92/63 figure with caution. Plan around the verified magnitudes (advisor: roughly 12% savings; orchestrator: sometimes over 50% on parallelizable tasks), not the largest numbers circulating.

FAQ: Multi-Agent Cost Optimization with Advisor and Orchestrator Patterns