Capability Has Converged. So Cognition Put Price Inside the Training Loop.

Yesterday Cognition released SWE-2, and the announcement is worth your attention for a reason that has very little to do with the leaderboard screenshot at the top of their post. Yes, SWE-2 scores 50.0% on FrontierCode 1.1 Main — within a single point of Fable 5.1 while being 64% cheaper, and within a few points of GPT-6 Astra at roughly a quarter of the cost. Those are good numbers. But every serious coding model now posts good numbers, and that is precisely the point. When capability converges, the interesting competition moves to the other axis of the chart: what a point of benchmark performance costs you. Cognition's real announcement is that they've stopped treating cost as a deployment decision and started treating it as a training objective.

That distinction is the whole story, and it's the part most coverage will skip on the way to the benchmarks.

The convergence nobody markets

Look at the benchmark table Cognition published. On FrontierCode 1.1 Main, the spread between SWE-2 (50.0%), Fable 5.1 (50.9%), and GPT-6 Astra (53.3%) is about three points. On DeepSWE 1.1, SWE-2 at 73.0% actually edges past GPT-5.6 Sol and sits two points from Astra. On Terminal-Bench 2.1, SWE-2 leads the entire table at 92.8%.

This is what maturity looks like in a model category: the headline numbers compress into a band that no longer tells you which model to buy. We saw the same thing happen in general-purpose chat models eighteen months ago, and the consequence was identical — vendors started competing on price, speed, and context length because the benchmark top-10 had stopped being a differentiation strategy.

But there's a second table hiding in plain sight, and Cognition deserves credit for publishing it. On Terminal-Bench 4, SWE-2 scores 27.3% while Fable 5.1 scores 55.8% and GPT-6 Astra scores 57.9%. That is not a compressed band; that is a chasm. Long-horizon terminal work — the kind where an agent has to hold a plan together across dozens of shell interactions — is where the frontier actually still lives. The company shipping the model put a benchmark in their own launch post where they lose by thirty points. I can't remember the last time a frontier lab did that voluntarily.

The practical lesson for anyone choosing a coding model this month: headline scores are now marketing instruments. Match the benchmark to your workload. If your agents mostly do scoped repository edits — fix this bug, add this feature, refactor this module — the mid-tier models are interchangeable and the cheapest one wins. If your agents live in the terminal for forty steps at a time, the expensive models are still expensive for a reason.

The clever part: cost as a first-class training signal

Here is what I actually want you to take away from the SWE-2 post. Most post-training recipes handle the cost-performance tradeoff after training: you train the smartest model you can, then you offer the user reasoning-effort settings — low, medium, high — and hope the dial does something sensible. Kimi's own K3 recipe, which Cognition builds on, trains separate experts per effort level and consolidates them afterward. It works, but it's cumbersome and it treats cost as a knob bolted onto a finished model.

Cognition instead trains all effort levels in a single RL run using a reward function that is almost embarrassingly simple: reward equals success minus a cost penalty, where the penalty is linear in the rollout's dollar cost and time, and its coefficient is tuned per effort level to match the local slope of the base model's cost-performance curve.

Two things about this are genuinely elegant. First, the linearity isn't a convenience — it's derived. In the post's appendix they prove that a linear penalty is the only form that composes correctly with averaging over tasks: any nonlinear penalty would reward different behavior depending on whether you computed it per-rollout or over a batch, which would make the objective inconsistent with where the model actually lands on the cost-performance plane. Most hyperparameters in RL reward shaping are folklore. This one is geometry. Second, the per-effort-level coefficients aren't grid-searched; they're read off the tangent of the Pareto curve of the base model at each effort level. The training objective is literally pointing at the frontier you want to push.

And it demonstrably moved the model, not just the pricing page. Against their own SWE-1.7, SWE-2 at medium effort takes 58% fewer turns and costs 81% less on FrontierCode while scoring higher. Median steps before the first real code edit fell from 48 to 18 — not because the model got faster at typing, but because a smarter model wastes less exploration on codebase regions that don't matter. Efficiency and intelligence turned out to be the same optimization.

If you build anything with LLMs, steal this idea. Cost-aware fine-tuning — putting the dollar cost of a rollout into the reward — is applicable to any domain where agents have effort dials, and it's now been demonstrated at the multi-trillion-parameter scale.

What "smarter" actually looked like

The behavioral notes in the post are as telling as the scores, because they describe where the efficiency came from. SWE-1.7 was, by Cognition's own admission, an overthinker: it explored exhaustively before touching anything, which boosted benchmark scores and annoyed real users on simple tasks. SWE-2's largest gains come from focused exploration — the model is now good enough to judge which corners of the codebase a task actually depends on, so it starts editing sooner. Intelligence, it turns out, buys restraint.

Three other patterns they report from internal testing are worth flagging because they're the qualities that make an agent trustworthy rather than merely capable. SWE-2 writes tests that check an implementation end-to-end instead of confirming it superficially. When challenged, it re-derives conclusions rather than re-asserting them, and it runs the artifact to gather evidence instead of trusting prose. And when the obvious path is blocked, it looks for a legitimate route within its existing permissions — in one example, a missing MCP integration led it to reconstruct the data it needed from Slack channel history it already had access to.

None of these show up in a headline score. All of them show up in whether you can leave the agent unsupervised for twenty minutes. When you evaluate coding models, these are the axes to probe: does it verify before claiming, does it stay inside its lanes when blocked, does it test what it built? A model that's two points lower on FrontierCode but re-derives instead of re-asserting is the better colleague.

The app layer is eating the model layer

One more thing worth saying out loud, because SWE-2 is a data point in a trend that's accelerating. Cognition did not pretrain a foundation model. They took Kimi K3 — an open-weights 2.8-trillion-parameter model that had already been RL-trained for agentic coding — and spent their budget on domain-specific post-training, tripling their RL environments and building a flywheel where previous SWE-2 checkpoints harden the verifiers for the next round. They added five to six points on several benchmarks on top of a model they got for free.

This is the vertical-integration playbook for the agent era: the company that owns the application owns the trajectories, the company that owns the trajectories owns the RL data, and open weights mean the application company no longer needs a pretraining cluster to convert that data into a differentiated model. The frontier labs' moat is increasingly the segment of the benchmark table where they still win by thirty points — and the segments where they win by one point are being commoditized by companies they don't control.

The market has noticed. This week Cognition also raised funding at a reported $48 billion valuation, up from $10.4 billion a year ago. Whatever you think of the number, the direction is clear: the value is pooling around whoever can ship frontier-adjacent capability at a fraction of frontier prices.

What to actually do with this

SWE-2 is available now in Devin Desktop and Devin CLI, rolling out to Devin Web and Fusion. If you're evaluating coding agents, the decision tree this week looks like:

For scoped repo work — bug fixes, features, refactors — price the mid-tier seriously. A three-point benchmark gap that costs 4x is not a tradeoff; it's a rounding error with a subscription fee attached. Watch whether your vendor's "cheap" effort setting was trained as a first-class model or bolted on afterward. Cognition's single-run, all-effort-levels training means the medium setting isn't a crippled version of high — it's a differently-optimized point on the same frontier, which is why it can win on cost with almost no capability loss on simple tasks. With bolted-on dials, cheap usually means broken.

For long-horizon terminal workloads, hold your skepticism. Terminal-Bench 4 says the cheap frontier-adjacent models aren't there yet. Run your own eval on your own repo before switching — the benchmarks that matter are the ones shaped like your Tuesday.

And if you're building agents rather than buying them, the exportable insight from SWE-2 isn't the model — it's the objective. Cost went from a deployment concern to a training concern, and the teams that internalize that will ship agents that are simultaneously smarter and cheaper, while everyone else optimizes a dial that was never in the gradient.

The frontier moved this week. Sideways, onto the price axis — and that's where it'll be decided.