Negli ultimi giorni sto usando intensamente una delle modalità più interessanti introdotte da Anthropic in Claude Code: un modello veloce ed economico esegue il lavoro, mentre un modello molto più potente interviene solo come advisor nei passaggi complessi.

Questa è la configurazione:

```
{
"model": "sonnet",
"advisorModel": "fable",
"effortLevel": "max"
}
```

In pratica: Sonnet 5 fa tutto il lavoro quotidiano (esplora il repo, modifica i file, esegue i test, corregge gli errori). Quando incontra una decisione architetturale delicata o un problema che richiede più capacità di ragionamento, consulta Fable 5, riceve una strategia e continua da solo l'implementazione.

Sonnet 5 lavora → problema complesso → consulta Fable 5 → riceve la strategia → continua da solo

E il risultato, almeno nella mia esperienza, è impressionante.

Due precisazioni tecniche prima di proseguire: l'Advisor è un tool sperimentale e funziona solo tramite API Anthropic (non è disponibile su Bedrock, Vertex o Foundry). Per usare Fable 5 in Claude Code, come main o come advisor, serve la versione 2.1.170 o successiva. Vale inoltre la regola che l'advisor deve essere almeno capace quanto il modello principale: un main Sonnet 5 accetta come advisor Fable, Opus o un altro Sonnet 5.

Non è un semplice subagent

L'Advisor non è un agente secondario da avviare a mano: è integrato nel workflow. L'executor lo consulta durante il task, riceve la raccomandazione e riprende subito il lavoro. E la cosa interessante è che Sonnet non copia il consiglio: lo integra. Dall'Advisor arrivano diagnosi, strategia, alternative, rischi ed edge case, indicazioni per verificare il risultato — poi è Sonnet a portare avanti l'implementazione.

È come avere uno sviluppatore velocissimo ed economico con un senior architect sempre disponibile, senza pagare il senior per ogni singola operazione.

Perché consuma pochissima quota

Fable non tocca le operazioni meccaniche (cercare file, sistemare CSS, rilanciare lint e test, piccoli fix): quelle le fa tutte Sonnet. Il modello frontier interviene solo dove la sua intelligenza può cambiare davvero il risultato: architettura, planning, debugging difficile, decisioni ad alto rischio, verifica finale.

In più, un buon consiglio iniziale evita implementazioni impostate male, tentativi ripetuti e debugging che non converge. In alcuni task il sistema finisce per essere perfino più efficiente di Sonnet da solo.

Qualche numero. Nel blog ufficiale sull'advisor strategy, Anthropic riporta che Sonnet con Opus come advisor guadagna +2,7 punti percentuali su SWE-bench Multilingual rispetto a Sonnet da solo, riducendo al tempo stesso il costo per task agentico dell'11,9%. Per la coppia con Fable, i benchmark condivisi da ClaudeDevs a inizio luglio parlano di circa il 92% delle prestazioni di Fable usato da solo su SWE-bench Pro, a circa il 63% del costo, con Fable consultato in media una volta per task. Non sono percentuali garantite su ogni repository, ma la differenza qualitativa nella mia esperienza è evidente.

Advisor vs Agent Teams

Anthropic propone anche gli Agent Teams (anche questa una feature sperimentale): un lead agent che coordina più teammate paralleli (frontend, backend, test, documentazione). Approccio potentissimo per task enormi e realmente divisibili — monorepo giganti, migrazioni estese, feature separabili — ma ogni agente mantiene un proprio contesto, rilegge parte del repo, ragiona per conto suo e può duplicare il lavoro degli altri. Il consumo di quota può esplodere.

Per il daily coding, l'Advisor vince nettamente: un solo executor più consultazioni occasionali del modello frontier. Probabilmente il miglior rapporto tra qualità, velocità e consumo.

Cosa succede a Fable dal 20 luglio

Colpo di scena. Dopo tre proroghe consecutive (7 → 12 → 19 luglio), il 17 luglio Anthropic ha finalmente chiarito il futuro di Fable 5. Dal 20 luglio:

• Max e Team Premium: Fable 5 diventa incluso in modo stabile, utilizzabile fino al 50% dei limiti del piano
• Pro e Team Standard: Fable esce dai limiti inclusi e passa agli usage credits, con un credito una tantum di 100 dollari come compensazione. Esaurito quello, si paga a tariffe API ($10/M token input, $50/M output — le più alte del listino Claude)

Attenzione a un dettaglio che in pochi hanno notato: il 19 luglio scade anche il boost del +50% sui rate limit settimanali di Claude Code, quindi i limiti base tornano a scendere per tutti.

In pratica: chi è su Max può continuare a usare Sonnet + Fable Advisor come workflow stabile (Fable consuma quota molto più in fretta, quindi l'Advisor resta il modo più intelligente di usarlo). Chi è su Pro, dopo i 100$ di credito, farà bene a passare a Opus 4.8.

Avvertenza importante: secondo la documentazione ufficiale aggiornata in questi giorni, al momento Claude Code non offre Fable 5 come advisor — nel picker di /advisor appare disattivato come "temporarily unavailable" e i comandi /advisor fable e --advisor fable vengono rifiutati. Fable come modello principale non è toccato. Un rollout remoto deciderà quando tornerà selezionabile come advisor. Io ho fatto in tempo a usarlo, ma se lo provate adesso e non ve lo fa impostare, è per questo.

In attesa che Fable torni disponibile come advisor (o se siete su Pro), si può mantenere lo stesso workflow con Opus 4.8:

```
{
"model": "sonnet",
"advisorModel": "opus",
"effortLevel": "max"
}
```

Opus 4.8 resta un advisor validissimo per progettazione, debugging, sicurezza, database, autenticazione, pagamenti e refactoring complessi. Io userò questa configurazione finché Fable non tornerà selezionabile come advisor, in attesa anche di un eventuale Opus 5 (che al momento non è stato annunciato).

Riprodurre lo stesso sistema in OpenCode

OpenCode non ha ancora un Advisor server-side nativo, ma si può ottenere qualcosa di simile con un subagent dedicato, anche di un altro provider. Per esempio MiniMax M3 come executor e Kimi K3 come advisor.

Basta creare .opencode/agents/advisor.md:

```

---

description: Consult this advisor for architecture, difficult debugging, ambiguous requirements, repeated failures, important trade-offs and final verification of complex tasks.
mode: subagent
model: moonshot/kimi-k3
permission:
edit: deny
bash: deny

---

You are a senior technical advisor supporting another coding agent.

Your role is to provide strategic guidance, not to perform the implementation.

Analyze:

• the user's actual objective;
• the executor's current approach;
• the relevant repository context;
• architectural implications;
• likely failure modes and regressions;
• overlooked constraints and edge cases;
• whether the current strategy should continue or change.

Return:

1. A concise diagnosis
2. The recommended course of action
3. Important risks and edge cases
4. Concrete verification steps
5. A correction of course when necessary

Do not edit files.
Do not produce generic advice.
Do not repeat the entire context.
Prefer the smallest robust and maintainable solution.

The executor will continue the implementation after reading your response.
```

Lo si richiama a mano (@advisor analizza l'approccio attuale prima di procedere) oppure si istruisce l'executor a consultarlo automaticamente, aggiungendo in AGENTS.md:

```
Consult the advisor after the initial repository exploration and before
substantive work on complex tasks.

Also consult the advisor:

• before important architectural decisions;
• when requirements are ambiguous;
• when repeated implementation attempts fail;
• when considering a major change of approach;
• before declaring a complex task complete.

Do not consult the advisor for routine or mechanical changes.

Integrate its guidance critically, then continue the implementation yourself.
```

Il subagent introduce più overhead (contesto separato da trasferire ogni volta), quindi l'Advisor nativo di Claude Code resta più elegante ed efficiente. In compenso OpenCode permette di combinare liberamente provider diversi: executor locale + advisor cloud, DeepSeek + Kimi, modello economico + Opus via API, e così via.

Questo sistema dovrebbe diventare uno standard

Secondo me tutte le coding CLI dovrebbero adottare un vero Advisor nativo, possibilmente multi-provider. È più efficiente dell'uso continuo del modello costoso, più controllabile del routing automatico e quasi sempre più economico degli Agent Teams. Spero che OpenCode, Codex CLI, Kimi Code e Gemini CLI si muovano presto in questa direzione.

Perché dopo averlo provato, tornare a usare un singolo modello per tutto sembra semplicemente uno spreco. Voi cosa ne pensate?

Fonti

• Claude Code Advisor docs
• Claude Code Settings
• Claude Code CLI Reference
• ClaudeDevs su X — benchmark Advisor
• Claude AI su X — annuncio Fable
• Anthropic — Fable
• Anthropic Models Overview
• Anthropic — Opus 4.8
• OpenCode Agents docs
• OpenCode Permissions
• OpenCode Rules

📌 Questo articolo riassume una discussione su r/vibecodingitalia. Leggi il post originale.