Devin Fusion Hits CLI: Cognition Cuts Coding Costs 39%

One day after shipping SWE-2, Cognition pushed its Fusion harness into Devin CLI and Desktop on September 11, 2026 — and led with a number practitioners actually care about: "39% cheaper across coding benchmarks." That's the line from Cognition's own announcement on X, framing Fusion as "the most efficient frontier harness for Fable & Astra."

If you run Devin — or you're deciding whether to — the headline number matters less than what's actually happening under the hood, which benchmark produced it, and whether the same savings show up on your own pull requests instead of Cognition's eval suite.

TL;DR

What "Fusion" Actually Is

Fusion is not prompt caching, and it's not request-level model routing in the OpenRouter sense. It's closer to a planner/executor split within one harness.

Cognition's own description: a frontier "lead" model handles planning, interprets ambiguous instructions, and does final review — while a cheaper "sidekick" model handles the mechanical work: codebase exploration, boilerplate edits, test scaffolding. Both models run inside the same Devin session, but each keeps its own cached context, so switching work between them doesn't blow up the prompt cache the way naively swapping models mid-conversation would.

That separate-cache detail is the actual engineering trick. Mid-task model switching is normally expensive — you lose whatever KV-cache savings you'd built up with the first model and pay full prefill cost on the second. Cognition's Devin CLI/Desktop implementation sidesteps this by keeping the lead and sidekick's contexts independent and exchanging structured briefs and results between them, rather than handing one shared, growing context back and forth. An earlier, broader version of Fusion (rolled out to Devin generally around midyear) also described switching models specifically at context-compaction points — since compaction already forces a cache miss, doing the model swap there is close to free. Both approaches point at the same goal: get the cost benefit of a cheap model without eating the tax of losing cache state every time you hand off work.

This is meaningfully different from what most teams already do to cut agent spend:

Routing picks a model per request. Fusion picks two models per task and keeps them both running.

The Benchmark Numbers — And What They Don't Tell You

Cognition's own blog post breaks the 39% headline into two component pairings: Fable 5.1 as lead + SWE-2 as sidekick runs roughly 36% cheaper than running Claude Code alone on the same tasks, and GPT-6 Astra + SWE-2 runs roughly 39% cheaper than running Astra by itself. An earlier, separate Fusion benchmark (before SWE-2 existed as the sidekick option) reported 35% lower cost on Cognition's own FrontierCode 1.1 Extended suite — Fusion scored 47.9 at $2.38 per task against Opus 4.8's 48.8 at $3.24. Other coverage of that same period cited savings as high as 46% depending on which model pairing and benchmark slice you look at.

Those are all Cognition-run or Cognition-adjacent numbers. The more useful data point for a buying decision is independent: on the Artificial Analysis Coding Agent Index 1.5, Devin Fusion with Fable 5.1 cost about $7.90 per run versus $12.36 for Claude Code running the same model, and Devin Fusion with Astra 6 cost about $4.54 versus $7.47 for Codex with Astra 6. That's a third party measuring dollar cost per completed run rather than Cognition scoring its own harness — closer to what how to read an AI benchmark argues you should look for before trusting a vendor's percentage.

Here's the honest caveat every one of these numbers shares: benchmark cost and production cost are not the same number. FrontierCode, DeepSWE, and the Artificial Analysis index all run curated task sets with known-good scope and clear success criteria. Production work is messier — vague tickets, half-broken test suites, codebases with undocumented conventions. A router that correctly identifies "this is mechanical, hand it to the sidekick" on a clean benchmark task can misjudge a messier real ticket and delegate work that actually needed the frontier model's judgment. Cognition reports that 88% of merged pull requests from its own engineering team were routed automatically through Fusion without a human overriding the router — a genuinely useful data point, but it's Cognition's own dogfooding, on Cognition's own codebase, not a guarantee that transfers to yours.

Where SWE-2 Fits Into This

The timing here isn't a coincidence. SWE-2 launched September 10, scoring 50.0% on FrontierCode 1.1 — within a point of Fable 5.1 — while Cognition claims 64% lower cost at that score level versus Fable 5.1 running solo. Fusion shipping to CLI/Desktop the very next day, with SWE-2 as the recommended sidekick, reads as Cognition connecting the two releases deliberately: SWE-2 is cheap enough and close enough to frontier-tier on mechanical work to be a credible executor model, and Fusion is the harness that lets you keep a frontier model like Fable 5.1 or GPT-6 Astra doing the planning while SWE-2 does the grinding.

This also explains why SWE-2 shipped free for Devin Pro, Max, and Teams subscribers for roughly a month after launch (through mid-October, per Cognition co-founder Scott Wu's own post). A free sidekick model removes the main friction against trying Fusion — you get the dual-model savings without paying twice while you evaluate whether the routing actually holds up on your repos.

What People Are Asking

Does Fusion actually reduce output quality?

On mechanical work, mostly no. On judgment-heavy work, yes — sometimes noticeably. Cognition's own examples show refactoring tasks losing little to no quality when delegated to the cheaper sidekick, while deprecation work saved roughly a third on cost at equivalent quality. But tasks where the "right answer" depends on interpreting ambiguous intent — a hard feature implementation, an architecture decision disguised as a small ticket — showed real quality drops when the router handed them to the sidekick instead of keeping them with the frontier lead model. Cognition's own framing is blunt about this: when the judgment is the deliverable, delegating it backfires. The practical takeaway is that Fusion's router accuracy, not the sidekick model's raw capability, is the thing worth verifying on your own task mix before trusting it broadly.

Is this available now, or still rolling out?

It's live in Devin Desktop and CLI today (September 11, 2026 onward). Cognition's own SWE-2 launch notes from the day before listed "Web + Fusion rolling out" — so Devin Web support for Fusion specifically is following on a separate timeline rather than shipping simultaneously across every surface.

How does Devin's total cost compare to Claude Code, Cursor, or Copilot for similar tasks?

The clearest apples-to-apples number is the Artificial Analysis comparison above: $7.90 vs. $12.36 for a matched Fable 5.1 task, and $4.54 vs. $7.47 for a matched Astra task, both favoring Devin Fusion. That's a real signal that pairing a cheap executor with a frontier planner beats running the frontier model alone through a single-model harness like Claude Code or Codex on cost — at least on that index's task mix. It says nothing about developer experience, IDE integration, or how well Devin's autonomous "ticket to PR" workflow fits your team versus Cursor's in-editor completion model or Copilot's suggestion-based flow — those are different products solving adjacent but distinct problems, and Claude Code vs. Cursor vs. GitHub Copilot is a better starting point if that's the comparison you actually need.

Is this the same as prompt caching or model routing I'm already using?

No — see the technique table above. If your team already leans on prompt caching or a request-level router like the one described in Databricks' cost-management post, Fusion is a complementary, harness-level technique rather than a replacement — it only applies inside Devin's own agent loop, not to whatever routing layer sits in front of your other tools.

What This Means for Teams Running Devin at Scale

If your team is paying for Devin seats and running enough tasks that per-task cost shows up in a monthly bill worth scrutinizing — the pattern this blog has tracked across monthly agent cost breakdowns and enterprise cost-management posts — Fusion is worth turning on and measuring, not adopting on the strength of the 39% headline alone. The mechanism is sound: keeping a frontier model for planning and judgment while routing mechanical execution to a cheaper model is the same intuition behind human engineering teams pairing a senior engineer's design review with a junior engineer's implementation. The open question for any given team is router accuracy on their specific ticket mix, which only shows up after running real work through it — not before.

Concretely: turn on Fusion with Fable 5.1 or GPT-6 Astra as lead and SWE-2 as sidekick (free through mid-October), run your normal ticket queue through it for a week, and compare the actual Devin invoice against your prior single-model spend. That's a more reliable number than any benchmark chart, including this post's.

Honest Limitations

• The 39% headline is Cognition's own framing of Cognition-run benchmarks. The Artificial Analysis numbers are independent and point the same direction, but at different magnitudes (roughly 36-39%, not a flat 39% across the board).
• Quality tradeoffs are real, not hypothetical. Cognition's own writeup documents cases where delegating judgment-heavy work to the sidekick measurably hurt output quality — this isn't a free lunch on every task type.
• Benchmark conditions differ from production. Curated eval tasks have clean scope and clear success criteria; your backlog probably doesn't.
• Router behavior isn't independently audited. The 88% auto-routed merge rate is Cognition's own internal dogfooding statistic, not a third-party study.
• Devin Web support for Fusion is on a separate rollout timeline from CLI/Desktop — availability may vary by surface as of publication.

The Bottom Line

Fusion is a planner/executor split, not a new inference trick or a routing gimmick — a frontier model keeps the judgment calls, a cheap model (now recommended as SWE-2) does the mechanical labor, and separate per-model caching keeps the handoff from being expensive. Cognition's 39% figure and the independent Artificial Analysis numbers agree on direction — Devin Fusion measurably undercuts single-model harnesses on cost for comparable work — even if the exact percentage moves with the benchmark and model pairing you pick. The real test isn't the benchmark chart; it's whether your Devin bill drops by a similar margin once your own ticket mix runs through the router for a few weeks.

Related on explainx.ai

• SWE-2: Cognition's frontier-near coding model lands in Devin — the model shipping as Fusion's recommended sidekick, one day before this launch
• SWE-1.7: Cognition's frontier coding model at 1000 tok/s — the prior Devin model generation
• Databricks: managing AI coding costs at scale — enterprise routing and spend-gate patterns to compare against Fusion
• Prompt caching: a decision framework — the complementary technique Fusion doesn't replace
• What a real AI agent workflow costs per month — worked cost breakdowns to benchmark your own Devin bill against
• Why AI companies want you using agents: token economics — the broader economics behind per-task billing
• Claude Code vs. Cursor vs. GitHub Copilot — for comparing Devin against IDE-native tools, not just other autonomous agents
• How to read an AI benchmark and not get fooled — why the Artificial Analysis numbers matter more than Cognition's own chart

Sources: Cognition — Introducing Fusion in Devin Desktop & CLI · Cognition — Devin Fusion: Frontier Performance at 60% Lower Cost · Cognition on X, September 11, 2026 · Devin Fusion overview — eesel AI · Devin Fusion pricing — eesel AI.

Cost percentages, benchmark scores, and availability reflect Cognition's September 11, 2026 announcement and the third-party sources cited above — verify current numbers on your own task mix before making procurement decisions.