Pilotfish Review: Cut Claude Code Costs 50% With Multi-Model

Ever looked at your Claude Code subscription dashboard on a Wednesday and realized you’d burned through half your monthly Fable 5 quota already? Yeah, me too. Two weeks ago I was staring at 60% of my 2M-token quota gone by midweek, wondering if I was just bad at coding or if something was fundamentally broken about how I was using the tool.

Turns out, it’s neither. The problem is that every single Claude Code session — every search, every edit, every test run, every git blame — draws from the same Fable 5 quota pool. And most of those tasks don’t need a frontier model to do them.

So I went looking for a fix.

Enter Pilotfish — a multi-model orchestration layer that’s been trending on GitHub (475★, 53★/day since launch 9 days ago). It routes sub-tasks to cheaper models automatically: Fable 5 for planning and verification, Sonnet for edits, Haiku for grunt work. Anthropic’s own benchmarks show this split delivers 96% of Fable-only performance at 46% of the cost. I installed it, ran it for a week, and my next billing cycle was $12 lighter.

Here’s the full breakdown.

TL;DR

So Pilotfish is a lightweight orchestration layer that runs inside Claude Code via /init pilotfish. It creates a three-tier model system:

• Fable 5 — strategy, planning, code review
• Sonnet — implementation, refactoring, editing
• Haiku — search, test runs, documentation, git ops

The result? My quota lasted the full week with 30% to spare. Install took 30 seconds. Setup took 10 minutes of config tuning.

What Is Pilotfish, Really?

Honestly? Pilotfish isn’t a Claude Code replacement or a router in the traditional sense. Still — it’s an orchestration layer — think of it as a senior engineer who delegates tasks to junior engineers based on who’s best (and cheapest) for each job.

When you run a Claude Code session with Pilotfish active, here’s what happens under the hood:

1. Your prompt enters the Orchestrator (Fable 5) — it breaks down the request into sub-tasks
2. Each sub-task is assigned to a Worker Agent — routed to Sonnet or Haiku based on complexity
3. Results come back to the Orchestrator for Verification — Fable 5 checks the output, gives feedback, and repeats if needed
4. Final result surfaces to you

Here’s the thing — most tokens in a coding session aren’t judgment calls. Running git diff, searching through a codebase, executing a test suite — these are mechanical tasks that Haiku handles perfectly. The margin calls (should I refactor this module? is this approach correct?) stay on Fable 5.

The Config Files

So Pilotfish drops three YAML config files into ~/.pilotfish/:

orchestrate.yaml — The routing table. This is where you define which model handles which agent role.

orchestrator:
  model: claude-fable-5
  max_tokens: 32000
  decomposition: "auto"  # Let Fable decide how to split tasks

workers:
  editor:
    model: claude-sonnet-4
    max_tokens: 16000
  researcher:
    model: claude-sonnet-4
    max_tokens: 8000
  tester:
    model: claude-haiku-3
    max_tokens: 4000
  documenter:
    model: claude-haiku-3
    max_tokens: 4000

tasks.yaml — Template patterns for common sub-task types. Each template defines the system prompt for that agent role.

policies.yaml — Model selection rules with fallback chains.

fallback_chain:
  - claude-sonnet-4
  - claude-haiku-3
  - claude-fable-5  # Last resort — use Fable if everything else is down

retry_policy:
  max_attempts: 3
  backoff: "exponential"
  graceful_degradation: true  # Fall to cheaper model before dropping task

But the graceful degradation feature is what sold me. If the Anthropic API has a hiccup on Sonnet, Pilotfish doesn’t crash — it drops to Haiku, completes the task, and logs the fallback. Your workflow keeps running.

Benchmarks: The Data That Made Me Install It

Now, Anthropic published their multi-agent benchmarks alongside the Fable 5 launch, and the numbers are striking.

Anthropic Official Benchmarks

Honestly, the sweet spot is the three-tier setup. You lose 4% on benchmarks — in practice I couldn’t tell the difference — but you cut your cost by more than half.

Still, those were Anthropic’s numbers in a controlled lab. I wanted to see real-world data.

Community Experiment (Developers Digest)

Independent testing from the Developers Digest team ran a week-long coding benchmark with real-world tasks:

Source: Developers Digest — Fable 5 Orchestrator Playbook

So your mileage will vary based on your usage pattern — if you spend 80% of your time doing strategic planning, the savings won’t be as dramatic. But if you’re like me (heavy on code search, test cycles, and git operations), these numbers are real.

My Week With Pilotfish

I installed Pilotfish on a Monday morning and ran it through Sunday. Here’s what happened.

Install was dead simple:

/init pilotfish

That’s it. One command in your Claude Code session, and the agent walks you through setting up the three config files. Took me about 30 seconds to type it and another 10 minutes to tune the model routing settings.

But I was still skeptical. A 30-second install felt too easy. I figured I’d notice something broken within a day.

That didn’t happen. The first surprise came on Tuesday. I was deep in a debugging loop — checking logs, patching a function, running the test suite, checking logs again, repeat. With Fable 5 only, each iteration of that loop would burn ~4,000 tokens. With Pilotfish, the test-run sub-task and the log-search sub-task went to Haiku. So each iteration dropped to ~1,800 tokens. The cycle that normally took me to 40% of my daily quota only took 18%.

Wednesday was the real test. My previous week, I hit my Fable 5 soft cap on Wednesday at 3 PM. With Pilotfish, I checked the dashboard on Wednesday evening and I’d used 45% of quota. Normal operations, no active cost avoidance — just the orchestration layer doing its job.

The one feature I didn’t expect to love: graceful degradation. Thursday afternoon, Anthropic had a brief API blip on Sonnet. Pilotfish silently fell back to Haiku for the editor tasks. I didn’t even notice until I checked the logs at the end of the day. No workflow interruption, no error messages, no lost work. That alone made the tool worth keeping.

Where it struggled: That said, complex multi-file refactors with tight coupling across modules are where the orchestration approach hits its limit. I tried a rename-across-20-files operation that Fable 5 normally handles in one shot. Pilotfish’s decomposition broke it into sub-tasks that lost the global context — one worker renamed A → B while another was still referencing A. The orchestrator caught it in verification and fixed it, but the cycle took 30% longer than Fable 5 doing it solo. For deep, cross-cutting refactors, I’d still reach for Fable-only mode.

Pilotfish vs The Alternatives

This is one of the more confusing parts of the Claude Code ecosystem right now — there are three projects in the same orbit but solving different problems.

Claude Code Router handles routing — my Pilotfish article is about handling cost. Agent Chief manages attention — Pilotfish manages models. They’re complementary, not competitors. If you’re running a multi-project Claude Code setup, all three could work together.

Scaling With a Team Gateway

Now, if you’re solo, Pilotfish’s /init pilotfish setup is all you need. But if you’re on a team of 3+ devs all running Claude Code, there’s a smarter setup: deploy Pilotfish behind a shared remora-cc gateway on a VPS.

The idea is simple — instead of each developer configuring their own model routing, you run one gateway that handles model selection centrally. Every Claude Code session on your team routes through it. This means:

• Single config update — change one policies.yaml instead of N
• Shared quota pooling — unused Fable 5 tokens on one dev’s session get reallocated
• Unified logging — see exactly which models are burning your team’s collective quota

But for a team gateway, a DigitalOcean $12 Droplet (affiliate link) handles a 5-person team comfortably. If your team is distributed across the US, Europe, and Asia, Vultr’s 32+ datacenters let you deploy region-local gateways for lower latency. Both will run the remora-cc + Pilotfish stack with zero issues — we’re talking a lightweight Python service, not a GPU workload.

Who Should (and Shouldn’t) Use Pilotfish

Good fit:

• Heavy Claude Code users hitting quota limits weekly
• Developers doing mixed work — code search, test cycles, documentation, plus real coding
• Small teams sharing a subscription or API budget
• Anyone who’s looked at their Claude Code billing and thought “this is unsustainable”

Not a good fit:

• Light users — if you’re not hitting quota limits, the config overhead isn’t worth it
• Pure strategic work — if your Claude Code sessions are all architecture planning and review, there’s nothing to delegate to cheaper models
• Anti-YAML developers — yes, there are three config files. They’re well-documented, but they’re still config files
• Developers on API-key billing who don’t care about cost — if Anthropic API costs are a rounding error in your burn rate, skip it

Final Verdict

Look, Pilotfish isn’t a flashy tool. Plus, it doesn’t add new AI capabilities or unlock magical features. So what does it do? It solves a boring, expensive problem: your Claude Code subscription quota shouldn’t run out because you asked it to search your codebase one too many times.

Still, is it for everyone? No. Light users don’t need it. But if you’re burning through Fable 5 quota faster than you’d like, Pilotfish is a cheap upgrade — easily one of the best returns on investment you’ll make this year. And at 475★ growing at 53★ per day, I’m not the only one who thinks so.