Found something good?

You open Claude Code in the morning, give Fable 5 one real task, and by lunch you've hit the limit.

Most people read that as "the quota is too small." I think it's the opposite signal:

You're paying frontier prices for a model to do work a cheaper model would do just as well.

Fable 5, GPT-5.6 Sol Max - they're extremely capable, but they're also slow and expensive to run. As the frontier gets stronger, the frontier model stops being the thing that writes your code and becomes the thing that decides what code gets written.

This is now the officially recommended practice, not a hack. Use the big model as the planner. Use a smaller one as the executor.

The economics are hard to argue with: Sonnet 5 costs about 20% of Fable 5, and performs roughly at the level of Opus 4.8 - which was the strongest model on earth a few months ago. You are not downgrading. You're paying 2026 prices for what was state-of-the-art in spring.

The two setups - and why only one of them is cheap

Claude Code's own docs describe two ways to do this, and they sound equivalent:

1. Advisor. Sonnet 5 is the main driver. It does the work, and occasionally makes a tool call out to Fable 5 to review its plan and hand back advice.

2. Orchestrator. Fable 5 is the main agent. It asks questions, makes the plan, freezes the spec, and spins up worker agents on a smaller model to execute.

Devin actually ran both. They've been shipping a harness called Devin Fusion, which claims Fable-5-level or better performance at ~35% lower cost by routing different task types to different models. Strip away the branding and Fusion is essentially: Claude Code's Fable 5 orchestrator + Sonnet 5 workers.

Their conclusion was not ambiguous. The orchestrator pattern wins, and the reason is token accounting, not intelligence:

An advisor has to read the main agent's full conversation history to say anything useful. A worker only receives a task.

Advisor calls send fresh input tokens every time. Worker calls hit cached context — and cached tokens cost roughly 10% of new input tokens. The advisor pattern quietly charges you frontier rates for re-reading your own transcript, over and over.

The part everyone gets wrong: sub-agents should be persistent

Here's where most orchestrator setups leak money without anyone noticing.

Traditionally, when Claude Code or Codex spawns a sub-agent, it spins up a fresh session on the fly. The sub-agent works, returns a final message, and dies. Then the main agent reads the result, decides something's off, and wants a revision — so it calls the task tool again, which spawns a brand new sub-agent with zero context. That agent re-reads the same files, re-derives the same understanding, and burns the same tokens a second time.

Devin calls the fix a sidekick. The sub-agent is a persistent session. Feedback goes back as a follow-up message to the same agent, which still has everything it learned — and all of that context is now cached, so it's nearly free.

If you use Claude Code, you already have this. It's literally what agent teams are:

So Fable 5 as coordinator, Sonnet 5 as executor, persistent and cache-warm, is available to you today with no infrastructure.

The 20 lines that turn it on

You get the whole workflow by adding a delegation-rules section to your CLAUDE.md. Mine says, roughly:

it spells out three things:

In practice: I ask it to design and build a to-do app. It asks me clarifying questions, plans, and for anything non-trivial writes a frozen spec into a task folder so there's no ambiguity left for the executor. Then it spawns a Sonnet 5 sub-agent whose prompt is basically "your role is executor, do the work yourself, don't spawn sub-agents, read the spec first, implement."

And because it's Sonnet 5, the implementation is dramatically faster than watching Fable 5 type it out.

The rules file is in the AI Builder Club skills repo - copy it straight into your own CLAUDE.md.

Tmux to have agent-team across harness

This is where the neat story breaks. In reality most of us run several agents: Codex, Gemini CLI, Open code, Kimi K3, etc.

Ideally you'd use the best coordinator you have - Claude Code or Codex on the top model - and then be free to pick any harness for the workers.

The Codex team has been quietly good about this. They shipped a Codex plugin for Claude Code that lets you delegate tasks to a Codex agent. Install the plugin, add OpenAI Codex, reload, and now you can say "delegate to a Codex agent to improve the UI of the to-do app at this URL." It gives you a small set of commands: codex rescue (Codex as a sub-agent), codex review (Codex reviews the git diff), codex result (fetch output from a specific session), codex cancel, and codex transfer (fork the conversation history over to the Codex side).

The Codex bridge is great. But what if you want to talk to Gemini CLI, Groq, Pi agent, OpenClaw, or anything else?

There's a general answer, and it's older than all of this: tmux.

tmux is a terminal multiplexer. It starts persistent terminal sessions, and - this is the part that matters - it lets you read and manipulate any of them programmatically.

Start an agent in a new pane on the right:

Send it a follow-up message (.1 = the second pane on screen):

Read what's on that screen and print it back:

That's the whole trick. Once you see it, the idea lands: you can just tell your agent to use tmux to start agent sessions the same way a human would — and through that, drive literally any coding agent as a real teammate.

The one hard part: how does the worker tell you it's done?

Starting sessions is easy. Notification is the actual problem.

tmux has a signalling primitive for this. A pane can raise a named signal, and another process can block until it fires:

So you instruct the sub-agent: when you finish, fire this signal. The orchestrator runs the wait command in the background, and the moment the worker is done, the command returns and the output gets piped back. That's a real completion callback across any two agents.

I wrapped the whole tmux hack into a skill called Open Agent Teams in the AI Builder Club GitHub repo: the skill file, the script, and a reference file with the delegation-rules section for your CLAUDE.md / AGENTS.md. Copy-paste over: https://github.com/AI-Builder-Club/skills/blob/main/skills/open-agent-teams/SKILL.md

Orca & Herdr & other ADEs

There are tools with this built in and a UI layer on top — Herdr and Orca. I tested basically all of them. Personally, Orca gives the best experience.

Orca ships an orchestration skill out of the box: a CLI plus a skill that does roughly what my tmux hack does. But because it's wired into their interface, the experience becomes genuinely intuitive rather than clever. I gave a fresh Orca repo the exact same joke task, and:

Plus Kanban view, token-usage tracking, and a mobile experience — all out of the box. It's fully open source and free, and it's been growing extremely fast the last few weeks. It's been my daily driver for talking to agents.

We did a one-hour deep-dive workshop with the Orca founder in @aibuilderclub_, walking step by step through how they ship hundreds of commits to Orca itself and orchestrate across Codex, Claude Code, and OpenCode - come join if you want the deeper version.

Meanwhile, we've included Open Agent Teams skill and the delegation rules for your CLAUDE.md in @aibuilderclub_ Github repo: https://github.com/AI-Builder-Club/skills