Claude Code has a native /advisor [model|off] command. The main model does the work and calls a stronger advisor model at decision points. The docs say it "tends to consult before committing to an approach, when an error keeps recurring, and before declaring a task done, but the timing is model-driven rather than rule-based." The advisor has no tools, so it can't spawn or direct other agents.
That leaves a gap. If the job has to be split (collect sources, fact-check them, write, judge the draft), the advisor can't split it. The other option is Fable 5.2 as main model, delegating work down to cheaper models.
This skill decides between the two and sets the rules for the second.
What it does:
1. Picks a mode. Mode A (native /advisor): one cheaper agent can do the whole task and only the decisions need a stronger model. Mode B (Fable as main): the work has to be split across models.
2. Assigns tiers in Mode B. Fable plans, makes the calls and writes the final copy. Haiku collects sources and does read-only lookups. Sonnet fact-checks each claim against its saved source. A cheap model that did not write the draft cold-reads it.
3. Sets the handoff rules. Every subagent writes its full result to a file with no length limit. The message it returns to the orchestrator is 200 words or fewer and names the file. The cap is on the return message only, not the file and not the final copy.
4. Holds collector output until a checker passes it. Verdicts are PASS, FIX, UNSUPPORTED, NO SOURCE. (The skill check in the table below used a different set: DRIFT, INVENTED, MISSING.) The orchestrator keeps one run-log row per subagent: job, model, tokens, verdict, file.
5. Uses fresh agents for cheap jobs. A forked subagent inherits the parent model and ignores the model override.
It doesn't decide whether to delegate. That's my earlier skill, subagent-dispatch-economics (post: https://www.reddit.com/r/PromptEngineering/s/ivuwzVYwad). This one starts after that decision.
Why the checker tier is there: in an earlier session a Sonnet checker found a "quote" a Haiku collector had saved that wasn't on the page. On 16 Nov I ran the pattern itself, with Fable 5.2 as main model and /advisor off:
| job | model | tokens | verdict |
|---|
| read-only lookup of my tool's database | Haiku | 91,409 | rows found; no token/cost data recorded |
| fact-check of the generated skill (first generation, before the fixes below) | Sonnet | 78,437 | 28 claims: 8 PASS, 4 DRIFT, 11 INVENTED, 5 MISSING |
| fact-check of Fable's own LinkedIn drafts | Sonnet | 89,861 | 56 rows: 37 PASS, 5 FIX, 10 UNSUPPORTED, 4 NO SOURCE |
| cold-read judge of those drafts | Haiku | 79,634 | 7 drafts scored 2-4 of 5; 2 AI tells |
That's 339,341 subagent tokens in total. All four returned 200 words or fewer and wrote a file. Fable's own token count isn't visible from inside the session. The checker flagged 19 lines in the top model's drafts, so the top model needs checking too.
About the cost claim you may have seen: Anthropic's April blog post reports Sonnet with an Opus advisor at +2.7 points on SWE-bench Multilingual and 11.9% lower cost per task. Those were older models (Opus 4.6 as advisor), not Fable 5.2. The current platform docs only say "Opus keeps total cost similar or lower; Claude Fable 5.2 maximizes the quality lift." I couldn't find a Fable advisor number from Anthropic, so the skill doesn't use one.
How it was made, and what it taught me about my own tool: I generated it with the Context Engineering pipeline in my tool, from a goal plus a one-page reference file of verified facts. Then I ran an evaluation: 4 skills x (with reference / goal only) x 2 runs, 16 generations on production.
- With a reference file: 8 of 8 usable. 74 of 80 required rules came through, and every limit kept its qualifier.
- From a goal only: 0 of 8 worth using. Each was well-formed but hollow, and each carried my platform's own security boilerplate ("sanitize external inputs", "least privilege") even for skills with no tools or inputs.
The two evaluation rounds led to three fixes, now live:
- A prompt bug that deleted the steps from skills (15 of 16 lost them in the first round).
- The boilerplate no longer appears for goals that don't mention access, input, auth or data (a keyword check).
- A goal with no reference now warns you it will be a scaffold before you spend credits.
The advisor file below started as the reference run's output. I rebuilt it by hand from the reference file:
- Removed one invented line (a garbled version of the benchmark caveat plus the boilerplate).
- Put back the companion-skill pointer, which the generator dropped in both runs.
- Added the Mode A limits, the fork rule, the checker gate, and the Never and Requirements sections.
- Rewrote the description.
What I checked and didn't: a fresh Sonnet agent followed the skill on four tasks with pass conditions fixed beforehand: a variable rename, a fact-checked blog post from 6 sources, a flaky test, and 40 tickets summarized for a CEO. It picked the expected path all four times. It also listed six unclear spots, and I fixed three. That run came before my last wording edits and I didn't repeat it. This is a smoke test on four prompts, not an evaluation. I haven't measured whether Mode B is cheaper or better than one Fable agent doing everything.
The Skill Definition (skill.md):
---
name: "advisor"
description: "Decides which Claude model tier does which job when Fable 5.2 is available, and sets the handoff rules between them. Use when a task could run under native /advisor or with Fable as main model delegating to cheaper models. Not for deciding whether to delegate at all (see subagent-dispatch-economics)."
---
# advisor
Chooses between native /advisor (a cheaper model works, Fable 5.2 advises) and Fable 5.2 as main model delegating down to cheaper models, then assigns each job to a tier and enforces the handoff rules.
## Instructions
### Steps
1. **Confirm delegation is decided.** Whether to delegate, and fork vs. fresh agent, belongs to `subagent-dispatch-economics`. This skill starts after that decision. Do not restate it. If the answer is "don't delegate", stop here and do the task in the main session.
2. **Choose the mode.**
- **Mode A, native `/advisor`:** one cheaper main model can do the whole task and only the decisions need a stronger model. The advisor has no tools and cannot delegate or orchestrate. Its call timing is model-driven; there is no setting to cap or force calls, so ask in your instructions if you want more or fewer.
- **Mode B, Fable 5.2 as main:** the work must be split across models. Fable plans, judges and writes the final copy. It delegates lower-level jobs to fresh subagents with a per-spawn model override.
3. **In Mode B, assign tiers:**
| Job | Model |
|---|---|
| Plan, make the calls, write the final copy | Fable 5.2 (main) |
| Collect sources, read-only lookups | Haiku |
| Fact-check each claim against its saved source (web page, file or input record) | Sonnet |
| Cold-read judge of the final draft (no project context) | Haiku or another cheap model, a fresh agent: never the writer, never the agent that collected |
4. **Spawn cheap jobs as fresh agents.** A forked subagent inherits the parent model and ignores the model override.
5. **Apply the handoff rules** (below) to every subagent.
6. **Gate on the checker.** Collector output is not trusted until a checker tier that did not produce it passes it. The orchestrator's own drafts go through the checker too.
7. **Keep the run log.** One row per subagent: job, model, tokens (as the harness reports them; write "not available" if it doesn't), verdict, output file.
### Handoff Rules
- Every subagent writes its full result to a file. The file has no length limit.
- The message a subagent returns to the orchestrator is 200 words or fewer and names the file.
- The 200-word cap applies only to that return message, not to the result file and not to the orchestrator's final copy.
- Checker verdicts: PASS, FIX, UNSUPPORTED, NO SOURCE.
### Never
- Present the Sonnet + Opus advisor benchmark (+2.7 points, 11.9% lower cost, Anthropic blog, April 2026, older models) as a Fable 5.2 result.
- Let the writer judge its own draft.
- Use a forked subagent for a job meant for a cheaper model.
### Requirements
- Native /advisor is experimental and requires the Anthropic API, Claude Platform on AWS, or Claude Models on Google Cloud (Anthropic managed). Fable 5.2 requires Claude Code v2.1.321 or later. On some plans Fable usage, including as advisor, bills to usage credits.
Which describes you best? A) I run one model for everything. B) I use /advisor already. C) I hand jobs to cheaper subagents by hand. D) I have a checker step that isn't the writer.
Has a cheap checker ever caught something your top model got wrong?
Repo: https://github.com/nivlewd1/prompt-optimizer/tree/main/skill/advisor
I built a platform that generates skills like this from a goal and a reference file: promptoptimizer.xyz/about/context-engineer (signup required, free tier).