Devin Fusion adds Fable 5 to cut coding-agent task costs

• Devin Fusion now incorporates Fable 5, and Cognition says the Fable-led version ran at lower cost per task than Opus 4.8 while improving delegation and reasoning-chain efficiency, according to Cognition's announcement.
• The cost inversion came from the harness: Fable + Sidekick cut cost by 54% versus pure Fable while leaving score nearly unchanged, a result omarsar0's thread pulled out of Cognition's writeup.
• The mechanism was management style: Fable wrote specs, delegated implementation, and avoided touching code in many runs, while Cognition's comparison said Opus 4.8 tended to reread files and redo work.
• The caveat is workload shape: serial debugging keeps accumulating context in one chain of judgments, and Cognition's caveat says cost savings were not uniform across tasks.
• The broader pattern is turning into product UI: Devin exposes Fusion and other routers in its menu, while Amp's Dial replaces raw model picking with modes that combine GPT-5.6 Sol and Fable 5.

Cognition's Fable cost post has the cleanest weird number: Fable 5 costs twice as much per token as Opus 4.8, yet Fable + Sidekick came out 9% cheaper per run. The diagram in omarsar0's thread reduces the pattern to an executor and on-demand advisor. Artificial Analysis framed the same accounting problem around turns, token efficiency, prompt-cache hit rate, and token price.

Cognition shipped Fable 5 into Devin Fusion and said the new setup is live in Devin Cloud as an agent preview, according to its availability post. The official Devin Fusion post describes the harness as a frontier lead model plus a cheaper, faster sidekick, with dynamic mid-session routing layered on top.

The newer Fable cost post says Cognition ran 3,000 FrontierCode 1.1 sessions across four configurations: Fable and Opus as the lead model, each with and without the same cheap sidekick.

The headline result:

• Fable 5 + Sidekick: 60.7 score, $1.86 mean cost per run.
• Opus 4.8 + Sidekick: 54.6 score, $2.04 mean cost per run.
• Fable 5 alone: 60.8 score, $4.03 mean cost per run.
• Opus 4.8 alone: 55.4 score, $3.06 mean cost per run.

Fable's per-token premium survived the benchmark. The bill fell because the lead model took fewer expensive turns.

The sidekick architecture only pays off if the expensive model can stop doing expensive-model work. Cognition's logs put numbers on that split.

In the official breakdown, Fable + Sidekick spent more on the sidekick than Opus + Sidekick, $0.58 versus $0.31 per run. The Fable lead spent less on itself, $1.28 versus $1.73, because it averaged 11.5 lead turns per run versus Opus's 26.5.

The token gap was larger than the dollar gap:

• Lead input tokens: 545k for Fable + Sidekick, 1,679k for Opus + Sidekick.
• Lead output tokens: 6.1k for Fable, 19.0k for Opus.
• Lead code edits: 81% of Fable-led runs had zero lead-model code edits, versus 24% for Opus.
• Repo reads: 13% of Fable-led runs never had the lead model read a repo file.

Omar Sarikaya called the pattern "building your own harness & orchestrator" in his follow-up, and later said he wanted more experiments combining frontier, provider, and open-weight models rather than treating model choice as a single fixed pick in the same thread.

Cognition's qualitative sample was small but useful: it parsed every LLM call across the 3,000 sessions, then manually inspected 40 tasks where either Fable or Opus was much cheaper plus a middle sample.

The key difference was when the lead model handed off work. Cognition said both leads delegated about three times per run, but Fable delegated earlier, while Opus often explored, designed, and implemented before assigning the mechanical tail.

The management pattern looked like this:

• Fable wrote handoff briefs with constraints, edge cases, and a definition of done.
• The sidekick handled implementation, tests, and lint in its own context.
• Fable reviewed diffs with cheap git show or git diff style checks.
• When work came back over-engineered, Fable often delegated a simplification pass.
• Opus pulled sidekick files back into its own context twice as often and made four times more corrective edits at lead-model prices.

Jared Friedman's commentary highlighted the most counterintuitive part: a more expensive model can be cheaper when it avoids work outright. Andrew Levie reached the same read in his post, calling Fable's behavior "the habits of a good manager."

Cognition's caveat is the part that keeps this from becoming a one-line recipe. Short tasks have little room to delegate, and serial debugging tasks can require one accumulating context chain where the root-cause hunt is the work.

Community reports split along the same fault line. One Reddit user debugging a severe Windows failure said Sol caught subtle Fable mistakes and was faster and cheaper, while still saying the test was too limited for a firm conclusion in the OpenAI thread. Another user comparing hydraulic diagrams in mechanical engineering said Fable caught two ChatGPT 5.6 errors, but consumed 100% of the session where ChatGPT used 1% in a separate OpenAI thread.

The shared constraint is context ownership. If the expensive model must hold the whole chain of evidence to make the next judgment, the sidekick has less room to save money.

Devin's UI already exposes routing as a product surface rather than an internal implementation detail. Dabit listed seven router-style modes available in Devin:

• Fusion: frontier performance at 35% lower cost, using a smart sidekick.
• Agent (Normal): fast long-horizon planning and execution.
• Agent (Fast): 2.5x faster, 2x more expensive, same intelligence.
• Lite: cheap, fast models for lightweight tasks.
• DANA: a specialized data analyst router.
• Adaptive: a local router that picks the model automatically.
• Ultra: always picks the strongest frontier model available.

dabit3's reply said Cognition has multiple routers including Fusion, and his follow-up pointed readers back to the Fusion explainer.

Amp is pushing the same idea through a different interface. sqs's Dial screenshot shows a mode set to GPT-5.6 Sol X-High plus Fable 5 High, with the claim that a dial conveys user intent better than a raw model picker.

The hands-on pattern outside Devin is already more granular than "pick the best model." Paulius Ztin said he cut the token count of 63 Claude skills by 40% by asking Fable to audit invocation frontmatter, remove duplicate or system-prompt-baked claims, refactor for progressive disclosure, and clean dangling scripts, then implemented the plan with Opus.

swyx described a four-role stack for bigger projects in his workflow post:

• Sol Ultra to plan.
• Fable 5 to critique.
• Sonnet 5, Terra Ultra, or SWE 1.7 to code.
• Devin Review to review.

The scout-agent variant pushes ambiguity resolution out of the main context. pvncher described using Codex scout agents for research first, then running the main agent after ambiguity is resolved.

Artificial Analysis framed agent cost around four variables that match Cognition's finding:

• Token price: model list prices still matter.
• Turns: previous outputs become future inputs, so multi-turn trajectories compound cost.
• Token efficiency: verbose models can cost more per task at lower per-token prices.
• Prompt caching and hit rate: long tasks repeatedly resend instructions, files, research, and tool outputs.

The research thread is broader than Devin. AlphaSignal's paper roundup cited a harness-only study where changing orchestration cut cost per task 41%, median wall clock 44%, and tokens by a similar amount while holding model weights fixed. The Register's Databricks coverage quoted the same market shift as a move from price per token to price per completed task.