Here is the pattern in one sentence: run your agent on a cheap, fast model, and let it phone a smart, expensive model for the plan — inside a single API call, paying frontier rates only for the plan.

That is Anthropic's advisor tool (beta, type: advisor_20260301). It splits an agentic task the way a good team does: a junior engineer does most of the typing, and asks the staff engineer for direction at the hard forks. The junior is billed at junior rates; the staff engineer is billed only for the minutes they spend advising. For a founder watching an agent's token bill climb, that split is the whole point — and it is one of the cleaner ways to reduce agent token costs that doesn't mean downgrading the model doing your actual work.

The 30-second version#

import anthropic
client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-5",                 # executor: cheap, does the work
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-fable-5",       # advisor: strong, plans the work
        }
    ],
    messages=[{
        "role": "user",
        "content": "Build a concurrent worker pool in Go with graceful shutdown.",
    }],
)

That is the entire integration. The executor decides when to consult the advisor, the same way it decides when to call any tool.

How it actually works#

When the executor wants advice, it emits a server_tool_use block named advisor with an empty input — it only signals timing. Anthropic then runs a separate inference pass on the advisor model, feeding it the full transcript (your system prompt, the tool definitions, every prior turn and result, and what the executor has produced so far). The advisor runs under its own system prompt, without tools, and its thinking is dropped — only the advice text comes back, as an advisor_tool_result block. The executor reads it and continues.

{
  "type": "advisor_tool_result",
  "tool_use_id": "srvtoolu_abc123",
  "content": {
    "type": "advisor_result",
    "text": "Use a channel-based coordination pattern. The tricky part is draining
             in-flight work during shutdown: close the input channel first, then
             wait on a WaitGroup..."
  }
}

One wrinkle to code around: the result shape depends on the advisor model. Opus 4.8 returns a plaintext advisor_result with a readable text field. Opus 5, Fable 5, and Mythos 5 return advisor_redacted_result with an opaque encrypted_content blob — the executor reads it server-side, but your client cannot. Either way, round-trip the block verbatim on later turns, and branch on content.type if you might switch advisors.

Where the savings come from (and where the bill hides)#

The advisor's job is to write a plan, not your output. That plan is small — 400 to 700 text tokens, or 1,400 to 1,800 including its own thinking. Your full deliverable is generated by the executor at the executor's rate. That is the arbitrage.

The trap: advisor tokens are billed separately and do not appear in your top-level usage. They live in usage.iterations[], tagged by model:

"usage": {
  "output_tokens": 531,                       // executor totals only
  "iterations": [
    { "type": "message",         "output_tokens": 89 },
    { "type": "advisor_message", "model": "claude-fable-5",
      "input_tokens": 823, "output_tokens": 1612 },   // billed at Fable 5 rates
    { "type": "message",         "output_tokens": 442 }
  ]
}

If you build cost tracking off the top-level totals, you will silently undercount every advisor call. Sum usage.iterations instead, and price advisor_message iterations at the advisor model's rate, message iterations at the executor's.

Three ways to keep the advisor cheap#

The advisor's output length is the main cost driver, and your top-level max_tokens does not bound it. Reach for these in order:

  1. max_uses — a hard cap on advisor calls per request. Past it, calls return max_uses_exceeded and the executor proceeds without more advice.
  2. max_tokens on the tool (minimum 1024) — caps advisor output per call. Anthropic's recommended starting point is 2048, which cut mean advisor output roughly 7× in their tests with near-zero truncation.
  3. caching — set {"type": "ephemeral", "ttl": "5m"} on the tool to cache the advisor's growing transcript across calls. It breaks even at about three advisor calls per conversation, so enable it for long agent loops and leave it off for short tasks.
tools=[{
    "type": "advisor_20260301", "name": "advisor", "model": "claude-fable-5",
    "max_uses": 4,
    "max_tokens": 2048,
    "caching": {"type": "ephemeral", "ttl": "5m"},
}]

For conversation-level budgets there is no built-in cap — count calls client-side, and when you hit your ceiling, remove the advisor tool from tools and strip the advisor_tool_result blocks from history (leaving them without the tool present returns a 400).

This is not a model router#

It's easy to file the advisor tool next to a cost-capping model router, but they solve different problems. A router picks one model for the whole request. The advisor blends two models within one request, along the planning-vs-execution seam. A router asks "which model should handle this task?" The advisor asks "which model should make the decisions, and which should do the typing?"

That is also why "just use the big model" isn't the same trade. Running Fable 5 end to end pays frontier rates for every token of a long agentic run, most of which is mechanical. The advisor pays those rates only for the handful of tokens where judgment matters.

When it fits — and when it doesn't#

Anthropic frames the two entry points cleanly:

It's a weak fit for single-turn Q&A (nothing to plan), for pass-through routers where users already pick their own cost/quality trade, and for workloads where every turn needs the frontier model's full capability.

One behavioral note worth budgeting for: Haiku under-calls the advisor on coding work. Anthropic's fix is a short "you haven't consulted the advisor yet" nudge injected around turn 2, which raised Haiku pass rates by roughly 7 percentage points in their testing. Don't apply it to Opus executors — there it slightly hurt.

Getting started#

The valid pairs, in short: the advisor must be at least as capable as the executor and at least Sonnet 4.6. Haiku 4.5 and Sonnet 5 executors can take any Opus or Fable/Mythos advisor; an Opus 5 executor is limited to Fable 5, Mythos 5, or Opus 5. Anything invalid returns a 400.

Availability is the one real constraint for now: beta on the Claude API and Claude Platform on AWS only — not Amazon Bedrock, Google Vertex AI, or Microsoft Foundry. If your agents run on one of those, this pattern is on the roadmap, not in your hands yet. If they run on the first-party API, it's a two-line change to your tools array — and the cheapest way to put a frontier brain on a budget model's shoulders.