How to Use Claude’s Advisor Tool: Fable 5 as Consultant, Opus 4.8 as Executor

Claude announced that the Fable 5 model, originally scheduled to be retired on the 7th, is now extended to December 12, which appears to be a move to counter GPT‑5.6. After the 12th, Fable 5 will only be available via paid API.

A team that ran Fable 5 for 24 hours through the API incurred a $113,421.87 bill, illustrating the potential cost explosion.

Claude’s official benchmark on the SWE‑bench Pro subset shows that using Sonnet 5 for the whole task costs about $0.75 per question with ~75% accuracy, while using Fable 5 costs $2.20 per question with ~91% accuracy, highlighting the classic cheap‑but‑less‑smart vs. expensive‑but‑smart dilemma.

A later ClaudeDevs tweet added a third point: using Sonnet 5 as the executor and Fable 5 as the advisor costs $1.40 per question with ~84% accuracy, because most tokens are billed at the lower executor rate.

The advisor tool works by declaring two models in a single request: the top‑level model field holds the cheap executor, and the tools array contains an advisor entry whose model is the expensive consultant. Example JSON:

{
  "type": "advisor_20260301",
  "name": "advisor",
  "model": "claude-fable-5",
  "max_tokens": 2048
}

During execution, the executor runs until it decides it needs higher‑level guidance, then the server forwards the entire conversation history (system prompt, tool definitions, prior turns, and the current partial output) to the advisor model. The advisor returns a suggestion text, which the executor receives and continues processing.

The advisor’s input is always empty; the server handles context transfer, so the client does not need to implement cross‑model stitching. All of this happens inside a single /v1/messages request.

Full Python example using the Anthropic SDK:

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

The author likens this to a primary physician consulting a specialist: the specialist sees the full record, gives directional advice, and the primary doctor continues writing.

When Fable 5 acts as the advisor, its response is returned as an encrypted block ( advisor_redacted_result) that the client cannot see; Opus returns plaintext.

Pairing rules are strict: the advisor must be at least as strong as the executor, with a minimum of Sonnet 4.6. Allowed pairs include Haiku 4.5 with any Sonnet 4.6+ model, Sonnet 5 with Opus 4.7/4.8 or Fable 5, and Fable 5 only with itself. Mismatched pairs return HTTP 400.

Pricing: Fable 5 costs $50 per million tokens, Sonnet 5 $15 (discounted to $10 until the end of August). The advisor typically emits 400–700 tokens of suggestion plus 1,400–1,800 tokens of internal thinking, so its cost per consultation is modest.

Claude recommends asking the advisor two or three times per coding task: once for direction before starting, and once for a final check after the work is done. The documentation advises persisting intermediate results before the final check because advisor calls add latency and may be interrupted.

Cost breakdown appears in the usage.iterations array: advisor_message entries are billed at the advisor rate, while regular message entries use the executor rate, enabling precise per‑consultation accounting.

Each advisor call re‑reads the full conversation, billed at $10 per million tokens for Fable 5. A caching switch can store the conversation on the advisor side; the official guidance says the switch breaks even after three queries in a single dialogue. Use caching for long agent loops, but disable it for short tasks.

An alternative pattern is to use Fable 5 as an orchestrator that plans work and delegates to many Sonnet 5 workers. On the BrowseComp benchmark, the Fable‑orchestrated + Sonnet workers combo achieved 86.8% accuracy at $18.53 per question, compared with 77.8%/ $16.01 for all‑Sonnet and 90.8%/ $40.56 for all‑Fable, yielding 96% of the performance at 46% of the cost.

Both the advisor and orchestrator patterns are supported by Claude Managed Agents’ sub‑agents, each maintaining its own cache to avoid paying full price for repeated context.

Claude Code integrates the advisor tool starting with version 2.1.98. Users can invoke it with the /advisor command or set advisorModel in settings.json, effectively reproducing the Sonnet‑executor + Fable‑advisor workflow.

The advisor differs from the earlier OpusPlan approach, which swapped models only between distinct phases. Advisor allows mid‑execution help with full history, something sub‑agents cannot replicate because they only receive the initial task description.

Many developers already perform a manual version of this by copying context from a cheap model (e.g., DeepSeek or GLM) to a stronger model (GPT‑5.5 or Opus 4.8) and pasting the answer back. The official advisor tool automates this hand‑off within a single API call, eliminating context‑mismatch issues.

After Fable 5 leaves the subscription tier on the 12th, paying for occasional advisor calls with Fable 5 can be a practical fallback when Opus 4.8 or GPT‑5.6 cannot solve a problem.