Fable 5 Advisor and Orchestrator Patterns: 92% Quality at 63% Cost (July 2026)
ClaudeDevs July 8, 2026 — Sonnet 5 executor + Fable 5 advisor hits ~92% of Fable solo on SWE-bench Pro at ~63% price. Fable orchestrator + Sonnet workers reaches 96% on BrowseComp at 46% cost. Advisor tool docs explained.
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.
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.
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.
Executor emits server_tool_use with empty input — timing only; server supplies context.
Anthropic runs a separate inference on Fable with the full transcript (your system prompt, tools, prior turns, in-progress output).
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.
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:
Executor
Advisor options (subset)
Sonnet 5
Fable 5, Mythos 5, Opus 4.6–4.8
Sonnet 4.6
Fable 5, Mythos 5, Opus 4.6–4.8
Haiku 4.5
Fable 5, Mythos 5, Opus 4.6–4.8
Invalid pairs return 400 invalid_request_error. The advisor must be at least as capable as the executor.
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:
Advisor vs orchestrator — architectural difference
Dimension
Advisor pattern
Orchestrator pattern
Fable's job
Mid-task course correction inside one agent loop
Task decomposition + sub-agent dispatch
Sonnet's job
Primary tool loop + code generation
Parallel workers on scoped subtasks
Best for
SWE-bench-style coding (one repo, one agent)
BrowseComp-style research (many searches, parallel paths)
Composition
advisor_20260301 in tools[]
CMA dynamic workflows + sub-agents
Call frequency
~1 advisor call per task (Anthropic tweet)
Fable plans once; many Sonnet worker turns
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:
max_tokens on advisor
Mean advisor output
Truncation rate
unset
~4,200–5,900
n/a
2048 (recommended start)
~630–840
~0%
1024
~370–480
~10%
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:
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.
Sonnet alone — advisor adds latency without payoff
Every turn needs frontier reasoning
Fable solo — patterns optimize cost, not max intelligence
Haiku triage + occasional hard tasks
Haiku executor + Fable advisor + nudge on turn 2
Honest limits
Benchmarks are Anthropic-reported — SWE-bench Pro and BrowseComp numbers come from @ClaudeDevs tweets, not third-party replication on explainx.ai.
Advisor is beta — API surface, availability, and ZDR eligibility may change; Bedrock/GCP/Foundry not supported yet.
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.
Orchestrator adds orchestration complexity — sub-agent failures, vault secrets, and CMA scheduling are operational overhead the advisor pattern avoids.
Once-per-task is a target, not a guarantee — without max_uses and system-prompt steering, executors may over- or under-call the advisor.
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.
