Fable 5 Advisor and Orchestrator Patterns: 92% Quality at 63% Cost (July 2026)

On July 8, 2026, @ClaudeDevs published a thread on two production patterns for using Fable 5 without paying Fable prices on every token — the same day Anthropic extended included Fable through Sunday July 12 and expanded Claude for Open Source.

Hands-on setup: Fable 5 advisor + Sonnet 5 executor in Claude Code — /advisor fable, prompt templates, and game-dev workflow.

The patterns are not new abstractions — they map directly to shipping API primitives: the advisor tool for inline strategic consults, and Claude Managed Agents with dynamic workflows for plan-big / execute-small orchestration.

TL;DR — advisor vs orchestrator

Benchmark figures are from @ClaudeDevs July 8 tweets — Anthropic internal evals, not independent reproduction. Validate on your workload.

Pattern 1 — Fable 5 as advisor, Sonnet 5 as executor

@ClaudeDevs frames this as the default mental model for coding agents:

Use Fable 5 as an "advisor." An executor (Sonnet 5) calls Fable 5 for guidance. Most tokens are billed at the lower executor rate.

On SWE-bench Pro, Anthropic reports Sonnet 5 + Fable 5 advisor tool reaches ~92% of Fable 5's score at ~63% of the price. Fable is called rarely — about once per task — to steer while Sonnet executes the majority of tool calls and output generation.

Why this works economically

The advisor tool docs explain the billing split:

• Executor tokens bill at the executor model rate (Sonnet 5).
• Advisor sub-inference bills at the advisor model rate (Fable 5) inside usage.iterations[] as type: "advisor_message".
• Top-level usage.input_tokens / output_tokens reflect executor only — advisor tokens are separate because rates differ.

Advisor output is typically 400–700 text tokens (or 1,400–1,800 including thinking on harder tasks). The savings come from Fable not generating your full patch series, test logs, and file edits — Sonnet does that at Sonnet rates.

Minimal API setup

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-5",  # executor
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-fable-5",  # advisor
            "max_uses": 3,  # per-request cap; optional
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Refactor the payments module to use dependency injection.",
        }
    ],
)

When the executor invokes advisor:

1. Executor emits server_tool_use with empty input — timing only; server supplies context.
2. Anthropic runs a separate inference on Fable with the full transcript (your system prompt, tools, prior turns, in-progress output).
3. Fable's response returns as advisor_tool_result — for Fable advisors, advisor_redacted_result with encrypted_content you must round-trip verbatim on subsequent turns.
4. Executor continues generating, informed by the advice.

All inside one /v1/messages request (unless pause_turn — see docs for resume flow).

Model pairs that include Fable 5

Per the compatibility table, valid executor → advisor pairs include:

Invalid pairs return 400 invalid_request_error. The advisor must be at least as capable as the executor.

When advisor is a strong fit

Anthropic's docs align with the tweet:

• Long-horizon agentic workloads — coding agents, computer use, multi-step research pipelines.
• Tasks where most turns are mechanical but plan quality is crucial.
• Teams currently running Sonnet on complex tasks who want a quality lift without switching every turn to Fable.

Weaker fit: single-turn Q&A, workloads where every turn genuinely needs frontier reasoning, or pass-through model pickers where users already chose their cost/quality tradeoff.

Pattern 2 — Fable 5 as orchestrator, Sonnet 5 as workers

The second @ClaudeDevs pattern inverts the role split:

Use Fable 5 as an orchestrator. Fable 5 plans and delegates to workers (Sonnet 5). Most tokens are billed at the lower worker rate.

On BrowseComp, Anthropic tested Claude Managed Agents with a Fable 5 orchestrator and Sonnet 5 worker sub-agents:

• ~96% of Fable 5 solo performance
• ~46% of the price
• Token-heavy research delegated to Sonnet 5

Implementation reference: Anthropic's CMA plan-big / execute-small cookbook — pairs with the Code with Claude Tokyo CMA launch (scheduled deployments, vaults, dynamic workflows GA).

Advisor vs orchestrator — architectural difference

Think of advisor as "ask the principal engineer before you commit to the approach" inside a single Claude Code session. Think of orchestrator as "principal writes the work breakdown; juniors run the searches" across managed sub-agents.

Prompting and cost controls (from platform docs)

Anthropic ships extensive advisor guidance beyond the tweet. Highlights for production:

Call timing on coding tasks

Docs recommend:

• Early first advisor call — after a few exploratory reads, before substantive writes.
• Final advisor call — after file writes and test output exist, before declaring done.
• Hard rule variant (Haiku coding): first write_file / edit_file / state-changing bash must be preceded by an advisor call.

If your agent exposes planner tools (todo lists), prompt the executor to call advisor before those tools so Fable's plan funnels into structured steps.

Capping advisor output

Set max_tokens on the tool definition (minimum 1024). Anthropic's internal table on a hard reasoning benchmark:

Soft alternative: prefix user messages with (Advisor: please keep your guidance under 80 words...).

Haiku nudge for under-calling

If a Haiku executor skips the advisor on turn 1, append a short reminder user message before turn 2 — Anthropic reports ~7 percentage point pass-rate lift on Haiku in behavioral eval. Do not nudge Opus executors (slightly lowered pass rates in their testing). Sonnet showed no measurable nudge effect.

Advisor-side prompt caching

Enable caching: {"type": "ephemeral", "ttl": "5m"} on the tool definition when you expect 3+ advisor calls per conversation — prefix is stable across calls. Break-even at roughly three calls.

Pairing with effort

For coding: Sonnet executor at medium effort + Fable advisor ≈ Sonnet at default effort intelligence at lower cost per docs. Keep executor at default effort when you need maximum intelligence.

Response structure you'll see in logs

Successful advisor invocation in assistant content:

{
  "type": "server_tool_use",
  "id": "srvtoolu_abc123",
  "name": "advisor",
  "input": {}
}

Followed by:

{
  "type": "advisor_tool_result",
  "tool_use_id": "srvtoolu_abc123",
  "content": {
    "type": "advisor_redacted_result",
    "encrypted_content": "..."
  }
}

Error codes inside advisor_tool_result_error: max_uses_exceeded, too_many_requests, overloaded, prompt_too_long, execution_time_exceeded, unavailable. The request does not fail — executor continues without advice.

Streaming: advisor sub-inference does not stream. Executor stream pauses at server_tool_use close; full advisor_tool_result arrives in one content_block_start.

How this fits explainx.ai's agent stack

These patterns are harness engineering decisions — which model runs which phase of a loop:

1. Route bulk generation to Sonnet (or Haiku for triage).
2. Reserve Fable for plan checkpoints — advisor calls or orchestrator planning.
3. Measure on your eval suite — SWE-bench Pro and BrowseComp are Anthropic benchmarks; your repo's flake rate, test style, and search depth may differ.

With Fable credits starting July 13 for included-plan users, the advisor pattern is the obvious cost lever for teams that were running Fable solo on every Claude Code loop.

Decision matrix — which pattern when?

Honest limits

1. Benchmarks are Anthropic-reported — SWE-bench Pro and BrowseComp numbers come from @ClaudeDevs tweets, not third-party replication on explainx.ai.
2. Advisor is beta — API surface, availability, and ZDR eligibility may change; Bedrock/GCP/Foundry not supported yet.
3. Fable advice is encrypted — advisor_redacted_result means you cannot inspect advice in logs without executor-side effects; debug via executor behavior, not advisor plaintext.
4. Orchestrator adds orchestration complexity — sub-agent failures, vault secrets, and CMA scheduling are operational overhead the advisor pattern avoids.
5. Once-per-task is a target, not a guarantee — without max_uses and system-prompt steering, executors may over- or under-call the advisor.

Related on explainx.ai

• Fable 5 extended through July 12 — billing context for when these patterns matter most
• 35 Fable use cases for restore week — workloads to test advisor vs solo
• Claude Code loops official guide — where advisor calls fit in /goal loops
• Claude Managed Agents — Tokyo launch — orchestrator infrastructure
• Agent harness engineering — model routing as harness design
• What is loop engineering? — plan-verify-revise with mixed models
• GPT-5.6 Sol in Claude Code — swap executor to Sol while advisor stays Fable

Official sources

• @ClaudeDevs — Fable 5 patterns thread (July 8, 2026)
• Advisor tool — Claude Platform Docs
• CMA plan-big / execute-small cookbook

Benchmark percentages, API availability, and model IDs follow Anthropic's July 8, 2026 @ClaudeDevs posts and advisor tool documentation. Re-run cost math on your token logs — executor and advisor bill at different rates in usage.iterations.