Cognition’s new SWE-2 coding model creates a tempting argument for anyone tired of spending premium-model quota on ordinary development work. On FrontierCode 1.1 Main, SWE-2 scores 50.0% against Fable 5.1’s 50.9% while Cognition says it costs 64% less. On another current coding benchmark, Fable scores more than twice as high.
That makes SWE-2 worth testing. It does not make Fable 5.1 obsolete.
The better move is workload routing. Give SWE-2 routine jobs where a cheap failed attempt is easy to catch. Keep Fable 5.1, GPT-6 Astra, or another stronger frontier model available when a failed run can cost more than the inference you saved.
SWE-2 vs Fable 5.1: key takeaways
Cognition reports 50.0% for SWE-2 on FrontierCode 1.1 Main, against 50.9% for Fable 5.1, while claiming SWE-2 costs 64% less at that comparison point.
The same SWE-2 release reports 27.3% on Terminal-Bench 4, against 55.8% for Fable 5.1 and 57.9% for GPT-6 Astra.
SWE-2 beats Fable 5.1 on two other Cognition-reported coding tests. The evidence does not support treating it as a generally weak budget model.
Cognition evaluates different model families through different agent harnesses. The scores measure model-plus-agent systems rather than isolated model intelligence.
For real teams, the useful metric is cost per accepted patch, including retries and human review. SWE-2 looks like a strong cheap first route, not an obvious universal replacement.
What Cognition released with SWE-2
Cognition introduced SWE-2 on September 10, 2026, calling it its most advanced coding model so far. The company post-trained it from Kimi K3, a 2.8-trillion-parameter base model that had already undergone extensive reinforcement learning for agentic coding.
Cognition changed more than the base model. SWE-2 training explicitly penalizes unnecessary inference cost, with different penalties for its medium, high, and max effort settings. On FrontierCode, Cognition says SWE-2 medium takes 58% fewer turns than SWE-1.7 and costs 81% less on average.
That focus is useful because coding agents can burn a surprising amount of money before producing useful code. They read files, grep repositories, create plans, revisit assumptions, run tests, and sometimes consume a great deal of context while deciding what to do.
SWE-2 medium made its first real edit after a median 18 steps in Cognition’s FrontierCode runs. SWE-1.7 took 48.
SWE-2 is available through Devin Desktop and Devin CLI, with Devin Web and Fusion rolling out. Cognition’s launch announcement does not offer downloadable SWE-2 weights or a standalone SWE-2 API.
That limits what “switching to SWE-2” means today. You are adopting Cognition’s agent environment rather than changing one model ID inside any coding stack you already use.
The Terminal-Bench 4 result changes the SWE-2 comparison
Cognition published four headline coding results, and they point in different directions.
On FrontierCode 1.1 Main, SWE-2 scores 50.0%, Fable 5.1 scores 50.9%, and GPT-6 Astra scores 53.3%. On DeepSWE 1.1, SWE-2 reaches 73.0%, ahead of Fable’s 67.4% and just below Astra’s 74.1%.
Terminal-Bench 2.1 is also favorable to SWE-2. It scores 92.8%, compared with 91.4% for Fable and 89.9% for Astra.
Then Terminal-Bench 4 flips the picture. SWE-2 falls to 27.3%, while Fable 5.1 reaches 55.8% and Astra reaches 57.9%.
That single row makes a blanket migration hard to defend. Fable resolves more than twice the share of Terminal-Bench 4 tasks in Cognition’s published comparison.
The version change deserves attention too. Terminal-Bench 4.0 recalibrated CPU, memory, and time resources, fixed 19 tasks, removed 8 saturated or problematic tasks, and moved to an 8-hour agent timeout. The changes are substantial enough that old trials cannot simply be carried onto the new leaderboard.
The 92.8% Terminal-Bench 2.1 score remains useful evidence. It just describes a materially different benchmark version from the one producing SWE-2’s 27.3% result.
For someone choosing a coding agent now, the current test deserves more weight than the much prettier older number.
FrontierCode is closer to ordinary repository work
The near-tie with Fable on FrontierCode still deserves attention.
FrontierCode asks whether a repository maintainer would actually merge an AI-generated pull request. Its tasks come from real open-source repositories and are written by maintainers. Grading covers correctness, test quality, scope discipline, style, and repository conventions through tests, rubrics, and other verifiers.
That is a useful target for coding-agent evaluation. Real development work usually involves understanding an issue, finding the relevant code, making a bounded change, testing it, and producing a patch someone else is willing to accept.
A 50.0% result beside Fable 5.1’s 50.9% therefore gives SWE-2 a credible case for ordinary repository work.
There is a methodological catch. Cognition uses the harness primarily associated with each model family when it does not have a public result. Anthropic models run through Claude Code, OpenAI models through Codex, xAI models through Grok Build, and open-weight models through Devin CLI. Cognition also reports the best score across reasoning-effort settings.
So the leaderboard does not isolate the underlying model while keeping everything else fixed. It compares deployed coding systems.
That can be more useful than a sterile model-only test if you are buying an agent. It also makes “SWE-2 is within one point of Fable 5.1” a less universal claim than the number first suggests. Harness behavior, tool use, context management, and effort settings all contribute to the result.
The 64% cheaper claim is task-specific
Cognition’s strongest economic claim is that SWE-2 reaches 50.0% on FrontierCode while costing 64% less than Fable 5.1.
The comparison point for Fable 5.1 Medium is $3.28 per FrontierCode task. Anthropic currently prices Fable 5.1 at $10 per million input tokens and $50 per million output tokens, with substantially cheaper cache reads.
The important unit in Cognition’s claim is per FrontierCode task.
There is no general SWE-2 per-token API price in the launch announcement. Devin also meters usage according to the work its agent performs, including action count and complexity, context gathering, execution, browser activity, virtual machine time, and networking.
So a 64% benchmark cost advantage does not mean your coding bill automatically falls by 64%.
Your workload could save less. It could save more. Retries and cleanup can wipe out an apparent model-price advantage very quickly.
Popular AI’s broader AI API cost comparison reaches the same practical point for coding agents. Cheap inference is useful only when the model does not give the saving back through extra attempts, longer context traces, or developer repair time.
There is also room to reduce the amount of expensive cloud context an agent consumes before changing the model itself. Tools such as Promptscout target the costly repository-context discovery step, which can make routing experiments more useful when repository exploration is a large part of your bill.
More on AI agent routing:
Where SWE-2 should replace premium models first
SWE-2 now looks good enough that paying Fable or Astra prices for every coding task is difficult to justify.
Start with work where failure is cheap and verification is strong. Ordinary bug fixes with reproducible tests are a good fit. So are straightforward test additions, repository exploration, mechanical implementation from a precise issue, small features backed by strong CI, documentation-related code changes, and routine refactors with clear boundaries.
Those jobs resemble the repository work where SWE-2’s FrontierCode result is encouraging. They also give your test suite a chance to reject a bad patch before an engineer spends half an afternoon repairing it.
SWE-2 medium is the obvious first configuration to test. Cognition describes it as the faster, more cost-conscious effort level for simple and intermediate work.
Do not promote it to your default because a vendor leaderboard looks good. Promote it after it survives your repositories, your test suites, and your review process.
That same rule applies inside Anthropic’s lineup. Popular AI’s Claude Opus 5 vs Fable 5 comparison reaches a similar cost-per-accepted-result approach: pay for the stronger model when its extra capability actually removes failures or human intervention.
More on Fable 5 for coding:
Where Fable 5.1 or Astra should stay available
The Terminal-Bench 4 gap argues for keeping a stronger escalation model.
Use that route for ambiguous requirements, unfamiliar infrastructure, difficult environment problems, multi-stage migrations, heavy tool use, long autonomous sessions, weak test coverage, and changes where a plausible-looking mistake is expensive.
The exact boundary will vary by repository. Your job is to find the point where SWE-2’s retries, bad patches, or review burden cost more than its cheaper inference saves.
This is why GPT-6 Astra makes more sense as an escalation model than a universal default. Expensive intelligence earns its price when it prevents expensive failures.
A coding stack does not need a single permanent champion. It needs a cheap first route, a clear promotion rule, and a model strong enough to handle the ugly work when the first route stalls.
More on GPT-6 Astra for coding:
Claude quota pressure makes routing more attractive
There is another practical reason coding-agent users may want a cheaper first route.
Anthropic says Fable 5.1 is included as a standard part of Max and certain premium Team and seat-based Enterprise plans. On those plans, Fable models can consume up to 50% of the account’s weekly usage limit, while still drawing from the broader weekly allowance.
That makes premium capacity something users may prefer to save for jobs where it has a real advantage.
There are also recent reports from Claude Code users about confusing Fable consumption. One September 8 GitHub report describes roughly half of a renewed allowance disappearing after resuming a long Fable 5.1 session and asking a simple question.
Another September 8 report describes a Fable usage indicator jumping sharply after only a few short interactions, alongside contradictory usage percentages and a weekly-limit warning.
These are individual user reports, not evidence of a product-wide quota-accounting bug. They still show why predictable consumption belongs in the routing decision.
A model can be excellent and still be a poor default for routine work when its quota is scarce or difficult to predict. Saving Fable for jobs where its extra capability pays for itself becomes much more attractive under those conditions.
SWE-2 arrives at a convenient moment to compete for the rest.
Measure cost per accepted patch instead of token price
Teams considering SWE-2 should run a routing trial on their own work rather than debate benchmark rankings.
Take 20 to 50 representative issues. Include easy fixes, tests, medium-sized feature work, debugging, and a few unpleasant jobs that tend to send agents wandering through the repository.
Run comparable tasks through SWE-2 and your current premium model. Record model or agent cost, retries, elapsed time, whether CI passes, whether the first patch is acceptable, and how much human review or repair the result needs.
Then calculate:
cost per accepted patch = (AI cost + retry cost + human review cost) / accepted patches
If you use subscriptions rather than APIs, substitute quota consumption for direct model charges.
That measurement catches the failure that token pricing hides. A $1 attempt followed by another $1 attempt and 25 minutes of engineer cleanup can lose to a $4 run that works the first time.
Popular AI reached the same conclusion when looking at Meta Muse Spark 1.1 as a cheaper coding-agent option. Low inference cost creates an opportunity. Reliability determines whether you keep the saving.
The test also tells you where routing should happen. You may find SWE-2 wins decisively on repetitive fixes but loses on environment debugging. Another team may discover the boundary elsewhere. That answer is more valuable than knowing which model won an averaged leaderboard.
More on Meta Musa Spark for coding:
SWE-2 still leaves you dependent on hosted AI
There is another tradeoff behind the SWE-2 comparison.
SWE-2 comes through Devin. You still depend on somebody else’s account system, hosted inference, billing rules, policies, and continued model availability.
Cognition’s current Platform Terms allow customer inputs and outputs to be used for model training and service improvement. Paid customers can opt out. Cognition says an opt-out prevents customer data from being used for model training and enables Zero Data Retention with its model providers. Enterprise arrangements may have separate protections.
Teams working with private repositories should check the terms attached to their own account before moving sensitive code.
Switching from Claude Code to another hosted coding agent can change the vendor, price, benchmarks, and workflow. It does not give you a local fallback.
If reducing cloud dependence is the actual goal, local AI puts the model and workflow on hardware you control. That comes with its own hardware, software, and maintenance burden.
Popular AI’s GGUF Loader Agentic Mode guide covers the coding-agent version of that approach, where model inference and repository access stay on your own machine.
Local operation does not magically solve coding-agent reliability either. The Qwen 3.5 Desk Test shows how tool calling, parsers, streaming, and file edits can become failure points even when the underlying local model looks strong in benchmarks.
Hosted SWE-2 and local coding agents solve different problems. SWE-2 is mainly an economics and capability option inside a hosted workflow. Local agents trade some convenience and frontier capability for more control over the machine, model, repository access, and vendor dependency.
More on local AI for coding:
Who should test SWE-2 now
▪ SWE-2 deserves an immediate trial if your team already uses Devin, spends meaningful money on repetitive agentic coding, has good automated tests, or routinely burns premium-model capacity on jobs that do not require the strongest model available.
▪ Teams with reproducible issues and reliable CI are in the best position to benefit. They can route more work to the cheaper model because mistakes are easier to detect automatically.
▪ Keep Fable 5.1, Astra, or another strong frontier model ready when requirements become ambiguous, failure gets expensive, or the result is difficult to verify.
▪ Teams without good tests and review discipline should move more cautiously. Cheap autonomous code stays cheap only while bad output is cheap to catch.
▪ Anyone hoping SWE-2 removes dependence on hosted AI should look at a different architecture. Cognition has made a strong case for cheaper hosted coding. It has not turned SWE-2 into a model you own.
SWE-2 is a routing win, not a full Fable 5.1 replacement
SWE-2 has done enough to earn real work.
A 50.0% FrontierCode score beside Fable 5.1’s 50.9%, plus stronger DeepSWE and Terminal-Bench 2.1 results, is too competitive to dismiss as budget-tier coding. Cognition’s reported cost advantage makes the case for testing even stronger.
Terminal-Bench 4 supplies the brake pedal. SWE-2 reaches 27.3% while Fable 5.1 reaches 55.8% on the same published comparison.
So keep the decision practical.
Route ordinary implementation, tests, repository exploration, and well-bounded fixes to SWE-2. Escalate difficult, ambiguous, and expensive-to-fail work to Fable 5.1, Astra, or whichever frontier model proves strongest on your repositories.
Then watch one number: cost per accepted patch.
If SWE-2 wins there, you have found something more useful than another benchmark champion.
Explore more from Popular AI:
Start here | Local AI | Builds & gear | Autonomy & policy | Fixes & guides | Popular AI podcast