Fable 5 as advisor: near-frontier judgment at Sonnet 5 and Haiku prices

Anthropic's advisor tool pairs a fast, cheap executor model with a stronger advisor model that gets consulted mid-generation. The executor calls advisor() like any other tool, the server runs a separate inference pass on the advisor with the executor's full transcript as context — and the advice comes back inline, one request, no extra round trip on your side. You get most of the quality of running the advisor model solo, at close to the executor's token rate, because the advisor only ever writes a plan (typically 400–1,800 tokens), not your full output.

The pairing rules matter here: the advisor must be at least as capable as the executor, and Fable 5 is on the valid advisor list for both Sonnet 5 and Haiku 4.5 executors. Mythos 5, by contrast, can currently only advise itself. That makes Fable-as-advisor a genuinely available pattern for the two most common agent tiers, not a hypothetical.

The two configs that matter

• Haiku 4.5 executor + Fable 5 advisor. You're already on the cheapest tier and want a real step up in judgment on harder turns. Expect higher cost than Haiku alone, but well under running Fable 5 as the executor.
• Sonnet 5 executor + Fable 5 advisor. You're on Sonnet for complex work already; the advisor adds a quality lift at similar-or-lower total cost, because Fable only writes the plan. Sonnet still generates the bulk of the output at its own rate. Pair it with a medium effort setting on the executor for intelligence comparable to Sonnet at default effort, for less.

Both are a poor fit for single-turn Q&A. There's nothing to plan. Same goes for workloads where every turn genuinely needs frontier-level output: at that point you're not saving anything by routing through a cheaper executor.

Wiring it up

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

One thing that trips people up: Fable 5 and Mythos 5 return advisor_redacted_result, not advisor_result. Where an Opus advisor hands back a readable text field, Fable's advice arrives as an opaque encrypted_content blob. The server decrypts it into the executor's prompt on the next turn, but you can't read it client-side. Round-trip it verbatim in your message history regardless, and if your code branches on advisor output shape (say you support swapping advisor models), switch on content.type, not on parsing text.

Making Haiku actually call it

Left to the built-in guidance, Haiku executors under-call the advisor on coding and write-heavy tasks. The default nudging keeps Haiku's call rate appropriately low on lookup work, but it leaves quality on the table where an early consult would have paid for itself. Anthropic's tested fix is a stricter system-prompt block with a hard rule: the first write_file, edit_file, or state-changing command on a task must be preceded by an advisor call. Read-only orientation (ls, grep, find) doesn't count. That single checkpoint measurably raised Haiku pass rates on coding workloads, but it also cost accuracy on browse/lookup-heavy workloads. Don't apply it blindly if your Haiku executor's traffic is mixed.

A lighter-touch option is the turn-2 nudge: a plain reminder message injected if the executor hasn't called the advisor by its second turn. It's aggressive, up to 98% of nudged Haiku attempts call immediately, so time it against your executor's actual baseline first-call turn, not a guess. Nudge too early and you get a low-context, badly-timed consult.

Keeping Fable's cost in check

The advisor runs as a billed-separately sub-inference at its own model's rate, and your executor's top-level max_tokens does not bound it. An uncapped advisor call on a hard reasoning task can run 4,000–6,000 tokens. Set max_tokens on the tool definition itself:

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

2048 is the tested sweet spot: roughly a 7x reduction in mean advisor output versus leaving it unset, with near-zero truncation. The floor is 1024, which cuts further but starts truncating ~10% of calls. Layer a soft ask on top if you want brevity without a hard cutoff mid-thought: a line in the user message addressed directly to the advisor ("Advisor: keep your guidance under 80 words") works more reliably than describing the limit in the system prompt.

If your conversations run three or more advisor calls, turn on caching in the tool definition. The advisor's own transcript is a stable, growing prefix, so caching it the same way you'd cache the executor's prompt pays for itself past that point. Below three calls, the cache write costs more than it saves.

Where this fits

The advisor tool is a routing decision, the same kind of call as picking Sonnet over Haiku in the first place. A two-tier setup (Haiku executor with Fable 5 advisor for the bulk of traffic, escalating to Sonnet 5 with the same Fable 5 advisor for anything that needs it) gets you Fable-class judgment at both tiers without ever paying Fable's own $10/$50 per-million rate for full generation. Cap the advisor's output, watch the redacted-result shape, and measure before you tune the call rate.