Cognition's Devin Fusion Cuts Coding AI Costs 35% Without Losing Frontier Intelligence

Frontier AI models are expensive, and using them for every line of code is starting to hurt. Cognition just shipped Devin Fusion, a hybrid-model harness built into their Devin coding agent that keeps frontier-level intelligence while cutting costs by 35% on real engineering tasks. The trick is not simpler routing logic -- it is a fundamentally different architecture that runs two agents in parallel and switches models mid-task without blowing up the token cache.

The problem with model routing today

The standard approach to reducing AI inference costs is model routing: classify the task upfront, send easy work to a cheap model, and reserve the expensive frontier model for hard tasks. It sounds reasonable, but it breaks down in practice for two reasons.

• Tasks reveal their difficulty late. A prompt that looks like a simple bug fix can turn into a multi-file race condition investigation three steps in. A router that commits to a cheap model at the start has no way to recover.
• Cache misses are brutal. Switching between models mid-session means the new model has no cached context. Cache hit tokens cost 10x less than cache miss tokens -- on Opus, that is $1.50/MTok cached versus $15/MTok uncached. Every cold-start switch is a significant cost spike.

Existing workarounds like the "Smart Friend" or "Advisor" patterns -- where one model queries another for advice -- hit the same wall. Upon every call to the other model, the context for the task is not shared in a way that is cached, and you pay a very expensive price. Devin Fusion is built specifically to avoid this.

The sidekick: two agents, one brain

The core idea behind Fusion is running two fully capable agents simultaneously: a frontier main agent and a smaller, cheaper "sidekick" agent. Both have their own toolsets, their own shell access, and their own persistent cached context. The frontier agent acts as a tech lead -- it plans, handles ambiguity, and does final review. The sidekick does the execution.

As the task progresses, the main agent decides which tasks to give the sidekick and which tasks to do itself. The main agent should take minimal actions, and only read what is absolutely necessary. By default it should delegate and monitor, while making the significant decisions: the plan, the interpretation of ambiguity, the final review.

This sidekick architecture solves the three classic routing failure modes:

• No benchmark overfitting. By keeping a frontier model in the mix, the sidekick approach continues to benefit from frontier model creativity and general intelligence.
• Handles follow-up complexity. Model routers often route to a single model for the entire task. Prompts often do not contain enough information about the task to properly discern difficulty. Being able to move between the smart model and sidekick dynamically makes this system much more robust.
• No cache miss penalty. In the sidekick setup, both the main model and sidekick model maintain their own persistent, cached contexts.

Dynamic routing: switching models mid-session for free

The second innovation is dynamic mid-session routing. Fusion uses lightweight classifiers running during task execution to detect when the sidekick is in over its head and the frontier model needs to take back control. The clever part is when this switch happens.

Fusion accomplishes cache-efficient switching by switching the model during context compaction, which would trigger a cache miss anyway. Each time compaction is triggered, Fusion takes it as an opportunity to evaluate the situation and switch the model that is in charge, effectively getting model switching "for free." Context compaction -- the process of summarizing and trimming a long conversation history to fit within a model's context window -- is a natural seam where the cache is already invalidated, making it the ideal moment to swap models at zero additional cost.

What it actually costs and where it wins

Cognition benchmarked Fusion against their new FrontierCode benchmark, which measures not just whether code is correct, but whether a maintainer would actually merge the PR. Without including Fable 5, Devin Fusion gives a 35% cost improvement on FrontierCode relative to frontier models like GPT-5.5 and Opus 4.8, while maintaining performance matching the frontier.

The savings are not uniform. Fusion shines on mechanical work and test-heavy tasks, but struggles when the judgment call is the deliverable. Here are real examples from Cognition's internal testing:

• Modernizing a JS file to ES6 with a slow Playwright test suite: Devin wrote the diff and handed off the slow test run. Cost dropped 62% with no quality loss.
• Ripping out OpenTracing across a Go server: Mechanical removal across many files, few judgment calls. Cost dropped 32%, same quality.
• Adding a cross-team search feature in React/Redux: Hard, multi-file feature graded on judgment calls. The sidekick lost the subtle intent. Score dropped from 75 to 27.

The pattern is clear: delegate execution, not judgment. When the value of the task is in the nuanced decisions -- architectural tradeoffs, ambiguous requirements, subtle design patterns -- keeping the frontier model in the driver's seat matters.

FrontierCode: the benchmark that made this possible

Devin Fusion was built and measured against FrontierCode, a new benchmark Cognition released weeks earlier. FrontierCode is the first benchmark to measure code mergeability, assessing end-to-end code quality including correctness, test quality, scope discipline, style, and adherence to codebase standards.

Over 20 world-class open-source developers built realistic, diverse, and challenging coding tasks from the repos they maintain, spending more than 40 hours per task. They define what "mergeable" means in their repo. The benchmark grades code the way a tech lead would, not a CI pipeline -- checking whether the patch is scoped correctly, whether tests actually catch regressions, and whether the code fits the project's existing style.

Results show Claude Opus 4.8 leads on the hardest Diamond subset with only a 13.4% score, highlighting how far current models are from production-quality code. That context matters for interpreting Fusion's numbers: a 35% cost reduction while holding a 47.9 score is meaningful precisely because that score represents real engineering quality, not benchmark gaming.

The Fable 5 asterisk

The most impressive result in the blog post comes with a significant caveat. Fable 5 proved to be exceptionally performant in this multi-model harness, achieving a 41% cost reduction while maintaining the same performance as Fable 5 in a traditional agent harness. But on June 12, 2026, access to Fable 5 was suspended in accordance with a US government directive. As of the blog post, access has not been restored. Cognition plans to extend Fable 5 to Fusion users once access is restored.

The suspension aside, the Fable 5 result points to something important: recent models, and Fable 5 especially, perform unusually well in these multi-agent setups. Fable delegates work more intelligently, requests context more efficiently, and plans more precisely, all of which yield a larger cost improvement with minimal impact on intelligence. The sidekick pattern is not just a cost hack -- it is an architecture that gets better as base models improve.

The bigger picture: the end of one-model-fits-all

Cognition is making a broader argument here, not just shipping a feature. The age of using one model for all of your work is coming to an end. The rising costs of frontier intelligence are reaching prohibitive levels in engineering organizations small and large.

There is also a growing case for mixing models based on their relative strengths rather than just their cost. Some models are better at UI testing. Others are better at identifying subtle bugs in PRs. As models emerge that excel at particular languages, tasks, or libraries, investing in multi-model capabilities only becomes more important.

The internal validation is encouraging: 88% of merged PRs driven by Cognition's internal users were handled entirely by the automated Fusion router , with no manual model selection required. Devin Fusion is available now in preview at app.devin.ai. Existing Devin plans apply -- no separate pricing tier is required to access Fusion.