SWE-2 Flash: 3x faster code at a fifth of the price

The SWE-2 Flash is a coding model from Cognition, with 276 billion total parameters and 12 billion active, released on November 4, 2026. It costs a fifth of the larger SWE-2 and answers three times faster in the announcement's simulated replay, 200 against 60 tokens per second. The new capability comes from the training recipe; the price comes from a commercial decision.

What changed in the training recipe?

Cognition inserted a mid-training stage before reinforcement learning, built on Thinking Machines' Inkling-Small. The new stage consumes a few trillion tokens of scientific articles, blogs, code and other sources, across three stages. On FrontierCode 2.0, the base model scored 3.2% and SWE-2 Flash delivers 24.0%.

That sentence hides the part that matters to whoever signs the invoice. The jump from 3.2% to 24.0% is not a large model getting better: it is a small model being prepared before it is charged for the work. Mid-training is the stage between raw pre-training and reinforcement, and Cognition presents it as new in the recipe.

The order is deliberate: the scarcest material enters the last of the three stages. To choose the mix, Cognition compared the token efficiency of each source.

Task diversity is not in that stage. It appears in reinforcement, where Cognition audited the instructions, environment and verifiers of each task and assembled new task types. That is where the company locates most of the gain: the tweaks to the recipe were minor, and the difference came from the quality and diversity of the tasks.

The announcement stops there. It declares no training savings, does not say reinforcement got shorter, and does not tie the recipe to the price: it presents the model at a fifth of SWE-2 as a commercial decision, next to the speed. The connection between the new stage and cost per task is this analysis's reading, not the vendor's claim.

An expensive coding model is not expensive per parameter, it is expensive per attempt. Every reinforcement round that fixes a basic behavior burns GPU without returning new capability. Preparing the format beforehand reduces what is left for reinforcement to learn.

The second number is the active parameter count: 12 billion lighting up inside 276 billion, and sparse activation lowers the cost per token.

The recipe, stage by stage, looks like this:

Cognition publishes the mid-training volume, a few trillion tokens, and neither the pre-training nor the reinforcement volume. The table describes the design, not the budget.

The announcement publishes eight evaluations and highlights three in a chart: FrontierCode 2.0, which looks at patches in real repositories, Terminal-Bench 4.0, which looks at terminal operation, and DeepSWE 1.1, which looks at task resolution. A model can do well on one and badly on another, which is why the decision comes out of the full table.

Where does SWE-2 Flash still lose?

On FrontierCode 2.0, SWE-2 Flash scores 24.0% against 23.8% for SWE-2, and that is the only one of the eight published evaluations where it leads. On DeepSWE 1.1 the gap is 12.9 points, and on Terminal-Bench 4.0 it is 7.3. Against Claude Haiku 5.5, the disadvantage on FrontierCode 2.0 is 3.7 points.

Margins deserve a cold reading, because they do not carry the same weight.

The advantage over its larger sibling is 0.2 points and fits inside run-to-run variation; calling Flash more capable than SWE-2 because of it would be stretching the data. What the table shows is something else: the model at a fifth of the price ties on FrontierCode 2.0 and trails on the other seven published evaluations, with a 12.9 point gap on DeepSWE 1.1 and 4.5 on FrontierCode 1.1. The trade is cost, and its price is capability outside FrontierCode 2.0.

The gap against Claude Haiku 5.5 changes with the axis. On FrontierCode 2.0 it is 3.7 points. On Terminal-Bench 4.0, Haiku scores 39.2 against 20.0, which makes 19.2 points, and on DeepSWE 1.1 Flash leads by 0.8. Anyone who cites only the first number is picking the favorable axis.

The question left is operational: how many points does one extra review per week cost? In code with test coverage, the wrong patch dies at the test. Without coverage, it reaches production.

Figures read on November 6, 2026. The speed is the one from the simulated replay of a trace on Terminal-Bench 4.0, not a production measurement. The point gaps cited in the text are simple subtractions between the cells of this table. Benchmarks change version and harness.

None of the eight evaluations carries a confidence interval, and the announcement does not say how many runs support each number. That defines the use: it serves to choose where to test, not to sign a contract. The difference between 23.8% and 24.0% does not survive that absence. The 12.9 points on DeepSWE do.

The conclusion is not replacement, it is division, but the tolerance criterion has to come from the right axis. Against SWE-2, the loss is zero on FrontierCode 2.0, 7.3 points on Terminal-Bench 4.0 and 12.9 on DeepSWE 1.1, the evaluation closest to a short agent task. Code review, unit testing and guided refactoring have cheap verification to absorb the error. The agent layer, which the diagram below places in the same risk band, is the one that loses most on the published axis, and it migrates after the pilot.

What is the cost per task at each layer?

Cost per task drops to a fifth in the layers that migrate, because the price per token is a fifth and the token volume per task does not change. The layer that stays on the large model keeps its current cost. The gain depends on how the portfolio is split, and that split is an engineering decision, not a price-list decision.

Before the index, here is the math that decides the migration: a fifth of the price buys five attempts for the price of one. On the fifth, the whole advantage disappears. A team that migrates a layer and watches retries climb to five attempts per task has saved nothing, and that is the most common way to lose the savings.

The table below uses an index with SWE-2 at 100. It is arithmetic on the relative price in the announcement, not a vendor number, and it assumes the same token volume per task in both models.

With 70% of the volume migrated, the portfolio index goes from 100 to 44: seventy percent at a fifth of the price, thirty percent at full price. The 56% drop is not a vendor discount, it is a consequence of where the work is placed. If the agent layer stays out until the pilot closes, the split shrinks and the index rises.

The matrix below translates the same math into the decision for each layer.

One layer the table does not capture: the agent loop. 200 tokens per second against 60 shortens the wait on every round, and across ten chained calls the difference is visible to whoever is waiting on the screen. Speed does not cut the bill directly: it cuts the engineer's task switching while the agent runs.

Do closed weights change the buying decision?

Yes, they change the risk, not the price. Cognition did not publish the SWE-2 Flash weights and justified the decision on cyber risk. The announcement says the company is building a program to share the weights with industry partners and research labs, with more details in a few weeks, without a date and without a list.

The number behind the justification is declared as training work, not as a side effect. Cognition states that it targeted cybersecurity in training and that this raised ExploitBench from 11.3% to 34.8%. The consequence the announcement itself admits: the same capabilities serve attackers, and that is why the weights stay closed.

For a buyer, the consequence has two sides. On the good side, there is no weight running outside the vendor's environment, which simplifies provenance auditing. On the bad side, there is no plan B: if the provider changes the model behind the same name, behavior changes without notice and with no way to pin the previous version. That is vendor dependency under another name.

The other end of the market measures the price of that choice. An open 1M-token model, such as the one covered in DeepSeek V4.1-Flash-1017: an open 1M-token model with its own search at $0.75 per thousand calls, lets a team download the weights and freeze a version, according to the internal article. SWE-2 Flash does not, and the trade is explicit: better performance per token against worse version control. That is not a licensing detail.

The broader governance decision is in The new position on open-weight models and the enterprise governance problem. Closed weights shift evaluation toward observed behavior in production, since the artifact is not available for inspection.

The announcement declares the intent to give transparent weight access to partners and researchers, with fine-tuning and execution in sensitive environments. Intent is not a guarantee: there is no deadline, no entry criterion and no commitment to public release. Anyone who needs weights for compliance treats SWE-2 Flash as a hosted model and negotiates contract, retention and notice of version change.

What the announcement publishes and what stays open for the contract conversation:

None of those answers is in the announcement. All of them weigh more than price when the code belongs to a regulated client, and the question stops being how much a token costs: it becomes who answers when behavior changes without notice.

What window exists to evaluate before November 30?

Access is open in Devin Desktop and the CLI, free through November 30, 2026. The window is short and has a declared deadline, which changes the shape of the pilot: you cannot run a quarter of observation and decide afterward. The evaluation has to produce a number before the end of the month.

Three and a half weeks are enough to measure cost per task across three layers and not enough to measure quality on legacy code. Accepting the asymmetry is the start of an honest pilot.

There is one profile that should not enter now: a team with high regulatory-risk code and no test suite to serve as a net gains little from three weeks.

The measurement that supports the decision has five steps, and none of them is optional:

1. Freeze a set of 30 tasks the team has already solved, with the accepted diff serving as the answer key.
2. Run the same 30 tasks on SWE-2 Flash and on the current model, without adjusting prompts between the two runs.
3. Record three data points per task: tokens spent, time to the first useful answer and whether the diff was accepted without edits.
4. Compare the acceptance rate before cost: a cheap model with lower acceptance returns the difference in rework.
5. Repeat the run in the last week of the window, to capture a behavior change in the hosted model.

With the number in hand, the 90-day script fits the deadline. Each phase has an exit criterion, because a pilot without an exit criterion becomes an opinion with a chart.

Phase 1 usually fails. Running in parallel means executing the same task on both models and comparing the accepted diff, not switching the model and seeing whether something breaks. The first format produces a number, and the second produces an impression.

Phase 3 exists because of the closed weights. Without a pinnable version, the only protection against silent change is to measure again after free access ends, because next month's behavior may not be the pilot's.

Frequently asked questions

The five questions below are the ones that open the buying conversation: weights, replacing SWE-2, the origin of ExploitBench, absolute price and the deadline of the window. Each answer stays within what the announcement publishes, and what it does not publish appears as a declared absence.

Does SWE-2 Flash have open weights? No. Cognition did not publish the weights and cited cyber risk, with ExploitBench rising from 11.3% to 34.8%. The company says it is building a program with partners, with details promised in a few weeks, without a date and without a guarantee of release.

Does it replace SWE-2? Not for all work. It ties on FrontierCode 2.0, at 24.0% against 23.8%, and trails on the other seven published evaluations, with 12.9 points on DeepSWE 1.1. In exchange, it costs a fifth and answers three times faster in the simulated replay. The reading that holds up is to split the portfolio by layer.

Why did ExploitBench rise from 11.3% to 34.8%? Because Cognition targeted cybersecurity in training, according to the announcement: the gain is a declared training objective, not spillover from coding skill. The company acknowledges that the same capabilities serve attackers, and that is the reason to keep the weights closed.

How much does a task cost on SWE-2 Flash? Cognition publishes a relative price, a fifth of SWE-2, and does not publish an absolute figure. Any dollar figure per task was calculated by third parties with their own assumptions about token consumption.

Until when is access free? Through November 30, 2026, in Devin Desktop and the CLI. The announcement does not say what happens afterward: it does not state whether access continues, nor what price will be charged from December 1.

References and Further Reading

The primary source for this analysis is the Cognition announcement, Introducing SWE-2 Flash, published on November 4, 2026. Every benchmark, relative price and speed number comes from it. Read on November 6, 2026. The links below address the same question at different scales.

For recalculating cost per task with more than one model, Multi-model orchestration in practice: 2 index points less for half the cost per task takes the same question at another scale.

For the quality-price trade-off when the index difference is small, A model 11 points smarter for the same cost per task: how to recalculate the trade-off in the router is the reading that precedes this one.

Next step: review the routing policy in Nexforce Router

SWE-2 Flash does not ask for a vendor change. It asks for a new line in the routing policy: which task layer goes to the cheap model, which stays on the expensive one, and which metric authorizes the move from one to the other.

In Nexforce Router, policy is where that decision becomes execution, with an OpenAI-compatible API, model selection by cost, performance, latency and context, a spend limit per key and failover between providers. The 56% gain in the index only exists if the rule is written and spend is capped per key, because a model five times cheaper with five times the volume returns the bill to where it started.

A routing policy, in practice, is a decision table: task type on the input, model on the output, attempt limit per call and spend cap per key. The attempt limit is the field almost nobody writes.

The review has a deadline. Run the layer measurement before November 30, 2026, with free access in effect, and write the rule with the number in hand. After that date, every test costs full price, and the 100 to 44 window becomes a historical reference, not a projection.