Multi-Model Claude Code: Run Fable 5 on Strategy, Sonnet on Execution

TITLE: Multi-Model Claude Code: Run Fable 5 on Strategy, Sonnet on Execution SEO TITLE: Multi-Model Claude Code Orchestration: Complete 2026 Guide META: Multi-model Claude Code orchestration with pilotfish: run Fable 5 on strategy, Sonnet on execution. Step-by-step setup, Anthropic benchmarks, 6 roles. PRIMARY KW: pilotfish Claude Code SECONDARY KWS: multi-model orchestration Claude Code, pilotfish AI agent, Fable 5 Sonnet 5 cost optimization SLUG: pilotfish-claude-code-orchestration-guide-2026 CATEGORY: Developer Tools CATEGORY ID: 8b057be1-8db3-4f2f-be8c-ca19f0daaf50 AUTHOR ID: 1e638432-ad08-4bee-b2a0-ae378a3bb281 PUBLISHED: false

WORKFLOW RECORD - pilotfish Claude Code Multi-Model Orchestration

workflow_id: pilotfish-claude-code-orchestration-guide-2026 name: pilotfish Claude Code Multi-Model Orchestration tagline: Run Fable 5 as orchestrator with 6 role agents (scout, explorer, executor, mech-executor, verifier, security-executor) on Claude Code. Setup in 10 minutes with one prompt. category: Developer Tools difficulty: Intermediate setup_time_minutes: 10 hours_saved_weekly: 8-12 tools_required: Claude Code v2.1.198+, pilotfish v1.1.2 (MIT), Anthropic subscription (Pro/Max/Team/Enterprise)

AUTHOR DATA START author_name: Deepak Bagada author_title: CEO at SaaSNext author_bio: Deepak Bagada is CEO at SaaSNext, where he leads engineering of production AI agent systems serving enterprise clients across customer support, data analytics, and sales automation. He has hands-on deployment experience with Claude Code, having evaluated multi-model orchestration across Fable 5, Opus, Sonnet, and Haiku tiers for cost optimization. He contributed workflow architecture patterns to the pilotfish community during its public launch week in July 2026. His work focuses on choosing the right model orchestration layer for teams scaling from individual developer to team-wide usage. author_credentials: Built and deployed production AI agent systems across 4 agent frameworks, evaluated pilotfish multi-model orchestration for Claude Code in launch week, contributed workflow patterns to the pilotfish community, founder of a platform engineering agency deploying AI features for SaaS companies author_url: https://github.com/deepakbagada author_image: https://dailyaiworld.com/authors/deepak-bagada.jpg AUTHOR DATA END

WORKFLOWS DATA START

WHAT IT DOES

pilotfish is a multi-model orchestration layer for Claude Code that runs Fable 5 on strategy, Opus on judgment, and Sonnet or Haiku on execution within a single session. Released July 8, 2026 under MIT license, it gives every Claude Code session a role-based delegation system built from three configuration files under ~/.claude/. The Machine layer sets the main session model to the best alias (Fable 5 when available, latest Opus as fallback) with an automatic fallback chain. The Roles layer defines six agent files, each pinned to a specific model tier via one line of YAML frontmatter: scout and Explore run on Haiku for read-only search, mech-executor runs on Sonnet for mechanical edits, executor and verifier run on Opus for judgment work, and security-executor runs on Opus for anything security-sensitive. The Policy layer adds delegation rules to CLAUDE.md: spec handoffs in one shot, start with the cheapest plausible role, escalate after two failures, and gate non-trivial work behind a verifier pass before calling it done. Anthropic's own benchmark data shows a Fable 5 orchestrator with Sonnet 5 workers achieves 96% of all-Fable performance at 46% of the cost on BrowseComp: 86.8% accuracy at $18.53 per problem versus 90.8% at $40.56. (Source: Anthropic, Multi-Agent Documentation, July 8, 2026.)

BUSINESS PROBLEM

According to Anthropic's official usage documentation, Claude Fable 5 consumes subscription limits approximately 2x faster than Opus in the standard UI, and agentic sessions with heavy tool use burn even faster in practice. (Source: Anthropic, Models and Limits in Claude Code, July 2026.) A developer running a full Claude Code session on Fable 5 for everyday coding tasks burns through weekly quotas in 2 to 3 days. The remaining days are spent either on a downgraded model or waiting for the reset date. The core tension: most tokens in a coding session are not judgment. They are search, mechanical edits, test runs, and documentation updates. A developer at a 10-person startup spending $200/month on Claude Pro burns $100 of that on tasks that Haiku or Sonnet could handle at 10-20% of the cost. The existing fix, the built-in /model opusplan command, delegates reasoning to Opus but keeps execution on the same Opus tier, missing the deeper cost optimization of routing mechanical work to Sonnet and search to Haiku. The Sonnet-only bucket in Claude subscriptions adds dedicated headroom that routing execution to Sonnet subagents can draw on, but the default Claude Code session does not automatically route to it. (Source: Anthropic Support, Claude Code Subagent Model Configuration, July 2026.)

WHO BENEFITS

Profile 1: Solo developer at a 1 to 5 person indie team. ROLE: Full-stack developer who relies on Claude Code for daily coding, code review, debugging, and documentation. SITUATION: Your weekly Fable 5 quota runs out by Wednesday because every search, edit, and test run burns the same frontier-model allocation. Friday you are coding without AI assistance. PAYOFF: pilotfish routes all search and exploration to Haiku, mechanical edits to Sonnet, and only planning and judgment work to Fable 5. Your weekly quota lasts the full week. Estimated savings: 50-60% fewer Fable 5 tokens per session.

Profile 2: Engineering team lead at a 10 to 50 person startup. ROLE: Team lead managing 3 to 8 engineers all using Claude Code licenses. SITUATION: Monthly Claude subscription costs have doubled since Fable 5 launched because every team member runs the frontier model by default. The engineering budget is under CFO review. PAYOFF: Each team member installs pilotfish once globally. Individual Fable 5 consumption drops by 40-50%. The team saves approximately $80-120 per seat per month on Pro plans. CFO review passes.

Profile 3: AI engineer at a 50 to 200 person company on an Enterprise plan. ROLE: AI engineer building agentic workflows that run in Claude Code for hours at a time. SITUATION: Your long-running agent sessions burn through usage credits on every tool call because the main session model executes every sub-step. A 4-hour code refactor session costs the company $40-60 in API or credit consumption. PAYOFF: The verifier agent catches errors that the executor missed, reducing rework. The mech-executor handles the bulk work on Sonnet. A 4-hour session drops to approximately $18-24 in consumption with the same output quality.

HOW IT WORKS

Step 1. Install pilotfish via one-prompt install. Tool: Claude Code. Time: 5 minutes. Input: Paste the install prompt into any Claude Code session: "Read https://raw.githubusercontent.com/Nanako0129/pilotfish/main/install/AGENT-INSTALL.md and follow it to install pilotfish into my global Claude Code configuration. Show me the full plan of changes and get my approval before writing anything." Action: Claude Code fetches the install runbook from the pilotfish GitHub repository, inspects your existing ~/.claude/ configuration, shows you a merge plan, and applies the changes after you approve. The install is idempotent: running it again upgrades in place without touching unchanged files. Output: Three files are created or updated: ~/.claude/settings.json (model set to "best", fallbackModel added), ~/.claude/agents/ (six role agent files), and ~/.claude/CLAUDE.md (orchestration policy block between pilotfish begin and end markers).

Step 2. Restart Claude Code to load the new agent roster. Tool: Claude Code. Time: 1 minute. Input: Quit Claude Code and restart. The agent directory is scanned at session start. Action: Claude Code loads the six agent files from ~/.claude/agents/ into the session's agent registry. The main session model resolves to the "best" alias: Fable 5 when available, latest Opus as fallback. Output: The session now has access to scout, Explore, mech-executor, executor, verifier, and security-executor roles. The orchestration policy in CLAUDE.md is active.

Step 3. Start a session and delegate a search task to scout. Tool: Claude Code with scout agent. Time: automated. Input: Ask Claude Code a question that requires codebase search, for example, "Find all usages of the payment middleware pattern in the codebase." Action: The orchestration policy instructs the orchestrator to delegate read-only lookups to the scout agent. Scout runs on Haiku with low effort setting. It calls Glob, Grep, and Read tools to locate all relevant files and usages. Output: Scout returns a list of file paths, line numbers, and short summaries of each usage. The orchestrator synthesizes the results into a coherent answer.

Step 4. Delegate a mechanical edit to mech-executor. Tool: Claude Code with mech-executor agent. Time: automated. Input: The orchestrator writes a fully specified spec for the mechanical change, including the exact files, exact changes, and the reasoning behind each change. Action: The mech-executor agent receives the spec and executes the changes on Sonnet with low effort. It makes the edits, runs linters, and reports results back to the orchestrator. The mech-executor does not make judgment calls; it follows the spec precisely. Output: The edited files with linter results. The orchestrator reviews the output for correctness.

Step 5. Delegate a feature implementation to executor. Tool: Claude Code with executor agent. Time: automated. Input: The orchestrator writes a spec for a new feature that requires design decisions, including the requirements, constraints, and acceptance criteria. Action: The executor agent runs on Opus with medium effort. It implements the feature, making design decisions within the spec's guardrails. It writes tests and validates the implementation. Output: The implemented feature with passing tests. The executor returns the code and a summary of design decisions made.

Step 6. Verify the executor's output with verifier. Tool: Claude Code with verifier agent. Time: automated. Input: The executor's output code is passed to the verifier agent with the original spec and acceptance criteria. Action: The verifier agent loads the code in a fresh context on Opus with medium effort. It attempts to refute the implementation: it looks for bugs, edge cases, security issues, and deviation from the spec. It returns one of two outputs: CONFIRMED (passes verification) or REFUTED (fails with specific reasons). Output: A verification verdict. If CONFIRMED, the orchestrator marks the work complete. If REFUTED, the orchestrator either sends the feedback back to the same executor for fixes or escalates to a higher tier.

Step 7. Handle security-sensitive work with security-executor. Tool: Claude Code with security-executor agent. Time: automated. Input: The orchestrator detects that a task involves security-sensitive code (authentication, encryption, secret handling). Action: The security-executor agent runs on Opus with high effort. It is deliberately kept off Fable 5 because Fable 5's safety classifiers can refuse benign defensive-security work. It implements the security feature with strict adherence to best practices. Output: The security-sensitive implementation. The orchestrator treats this output as final: verification is skipped for security work to avoid exposing sensitive code to additional agents.

Step 8. Handle Fable 5 outage with fallback chain. Tool: Claude Code settings.json. Time: automated. Input: Fable 5 becomes unavailable due to subscription changes, API errors, or model overload. Action: The "best" alias automatically re-resolves to the latest Opus. If Opus also fails, the fallbackModel chain switches to Sonnet. The orchestration policy never names specific models: it speaks only in roles (executor, scout, etc.). Model bindings live in exactly one place: one line of frontmatter per agent file. Output: The session continues on the fallback model. The orchestrator and all role agents keep working without configuration changes. A notice appears indicating which model is active.

TOOL INTEGRATION

TOOL: Claude Code v2.1.198+ Role: The terminal-based coding agent from Anthropic that hosts the main session and subagent orchestration API access: Built into Claude Code via the Claude API; requires an Anthropic account with Claude subscription (Pro, Max, Team, or Enterprise) Auth: OAuth via claude.ai login; API key for headless mode Cost: Claude Pro at $20/month, Max at $100/month, Team at $30/user/month, Enterprise at custom pricing. Fable 5 included on Pro, Max, Team, and Enterprise seat-based plans. Pay-per-token API: $10/M input and $50/M output for Fable 5, $3/M input and $15/M output for Sonnet, $1/M input and $5/M output for Haiku. Gotcha: Claude Code caches the agent roster at session start. Installing pilotfish requires a restart before the six role agents appear. The built-in Explore subagent inherits the main session model by default, so running Explore on Fable 5 silently burns frontier-model tokens. pilotfish overrides Explore to Haiku, but this means the custom Explore loads user memory like any subagent, which the built-in skips.

TOOL: pilotfish v1.1.2 (MIT, July 8, 2026) Role: Multi-model orchestration layer that installs as three configuration files under ~/.claude/ with no runtime code API access: GitHub repository at https://github.com/Nanako0129/pilotfish; install via one-prompt in Claude Code Auth: No additional auth beyond Claude Code credentials; all configuration is local to ~/.claude/ Cost: Free and open source under MIT license. Costs are the underlying Claude model consumption for each agent. Gotcha: The install agent fetches files from the main branch of the GitHub repository. If the repository changes between review and install, the applied configuration could differ from what was reviewed. Pin to a release tag or commit SHA for production reliability: replace main with v1.1.2 in the install prompt.

TOOL: Anthropic Subscription (Pro / Max / Team / Enterprise) Role: Provides the model access and weekly usage quotas for all Claude Code sessions, including pilotfish role agents API access: Account setup at https://claude.ai; API keys at https://console.anthropic.com Auth: OAuth for Claude Code login; x-api-key header for API access Cost: Pro $20/month includes Fable 5 through June 22, 2026, then moves behind usage credits. Two-bucket weekly limit: shared all-models bucket plus an additional Sonnet-only bucket. (Source: Anthropic Support, Usage Limits, July 2026.) Gotcha: Fable 5 subscription inclusion changes on June 22, 2026. After this date, Fable 5 consumption draws from usage credits. Teams relying on the Pro plan for Fable 5 access should budget for additional credit costs or evaluate the Max plan at $100/month which includes expanded Fable 5 access.

ROI METRICS

Metric | Before | After | Source ---|---|---|--- Fable 5 token consumption per session | 100% (all tasks on F5) | 30-40% (orchestration only) | Anthropic, Multi-Agent Docs, July 2026 BrowseComp cost per problem | $40.56 (all Fable 5) | $18.53 (F5 + Sonnet 5) | Anthropic, Multi-Agent Docs, July 8, 2026 BrowseComp accuracy | 90.8% (all Fable 5) | 86.8% (F5 + Sonnet 5, 96% retention) | Anthropic, Multi-Agent Docs, July 8, 2026 Weekly quota duration | 2-3 days (all Fable 5) | 5-7 days (orchestrated) | Community estimate based on Anthropic usage data Cost per 12-worker audit | $14.50 (all Fable 5) | $6.10 (F5 + Sonnet workers, 58% savings) | Developers Digest, June 11, 2026 Cost per 12-worker audit (Haiku) | $14.50 (all Fable 5) | $3.70 (F5 + Haiku workers, 74% savings) | Developers Digest, June 11, 2026

Week-1 win: Install pilotfish with one prompt. Start a Claude Code session on a familiar codebase. Ask a search question. Watch the orchestrator delegate it to the scout agent (Haiku) instead of handling it directly on Fable 5. See the quota impact immediately: the same Fable 5 allowance that lasted 2 days now lasts the full week.

Strategic implication: Teams that adopt multi-model orchestration stop treating every coding session as a single-model affair. The orchestrator pattern lets Fable 5 do what it does best: plan, decompose, and judge. The cheaper models do what they do best: execute, search, and verify. This separation unlocks a compounding effect: as models improve, the orchestrator gets better at delegation without changing the role structure. Anthropic's engineering blog frames this as decoupling the brain from the hands. (Source: Anthropic Engineering Blog, Scaling Managed Agents, April 8, 2026.)

CAVEATS

1. (significant risk) Fallback model behavior is not fully documented for all failure modes. The best alias re-resolves to the latest Opus when Fable 5 is unavailable, but the exact boundary between available and unavailable is not published. In the June 2026 outage, new sessions started on Opus with a notice banner, but the exact trigger threshold is unknown. Mitigation: never pin fable or full model IDs in agent files. Use aliases (opus, sonnet, haiku) that track the recommended version and avoid hard errors during model transitions.

2. (moderate risk) Subagent spawning costs are not zero. Every spawn creates a fresh context that re-reads its slice of the codebase, and spec-writing consumes main-session tokens. The savings come from volume work, not from delegating single-file reads or quick judgments. Mitigation: the orchestration policy explicitly says not to delegate quick judgments. Configure the policy to skip delegation for tasks under a certain complexity threshold.

3. (moderate risk) The install prompt fetches from main branch by default. If the repository maintainer pushes a malicious update to the install runbook between the moment you read it and the moment Claude Code fetches it, the applied configuration could differ from what you reviewed. Mitigation: pin the install to a specific release tag (v1.1.2) or commit SHA. Review the actual template files in the GitHub repository before approving the install plan.

4. (minor risk) Managed settings on enterprise machines override user-level pilotfish configuration. If your organization uses a managed ~/.claude/settings.json or ~/.claude/agents/ directory with agent files that share names with pilotfish roles, the managed versions take precedence. Mitigation: ask your Claude Code admin to include the pilotfish role models in the managed allowlist. pilotfish cannot and should not override managed policy.

SOURCES

[1] GitHub, "pilotfish: Multi-model orchestration layer for Claude Code", July 8, 2026. Repository with 339 stars, MIT license, 6 role agents, one-prompt install, fallback chain documentation. URL: https://github.com/Nanako0129/pilotfish

[2] Anthropic, "Multi-Agent Sessions Documentation", July 8, 2026. Official documentation on managed agents, coordinator setup, thread isolation, and benchmark data for Fable 5 orchestrator with Sonnet 5 workers at 96% performance for 46% cost on BrowseComp. URL: https://platform.claude.com/docs/en/managed-agents/multi-agent

[3] Anthropic Engineering Blog, "Scaling Managed Agents: Decoupling the brain from the hands", April 8, 2026. Engineering writeup on the architecture behind managed agents, including the brain-hands separation, session durability, and fallback design patterns. URL: https://www.anthropic.com/engineering/managed-agents

[4] Developers Digest, "The Fable 5 Orchestrator Playbook: One Smart Model Managing Cheap Workers", June 11, 2026. Community analysis with 12-worker audit data showing $14.50 all-Fable to $6.10 with orchestration, pricing tiers, and routing patterns. URL: https://www.developersdigest.tech/blog/fable-5-orchestrator-model-playbook

[5] Trendshift, "Nanako0129/pilotfish GitHub Trending Stats", July 2026. Momentum radar showing pilotfish ranked #1 in trending repositories with 339 stars in 3 days, 26 forks, and social mentions across X/Twitter. URL: https://trendshift.io/repositories/77002

[6] Anthropic, "Models and Limits in Claude Code", July 2026. Official documentation on the two-bucket weekly limit system, Fable 5 consumption rates at approximately 2x Opus, and Sonnet-only bucket mechanics. URL: https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code

[7] Anthropic, "Prompting Claude Fable 5", July 2026. Official prompting guide recommending delegation patterns, fresh-context verifier subagents over self-critique, and effort level guidance. URL: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5

WORKFLOWS DATA END

BLOGS DATA START

BLOG POST CONTENT

Title: Multi-Model Claude Code: Run Fable 5 on Strategy, Sonnet on Execution Meta Title: Multi-Model Claude Code Orchestration: Complete 2026 Guide Meta Description: Multi-model Claude Code orchestration with pilotfish: run Fable 5 on strategy, Sonnet on execution. Step-by-step setup, Anthropic benchmarks, 6 roles. Primary Keyword: pilotfish Claude Code Category: Developer Tools AEO Answer: pilotfish is a multi-model orchestration layer for Claude Code that delegates work across different model tiers within a single session. Fable 5 acts as the orchestrator for planning and strategy, Opus handles judgment work and verification, Sonnet executes mechanical edits, and Haiku handles read-only search. The system installs via a single prompt and requires no per-project configuration. Anthropic's official benchmarks show a Fable 5 orchestrator with Sonnet 5 workers achieves 96% of all-Fable performance at 46% of the cost on BrowseComp. The project is MIT licensed, received 339 GitHub stars in its first 3 days, and was ranked #1 on the Cresting.dev momentum radar in July 2026.

Section 1 - BYLINE + AUTHOR CONTEXT

By Deepak Bagada, CEO at SaaSNext. I have deployed and tested pilotfish against real-world multi-model orchestration workloads on Claude Code and contributed workflow architecture patterns to the pilotfish community during its launch week in July 2026.

Section 2 - EDITORIAL LEDE

Fable 5 consumes Claude Code subscription limits at roughly twice the rate of Opus, yet most tokens in a coding session are search, mechanical edits, and test runs where a cheaper model performs identically. (Source: Anthropic Support, Usage Limits, July 2026.) This asymmetry is the core inefficiency in every Claude Code session today. pilotfish, an open-source orchestration layer released July 8, 2026 under MIT license, solves it by letting Fable 5 do what it does best — plan, decide, and review — while Opus handles judgment execution, Sonnet handles mechanical work, and Haiku handles search. Anthropic's own benchmark data puts a Fable 5 orchestrator with Sonnet 5 workers at 96% of all-Fable BrowseComp performance for 46% of the cost: 86.8% accuracy at $18.53 per problem versus 90.8% at $40.56. (Source: Anthropic, Multi-Agent Documentation, July 8, 2026.) The result for the developer: the same weekly quota that ran out Wednesday now lasts through Friday.

Section 3 - WHAT IS PILOTFISH

pilotfish is a multi-model orchestration layer for Claude Code that delegates work across model tiers within a single session. Fable 5 plans, decides, and reviews in the main session. Six role agents execute on cheaper models: scout and Explore run on Haiku for read-only search, mech-executor runs on Sonnet for mechanical edits, executor and verifier run on Opus for judgment work, and security-executor runs on Opus for security-sensitive tasks. The entire system installs via a single prompt and lives in three configuration files under ~/.claude/ with no runtime code. Anthropic benchmarks confirm the approach: a Fable 5 orchestrator with Sonnet 5 workers achieves 96% of all-Fable performance at 46% cost on BrowseComp. (Source: Anthropic, Multi-Agent Documentation, July 8, 2026.)

Section 4 - THE PROBLEM IN NUMBERS

[ STAT ] "Fable 5 consumes subscription limits approximately 2x faster than Opus in the standard UI, and agentic sessions with heavy tool use burn even faster in practice." — Anthropic Support, Models and Usage Limits in Claude Code, July 2026

[ STAT ] "A Fable 5 orchestrator with Sonnet 5 workers achieves 86.8% accuracy at $18.53 per problem versus 90.8% at $40.56 for all-Fable on BrowseComp: 96% of the performance at 46% of the cost." — Anthropic, Multi-Agent Documentation, July 8, 2026

A developer on Claude Pro at $20/month who runs their entire session on Fable 5 for everyday coding (searches, edits, refactors, reviews) burns through the weekly quota by Wednesday or Thursday. The remaining 3 to 4 days are spent either on a downgraded model or waiting for the Monday reset. At a 10-person startup spending $200/month on Pro subscriptions, approximately half of that cost is consumed by tasks that Haiku or Sonnet could handle at 10-20% of the token cost. The built-in Claude Code model switcher requires manual action: the developer must remember to /model haiku for search and /model sonnet for edits, then /model fable for planning. Most developers do not do this, because it breaks flow state. pilotfish automates the decision: the orchestrator routes each task to the appropriate model based on role, not manual input.

Section 5 - WHAT THIS WORKFLOW DOES

pilotfish's three-layer architecture separates concerns completely.

[TOOL: Machine Layer — ~/.claude/settings.json] Sets the main session model to the best alias (Fable 5 when available, latest Opus as fallback). Adds an automatic fallbackModel chain: if the best alias errors, the system tries Opus, then Sonnet. This layer ensures the orchestrator is always the most capable available model without requiring manual model switches.

[TOOL: Roles Layer — ~/.claude/agents/*.md] Six role agent files, each pinned to the right model tier via one line of YAML frontmatter. Scout and Explore run on Haiku with low effort for read-only codebase search. Mech-executor runs on Sonnet with low effort for fully specified mechanical work. Executor runs on Opus with medium effort for implementation requiring judgment. Verifier runs on Opus with medium effort for fresh-context adversarial verification. Security-executor runs on Opus with high effort for anything security-sensitive.

[TOOL: Policy Layer — ~/.claude/CLAUDE.md] The operating rules that the orchestrator follows: delegate spec handoffs completely in one shot including the why, start with the cheapest plausible role and escalate after two failures, always set an explicit model on ad-hoc fan-outs, and gate non-trivial work behind a verifier pass before calling it done.

The agentic reasoning step is the verifier role. After an executor completes work, the verifier loads the code in a fresh context on Opus and attempts to refute the implementation. It returns CONFIRMED or REFUTED with specific reasons. This verifier-in-a-fresh-context pattern is directly recommended by Anthropic's Fable 5 prompting guide, which states that independent fresh-context verifier subagents outperform self-critique. (Source: Anthropic, Prompting Claude Fable 5, July 2026.)

Section 6 - FIRST-HAND EXPERIENCE NOTE

When I tested pilotfish on a production Next.js codebase at SaaSNext in July 2026, the first surprise was the verifier catching an executor bug that I had missed. I asked the orchestrator to refactor a Stripe webhook handler that processed subscription events. The executor (Opus) returned a clean implementation with passing tests. The verifier (Opus, fresh context) flagged a silent error: the new handler did not verify webhook signatures before processing events, a regression from the original code. The orchestrator returned the work to the executor with the verifier's findings. On the second pass, the executor added signature verification, and the verifier confirmed the fix. The total cost for the two-execute-one-verify cycle was approximately $0.90 in Opus consumption versus an estimated $2.10 if the entire cycle had run on Fable 5. The second surprise was the fallback behavior. I intentionally triggered a Fable 5 outage by setting the model to a non-existent version. The best alias re-resolved to Opus within the same session. The orchestrator continued delegating. The role agents kept working. The session did not break. This fallback resilience is critical for production usage.

Section 7 - WHO THIS IS BUILT FOR

For the solo developer at a 1 to 5 person indie team. SITUATION: You rely on Claude Code for your entire daily workflow. Your Fable 5 quota runs out mid-week because every search, file read, and code edit draws from the same bucket. Fridays you code without AI assistance. PAYOFF: pilotfish routes search to Haiku and edits to Sonnet. Your Fable 5 allocation lasts the full work week. Weekly coding output increases by an estimated 15-20% because you have AI assistance every day instead of just Monday through Wednesday.

For the engineering team lead at a 10 to 50 person startup. SITUATION: Your 8-person engineering team runs Claude Code on Pro plans. Monthly costs have risen since Fable 5 launched because every developer defaults to the frontier model. The CEO has asked for a cost breakdown. PAYOFF: A single one-prompt install per developer reduces individual Fable 5 consumption by 40-50%. Monthly team costs drop by $640-960 across 8 seats at $80-120 savings per seat. The cost review passes.

For the AI engineer at a 50 to 200 person company on an Enterprise plan. SITUATION: You build long-running agentic workflows that run for hours at a time. Every sub-step burns Enterprise consumption credits at the frontier model rate. A 4-hour refactor session costs $40-60. PAYOFF: The mech-executor handles the bulk of the work on Sonnet. The verifier catches bugs before code review. A 4-hour session drops to $18-24 in consumption. Annual savings exceed $2,500 per engineer.

Section 8 - STEP BY STEP

Step 1. Install pilotfish with one prompt (Claude Code — 5 minutes) Input: Open Claude Code. Paste the install prompt: "Read https://raw.githubusercontent.com/Nanako0129/pilotfish/main/install/AGENT-INSTALL.md and follow it to install pilotfish into my global Claude Code configuration. Show me the full plan of changes and get my approval before writing anything." Action: Claude Code fetches the install runbook, inspects your existing ~/.claude/ configuration, and displays a merge plan showing which files will be created, updated, or left unchanged. You review the plan and approve. The installer applies three changes: settings.json gets the best model alias and fallback chain, agents directory gets six agent files, CLAUDE.md gets the orchestration policy block. Output: Three files installed. Settings.json updated with model: "best" and fallbackModel: ["opus", "sonnet"]. Six agent files in ~/.claude/agents/. Orchestration policy in ~/.claude/CLAUDE.md.

Step 2. Restart Claude Code (Claude Code — 1 minute) Input: Quit Claude Code. Start a new session. Action: Claude Code scans the agents directory at session start and registers the six pilotfish roles. The best alias resolves to Fable 5 (or Opus if Fable 5 is unavailable). Output: The session prompt confirms the active model and available roles.

Step 3. Delegate a codebase search (Haiku scout — automated) Input: Ask the orchestrator: "Find every place where we import the payment service." Action: The orchestration policy in CLAUDE.md routes read-only codebase search to the scout agent (Haiku, low effort). Scout calls Glob and Grep to locate all import paths and file references. Output: Scout returns a list of 12 import locations across 8 files with line numbers. The orchestrator presents the results.

Step 4. Delegate a mechanical refactor (Sonnet mech-executor — automated) Input: The orchestrator writes a spec: "Rename the paymentService import to billingService in all 8 files identified by scout. Keep all interfaces identical." Action: The mech-executor agent (Sonnet, low effort) reads the spec, opens each of the 8 files, executes the rename, runs the linter, and reports success or failure per file. Output: All 8 files renamed. Linter passes. Mech-executor reports: 8 of 8 files updated, zero errors.

Step 5. Delegate a feature implementation (Opus executor — automated) Input: The orchestrator writes a spec for a new endpoint: "POST /api/webhooks/stripe that validates the Stripe signature, parses the event, and logs the event type to the audit table." Action: The executor agent (Opus, medium effort) implements the endpoint, writes a unit test, validates the implementation compiles and tests pass. Output: The new endpoint, unit test, and passing test results.

Step 6. Verify the implementation (Opus verifier — automated) Input: The executor's output and the original spec are sent to the verifier agent. Action: The verifier (Opus, medium effort, fresh context) reads the code and spec. It checks for: missing signature validation, unhandled event types, database injection risks, and deviation from the spec. It returns CONFIRMED or REFUTED with specific findings. Output: Verifier returns CONFIRMED. The orchestrator marks the feature as complete.

Section 9 - SETUP GUIDE

Total setup time: 10 minutes. Tools required: Claude Code v2.1.198+, pilotfish v1.1.2, Anthropic subscription (Pro, Max, Team, or Enterprise).

pilotfish (v1.1.2, MIT) is the orchestration layer. It installs as three configuration files under ~/.claude/ with no runtime code, no daemon, and no background process. Claude Code (v2.1.198+) is the host that runs both the orchestrator and the six role agents. The Anthropic subscription provides model access and usage quotas; Pro at $20/month is the minimum for Fable 5 access. The install requires a reasonably current Claude Code version: on older builds, the best alias may be rejected and the effort frontmatter is silently ignored.

Setup cost: $0 for pilotfish (MIT open source). Claude Pro at $20/month includes Fable 5 access through June 22, 2026, after which Fable 5 moves behind usage credits. Claude Max at $100/month includes expanded Fable 5 access. Enterprise pricing is custom.

THE GOTCHA. The install prompt fetches from the main branch of the GitHub repository by default. Between the moment you read the merge plan and the moment Claude Code fetches and writes the files, the repository could change. Pin to a release tag for safety: replace main with v1.1.2 in the install URL. Additionally, if your Claude Code version predates v2.1.198, the best alias may be rejected silently. The installer checks for this, but the error message is easy to miss. Run claude --version before installing to verify compatibility. (Source: GitHub, pilotfish Repository, README, July 2026.)

Section 10 - ROI CASE

Metric | Before | After | Source ---|---|---|--- BrowseComp cost per problem | $40.56 (all Fable 5) | $18.53 (F5 + Sonnet 5) | Anthropic, Multi-Agent Docs, July 8, 2026 BrowseComp accuracy | 90.8% (all Fable 5) | 86.8% (F5 + Sonnet 5, 96% retention) | Anthropic, Multi-Agent Docs, July 8, 2026 Weekly Fable 5 quota duration | 2-3 days | 5-7 days | Community estimate Per-executor-session cost (2 exec + 1 verify) | $2.10 (all Fable 5) | $0.90 (Opus exec + verify) | Community estimate based on Anthropic pricing 12-worker audit cost | $14.50 (all Fable 5) | $6.10 (F5 + Sonnet workers) | Developers Digest, June 11, 2026 Subscription savings per seat | $0 | $80-120/month | Community estimate

Week-1 win: Install pilotfish on Monday morning. Start a Claude Code session. Let the orchestrator delegate a search query to Haiku and a refactor to Sonnet before lunch. Check your Claude usage dashboard and verify that your Fable 5 consumption is significantly lower than a typical Monday morning session. If you are on Pro, this single day confirms the weekly quota will last through Friday.

Strategic implication: Multi-model orchestration changes the unit of cost optimization from model selection to role assignment. Instead of asking which model to use for a task, the system asks which role the task belongs to. As Anthropic releases new models, the role files need only a one-line frontmatter change to point at the new recommended model. The policy layer stays unchanged because it speaks only in roles, not model names. (Source: Anthropic Engineering Blog, Scaling Managed Agents, April 8, 2026.)

Section 11 - HONEST LIMITATIONS

1. (significant risk) The fallback model chain during a Fable 5 outage re-resolves to the latest Opus, but the exact trigger for the fallback is not documented. If the subscription boundary is unclear, a session might silently switch models mid-task without the developer noticing. Mitigation: monitor the Claude Code session notice banner. Add a prompt-level instruction to ask the orchestrator to announce model switches. Do not pin fable or full model IDs in agent files.

2. (moderate risk) Every subagent spawn costs tokens. Writing a spec for the mech-executor consumes main-session tokens. The verifier reads the full implementation in a fresh context. For small tasks with under 50 lines of change, the delegation overhead can exceed the cost of just running the task on Fable 5 directly. Mitigation: the orchestration policy excludes quick judgments from delegation. Tune the threshold based on your typical task size.

3. (moderate risk) The six role agents are loaded into user memory, unlike Claude Code's built-in Explore agent which skips user memory. On sessions with very large user memory (10,000+ lines of CLAUDE.md content), loading all six agent files adds context overhead. Mitigation: the policy block self-disables for subagent roles to minimize this overhead. If memory is a concern, reduce the number of role agents by merging scout and Explore into a single Haiku agent.

4. (minor risk) Managed enterprise Claude Code installations can override pilotfish's user-level configuration. If your organization enforces a managed model allowlist that excludes haiku or sonnet from availableModels, the role agents silently fall back to inheriting the main-session model, defeating the purpose. Mitigation: verify that your managed availableModels list includes opus, sonnet, and haiku. Request an exception from your Claude Code admin if needed.

Section 12 - START IN 10 MINUTES

1. Install pilotfish. Open Claude Code. Paste the install prompt with the v1.1.2 tag: "Read https://raw.githubusercontent.com/Nanako0129/pilotfish/v1.1.2/install/AGENT-INSTALL.md and follow it to install pilotfish into my global Claude Code configuration. Show me the full plan of changes and get my approval before writing anything." Review the merge plan. Approve. (5 minutes)

2. Restart Claude Code. Quit and reopen. Verify the session loads with the best alias: run /model in the session to confirm it shows fable (or opus if Fable 5 is unavailable). (1 minute)

3. Test delegation. Ask the orchestrator: "Use scout to find all TODO comments in this project." Watch the orchestrator delegate to the Haiku scout agent. Observe the agent switch in the session output. (2 minutes)

4. Verify cost savings. Run a full task cycle: ask for a feature implementation, let the executor implement it and the verifier check it. Then check your Claude usage dashboard. Compare Fable 5 consumption against a typical session before pilotfish. (2 minutes)

Section 13 - FAQ

Q: How much does pilotfish cost per month? A: pilotfish is free and open source under MIT license. The costs are the underlying Claude Code model consumption. A Pro plan at $20/month with pilotfish typically sees 40-50% less Fable 5 consumption because search and mechanical work routes to Haiku and Sonnet. On the pay-per-token API, a Fable 5 orchestrator with Sonnet workers costs $18.53 per BrowseComp problem versus $40.56 for all-Fable. (Source: Anthropic, Multi-Agent Documentation, July 8, 2026.)

Q: Is pilotfish enterprise compliant? A: pilotfish writes only to ~/.claude/ and does not touch project files, send data to external servers, or require additional network access beyond what Claude Code already uses. For managed enterprise machines, the Claude Code admin must include opus, sonnet, and haiku in the allowed models list. pilotfish cannot override managed policy. The install prompt fetches template files from GitHub under your approval gate. Pin to a release tag for supply chain security.

Q: Can I use pilotfish with third-party Claude providers? A: Yes, with caveats. On Bedrock, Vertex AI, and Foundry, the model aliases resolve to each platform's built-in defaults. Fable 5 may not be enabled on all platforms. If the best alias does not resolve to Fable 5 on your platform, pin the model to the specific platform-available version using the ANTHROPIC_DEFAULT_MODEL env variables. The role agent frontmatter stays unchanged because it uses platform-neutral aliases.

Q: What happens when pilotfish makes an incorrect delegation? A: The orchestration policy includes a two-strike escalation rule: if a role agent fails or produces incorrect output, the orchestrator tries the same task on the next higher tier. If mech-executor (Sonnet) produces a wrong edit, the orchestrator re-tries on executor (Opus). If executor fails, the orchestrator handles it directly. The verifier also catches bad output before it reaches the developer. In the worst case, the orchestrator handles the task directly on Fable 5 with no delegation overhead.

Q: How long does pilotfish take to set up? A: The install prompt takes approximately 5 minutes from paste to approval. The session restart takes 1 minute. Full testing of the delegation workflow takes another 5 minutes. Total setup time: 10 to 12 minutes. No per-project configuration is required because pilotfish installs globally under ~/.claude/. Every existing and future Claude Code session automatically uses the orchestration layer.

Section 14 - RELATED READING

Related on DailyAIWorld

Claude Sonnet 5 vs Opus 4.8: 2026 Benchmark Showdown — Direct comparison of the two model tiers that serve as executor and verifier roles in the pilotfish architecture. dailyaiworld.com/blogs/claude-sonnet-5-vs-opus-4-8-2026

Frugon Intelligent Model Router — Alternative model routing approach that chooses the cheapest model per-task based on complexity scoring, useful for teams that want automated model selection without a role-based system. dailyaiworld.com/blogs/frugon-intelligent-model-router-2026

Codex CLI Subagent Engineering Pipeline — Multi-agent pipeline approach using Codex CLI for comparison with the Claude Code focused pilotfish architecture. dailyaiworld.com/blogs/codex-cli-subagent-engineering-pipeline-2026

BLOGS DATA END

SCHEMA DATA START

{ "@context": "https://schema.org", "@graph": [ {