SWE-2 Flash 2026: The Coding Model Price vs Limits
Cognition launched SWE-2 Flash on November 4, 2026, and the launch numbers read like a straight upgrade: Terminal-Bench 4.0 jumps from 0.9% to 20.0%, FrontierCode 2.0 from 3.2% to 24.0%, at one-fifth the price and three times the speed of SWE-2. That comparison is real, but it is also a comparison against the wrong baseline. The 0.9% belongs to Inkling-Small, the open base model the flash variant was post-trained from, not to SWE-2. Measured against its own sibling on Cognition's own table, SWE-2 Flash scores 20.0 where SWE-2 scores 27.3, and 24.0 where SWE-2 scores 23.8. It wins one, loses four.
The second problem is more awkward for a pricing site. SWE-2 Flash does not appear anywhere in Devin's documentation. Not in the model list, not in the API reference, not in the 3.5 MB full-text dump of the docs. The v3 session API exposes a devin_mode enum containing swe-2-medium, swe-2-high and swe-2-max but no swe-2-flash value. There is no per-token rate to compare, no standalone endpoint to call, and no way to bill it the way you bill everything else in this catalog.
So the honest framing is narrower and more useful than the launch post. SWE-2 Flash is a product-surface release, not an API release. It is a fast, cheap option inside Devin Desktop and Devin CLI, aimed at developers who already pay a Devin subscription and want the mechanical part of a coding task done for less. For anyone choosing a coding model for a per-token API budget, the same benchmark table that made the launch look impressive actually argues for GLM 5.3 Flash or DeepSeek V4.1 Flash instead, and the arithmetic in the cost section below is not close.
What SWE-2 Flash actually is
The model is a post-train of Inkling-Small, a 276B-total, 12B-active mixture-of-experts model from Thinking Machines. The architecture is unchanged: SWE-2 Flash has the same 276B-A12B footprint as its base, and the same 1x size ratio in Cognition's table. Nothing here comes from a bigger network. The gains come entirely from post-training, and specifically from a stage Cognition says it had never run before.
Before reinforcement learning, Cognition ran a large-scale mid-training stage. The dataset is described as a few trillion tokens of scientific articles, blogs, and code, trained in three stages so that the scarcest and highest-quality material lands last. Rather than guessing at data mixes, the team measured them with token-efficiency plots: for each candidate mix, how many tokens were needed to reach the same validation loss as the baseline. That gave a defensible curve to pick the final mixture from. RL followed, with audited instructions, environment setup, and verifiers, plus several new task types aimed at the general reasoning and problem-solving that real work inside Devin demands.
The interesting engineering detail is the ordering. Mid-training before RL is unusual, and Cognition says it paid off: the RL recipe itself was barely changed from SWE-2, so most of the improvement came from the higher quality and diversity of the tasks. For a company that has spent a year shipping the same model architecture at different sizes, this is the first time the recipe itself changed rather than the parameter count.
The benchmark table, read carefully
Cognition published one table with SWE-2 Flash against nine alternatives. Here is every row, verbatim, because the framing changes depending on which column you read:
| Benchmark | SWE-2 Flash | Inkling-Small | Beam 1.0 | Muse Spark Open | GLM 5.3 Flash | DeepSeek V4.1 Flash | GPT-6 Luna | Claude Haiku 5.5 | SWE-2 |
|---|---|---|---|---|---|---|---|---|---|
| FrontierCode 2.0 | 24.0 | 3.2 | 2.9 | 6.2 | 14.2 | 19.3 | 21.9 | 27.7 | 23.8 |
| FrontierCode 1.1 Main | 45.5 | 21.5 | 22.8 | 24.5 | 31.8 | 43.9 | 42.4 | 46.4 | 50.0 |
| DeepSWE 1.1 | 60.1 | 17.4 | 43.3 | 60.0 | 63.4 | 77.0 | 66.6 | 59.3 | 73.0 |
| Terminal-Bench 4.0 | 20.0 | 0.9 | 4.0 | 8.0 | 41.8 | 42.3 | 16.4 | 39.2 | 27.3 |
| Terminal-Bench 2.1 | 89.2 | 64.7 | 80.1 | 76.4 | 84.3 | 91.0 | 82.0 | 94.4 | 92.8 |
| SWE-Atlas QA | 50.0 | 27.4 | 33.9 | 54.0 | 56.5 | 71.0 | 45.2 | 56.5 | 56.3 |
| SWE-Bench Pro v2 Hard | 89.9 | 56.5 | 76.5 | 82.4 | 88.2 | 86.3 | 80.4 | 90.2 | 90.6 |
| ExploitBench | 34.8 | 11.3 | 19.5 | — | 36.0 | 31.1 | 44.7 | 38.0 | 36.1 |
Three readings matter, and they point in different directions.
Against the base model, the jump is enormous. Terminal-Bench 4.0 goes 0.9 to 20.0, FrontierCode 2.0 goes 3.2 to 24.0, and DeepSWE 1.1 goes 17.4 to 60.1. This is the comparison the launch post leads with, and it is a legitimate result: a 276B-A12B model trained for general use can be pushed a long way with the right mid-training mix. But Inkling-Small is not a model anyone was shipping for coding work, so this comparison tells you what post-training did, not what you should buy.
Against its own sibling, the picture is mixed. SWE-2 Flash takes FrontierCode 2.0 at 24.0 to SWE-2's 23.8, and nearly ties it on SWE-Bench Pro v2 Hard (89.9 against 90.6). Everywhere else the 2.8T-A104B flagship is ahead: Terminal-Bench 4.0 at 27.3 against 20.0, DeepSWE 1.1 at 73.0 against 60.1, SWE-Atlas QA at 56.3 against 50.0, Terminal-Bench 2.1 at 92.8 against 89.2. Flash is a cheaper substitute for the mechanical portion of a task, not a stronger model across the board. Cognition's own phrasing is more careful than the headline: Flash outperforms American open-weight models, even models several times larger. Muse Spark Open, at 3x the size, scores 8.0 on Terminal-Bench 4.0 and 6.2 on FrontierCode 2.0, and SWE-2, at 10.1x, scores 27.3. True, and not the same claim as beating the frontier.
Against the models you can actually call per token, it loses badly. Terminal-Bench 4.0 is the row that decides the API question. GLM 5.3 Flash scores 41.8. DeepSeek V4.1 Flash scores 42.3. Claude Haiku 5.5 scores 39.2. SWE-2 Flash scores 20.0. The only column below it is GPT-6 Luna at 16.4. DeepSWE 1.1 repeats the pattern: 60.1 for Flash against 63.4 for GLM 5.3 Flash and 77.0 for DeepSeek V4.1 Flash. Only on FrontierCode 2.0 and SWE-Atlas QA does Flash land in the same band as the cheap open routes. If your workload is terminal work scored on Terminal-Bench, two cheap open-API models outscore it by roughly double, and they come with published per-token prices you can budget against.
The price claim, decoded
Cognition says SWE-2 Flash runs at one-fifth the price of SWE-2. SWE-2's published list price is $3.00 per 1M input tokens, $15.00 per 1M output tokens, and $0.30 per 1M cache-input tokens. One fifth of that is roughly $0.60 input and $3.00 output, which would make SWE-2 Flash a strong number against most of the market. That arithmetic is arithmetic, though, not a published rate. Cognition did not publish a SWE-2 Flash price line, and Devin's own models page, which is the authoritative price list for the platform, has no entry for the model.
Two promotions also blur the comparison in ways a headline number hides. SWE-2 itself is free for self-serve plans in Devin Desktop and Devin CLI through November 30, 2026, and 75% off list price through December 31, 2026, with list pricing applying afterward. SWE-2 Flash carries a free-through-November-30 badge on the launch post. So during the promotional window both models cost the same inside Devin, which is roughly nothing, and the one-fifth gap only becomes a real economic difference once the free period ends and an actual Flash rate exists to compare.
There is also a metering mismatch worth understanding before you model anything. Devin does not sell SWE-2 Flash as raw tokens. Self-serve plans include a usage allowance measured by the work the agent does, with on-demand credits covering everything past it; enterprise contracts meter in Agent Compute Units. The docs are explicit that ACUs convert the tokens consumed by the selected model at that model's per-token rate, so the per-token number still exists underneath the session-based meter, but you are buying sessions, not tokens.
Speed: 200 tok/s against 60 tok/s
Cognition's second headline is that SWE-2 Flash runs three times faster than SWE-2, and the accompanying chart shows 200 tokens per second against 60. The demo replays each model's run on the same Terminal-Bench 4.0 task, the gsea-proteomics environment, at the two simulated rates with transcripts shortened to equal length.
For agentic coding work, generation speed matters in a way it does not for chat. An agent loop is mostly waiting on tokens: plan, edit, run tests, read the failure, edit again. A three-fold increase in tokens per second compresses that wall-clock loop meaningfully, and it is the kind of latency that changes whether a workflow feels interactive or feels like a job you kick off and come back to. Cognition has been aggressive on this axis generally, running SWE-1.7 Lightning on Cerebras hardware for the same reason.
The caveat is that this is a replay on Cognition's chosen task at simulated rates, not a measurement on your repository. Your own wall-clock will be dominated by tool calls, test suites, and context assembly. Speed here means the model is less likely to be the bottleneck in the loop, not that the loop is fast.
How you actually access it
Today, through Devin Desktop and Devin CLI. Cognition's launch post says the model is available in both, and the Devin CLI docs confirm the product surfaces and the model-selection mechanics. Short family names resolve to the latest version, so swe points at the newest SWE release, and you can override it from the command line, a slash command, or the config file.
# Run a session with the SWE family from the terminal
devin --model swe -- "add regression tests for the retry path"
# Switch models mid-session
/model
# Pin a default in the CLI config
cat ~/.config/devin/config.json
# {"agent": {"model": "swe-1-6-fast"}}The session API is the programmatic route, and it is where the gap shows. Creating a session over the v3 API takes a service user key with the UseDevinSessions permission, plus an organization id, and the devin_mode field selects the agent mode:
curl -X POST "https://api.devin.ai/v3/organizations/$DEVIN_ORG_ID/sessions" \
-H "Authorization: Bearer $DEVIN_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt":"Fix the login bug in issue #42","devin_mode":"swe-2-medium"}'The documented devin_mode values are normal, fast, fusion, lite, ultra, swe-2-medium, swe-2-high, and swe-2-max. There is no swe-2-flash. Until Devin adds one, a Flash session is not reachable through the API, and the List Models API that returns your account's prices will not return a Flash row either. The models page lists SWE-2, SWE-1.7, SWE-1.7 Lightning, SWE-1.6, SWE-1.6 Fast, SWE-1-mini, swe-grep, and swe-check, and free-tier users are limited to SWE-1.6.
One thing worth borrowing regardless of Flash: Fusion. Cognition pairs a frontier lead model with a cheaper sidekick that executes the mechanical work, and the default pairing is Claude Opus 5.5 Medium as lead with SWE-2 Medium as sidekick. That is the same architecture idea as SWE-2 Flash, applied to a model you can already reach, and Devin bills each model in the pair at its own rate. Fusion requires a paid plan and is unavailable on free or trial tiers.
Cost math against the models you can actually call
Here is the comparison that should drive the decision, using OpenRouter route prices checked on November 5, 2026, plus SWE-2 list pricing from the Devin models page. The final row is the implied SWE-2 Flash rate from Cognition's one-fifth claim, not a published price.
| Model | Input /1M | Output /1M | Cache in /1M | Cost, 10K in + 40K out |
|---|---|---|---|---|
| DeepSeek V4.1 Flash | $0.045 | $0.50 | $0.018 | $0.021 |
| GPT-6 Luna | $0.10 | $0.50 | $0.01 | $0.021 |
| Claude Haiku 5.5 | $0.10 | $0.50 | $0.01 | $0.021 |
| GLM 5.3 Flash | $0.15 | $0.50 | $0.03 | $0.022 |
| SWE-2 (list) | $3.00 | $15.00 | $0.30 | $0.63 |
| SWE-2 Flash (implied 1/5) | ~$0.60 | ~$3.00 | ~$0.06 | ~$0.126 |
Read the last two rows against the first four. On a single 10K-input, 40K-output turn, the implied SWE-2 Flash rate costs roughly six times DeepSeek V4.1 Flash and about six times Claude Haiku 5.5 or GPT-6 Luna, while scoring less than half of DeepSeek V4.1 Flash on Terminal-Bench 4.0. That combination is hard to defend on a per-token budget.
If you want to test the alternatives side by side on your own prompts rather than trusting a benchmark, FreeModel exposes an OpenAI-compatible endpoint in front of multiple providers, so a single integration can point at different model IDs and measure how each handles the same task. That is the fastest way to settle whether Flash-style routing is worth it for your workload, and it costs nothing to compare before you commit a plan.
The weights question
SWE-2 Flash is not open. Cognition deliberately trained on cyber work, raising the model's ExploitBench score from 11.3% to 34.8%, and says plainly that the weights are not being shared publicly because the same capabilities can be used by attackers. The company is building a program to share the weights securely with trusted industry partners and research labs, with more detail promised a few weeks after the November 4 launch.
This is a defensible position rather than a marketing convenience. A 276B-A12B model with deliberate vulnerability-finding capability is not something you publish to a public repository on launch day, and the partner program is the usual shape for how this gets resolved. But it does mean the deployment options are narrower than for an open-weight model, and it puts a ceiling on how long the pricing discount is likely to last: a weights-sharing program that brings more inference providers into the market eventually competes with Cognition's own hosted rate. If you are planning around the one-fifth price, plan for it to compress rather than persist.
Who should use it, and who should not
Use SWE-2 Flash if you already pay for Devin and want cheap, fast execution of the mechanical part of a coding task inside Desktop or CLI. The three-fold speed increase is real for reducing loop latency, the model is free through November 30, and it comfortably handles automations, code review passes, feature work, and documentation updates, which is exactly where Cognition says the smaller-model tier should be aimed.
Skip it if you are picking a model for an API budget. Two cheap open routes outscore it by roughly double on Terminal-Bench 4.0 and DeepSWE 1.1 while costing about a sixth of the implied Flash rate, there is no published Flash price to plan against, and there is no API mode to call it from. If you need weights you can host and audit, they are not available today.
Wait on it if you build agent infrastructure on Devin and want Flash in your pipeline. Cognition has clearly committed to the model, and the Devin CLI is where models ship first, but the API surface is the part that matters for programmatic use and it has not caught up. Watch for two signals: a Flash entry on the Devin models page, and a swe-2-flash value in the devin_mode enum. When both land, the pricing question becomes answerable with real numbers instead of a ratio.
The verdict is that SWE-2 Flash is a good product decision and a weak API decision. Cognition built something genuinely difficult, a mid-training stage that moves a small model into usable coding territory, and shipped it into the surfaces where they control the experience. Whether it is the right model for your stack is a budget question, and on today's published numbers the answer for most API-driven teams is no.
Sources: Cognition, "Introducing SWE-2 Flash" (Nov 4, 2026); Cognition, "Introducing SWE-2: Pushing the Pareto Frontier" (Sept 10, 2026); Devin Docs, AI Models, Models in Devin CLI, Self-serve plans, Usage, Fusion, Create Session, List Models API (all verified Nov 5, 2026); devin.ai/pricing (verified Nov 5, 2026); OpenRouter model catalog (verified Nov 5, 2026).