Cognition's SWE-1.7 Matches GPT-5.5 on Coding Tasks at $1.97 Each

Cognition just released SWE-1.7, the most capable model in their SWE series and the engine now running inside Devin. The headline is striking: a model that scores within a few points of Claude Opus 4.8 and GPT-5.5 on agentic coding benchmarks, at a cost of $1.97 per task, running at 1000 tokens per second. That combination , frontier-adjacent quality, fraction of the cost, and blazing inference speed , is what makes this release worth paying attention to.

The benchmark that actually matters

To understand SWE-1.7's performance, you first need to understand FrontierCode, Cognition's proprietary evaluation benchmark. Unlike SWE-bench, which asks whether a model can pass unit tests, FrontierCode asks a harder question: would a real maintainer merge this PR?

FrontierCode evaluates whether coding agents produce mergeable, production-quality pull requests, scoring correctness, tests, scope, style, and maintainability through maintainer-authored rubrics. Tasks were built with open-source maintainers, with each taking 40+ hours and evaluated on dimensions like regression safety, cleanliness, scope, test correctness, and maintainability.

On FrontierCode 1.1 Main, here's how the models stack up:

That jump from SWE-1.6's 9.4% to SWE-1.7's 42.3% on FrontierCode is not a rounding error. It reflects a fundamentally different training run , and a model that behaves differently in practice.

What it's actually good at , and where it falls short

SWE-1.7 was specifically optimized for long-horizon, asynchronous software engineering tasks. The model is particularly optimized for longer-horizon asynchronous tasks, an important component of high-quality software engineering. In practice, this shows up most clearly in bug investigation: SWE-1.7 is much more likely to investigate the root cause of a bug and consider edge cases, hypotheticals, adversarial inputs, and beyond-the-ask requirements than Kimi K2.7-Code.

The tradeoff is scope. The extra thinking comes at a small cost in increased change scope , since SWE-1.7 reasons more, it also does more: writing additional test cases and touching more files than the task naively requires. Cognition acknowledges this is a known pattern across the industry: more reasoning tends to mean wider blast radius. It's an axis they say they're actively working to improve.

Practical use cases where SWE-1.7 shines:

• Deep bug investigation , it probes root causes rather than patching symptoms
• Multi-file refactors , long-horizon tasks that run for hours without human intervention
• Ambiguous requirements , it writes small probe scripts to settle semantics rather than guessing
• Security remediation , well-defined vulnerability patterns with clear fix criteria

The real breakthrough: RL at scale, across continents

The most technically interesting part of this release is not the benchmark numbers , it's how the model was trained. SWE-1.7 is the result of broad improvements across the RL pipeline: better infrastructure, more stable training, higher-quality data, and new techniques for long-horizon tasks.

Since SWE-1.7 was trained from a Kimi K2.7 base, which had already undergone extensive RL post-training, the large additional gains from Cognition's own training challenge the idea of a 'post-training ceiling' and suggest that RL can push capabilities much further than previously believed. That's the real claim here: you can keep stacking RL on top of a model that has already been RL-trained, and it still improves substantially.

Two well-known problems plague long RL runs:

• Entropy collapse , the model stops exploring, always picks the same tokens, and stops improving
• Numerical drift , the model doing inference and the model being trained gradually diverge, causing instability

Cognition's recipe addresses both. The key insight on entropy: top-p sampling (which cuts off very low-probability tokens before sampling) contributes significantly to staving off entropy collapse, where a strong model stops exploring and reward plateaus within a few hundred steps. But naive top-p creates a new problem , it widens the gap between what the inference engine samples and what the trainer expects. Their fix is sampling distribution replay: they record exactly which tokens were in the kept-set during rollout, then replay those masks in the trainer so both sides agree on the probability distribution. With this fix, the run's entropy stays roughly constant over the course of training and inference-training divergence stays bounded.

The full recipe also includes:

• The Muon optimizer , an alternative to Adam that improves training stability
• Importance sampling and off-policy correction , adjustments that let the trainer learn from slightly stale rollouts without introducing bias
• MoE routing replay , replaying the expert-routing decisions made at inference time so the trainer sees the same computation graph
• Quantization-aware training , training in low precision (NVFP4) to match the precision used at inference, eliminating a major source of numerical drift

Training across four datacenters on three continents

The infrastructure story is equally novel. Most large training runs require a single massive cluster with tight interconnects. Cognition couldn't access one, so they built around that constraint. Their RL training spans four datacenters across three continents, combining their own GPUs across multiple clusters with additional compute from inference providers like Fireworks. The result is that they can scale RL training far beyond what any single cluster would allow.

The key insight that makes this possible: RL decomposes naturally across multiple clusters. Only the trainer must live on a single high-bandwidth cluster. The inference engines that generate rollouts are self-contained , they can run anywhere and need nothing but the current weights.

Keeping weights synchronized across continents without stalling training required a clever compression scheme. Every K gradient steps, they compute and send a compressed weight delta between the current and previous weights, reducing the size of each transfer by over 99%. Cross-continental weight updates for a 1T parameter model complete in 1–2 minutes end-to-end, blocking neither training nor inference beyond 3–4 seconds of inference pause at update.

Teaching the model to compress its own memory

Long-horizon tasks hit a hard wall: the model's context window. Cognition's solution is self-compaction , training the model to summarize its own working state and resume from that summary when it approaches the context limit. The model simultaneously learns to write more informative, succinct summaries, and to better work from and leverage such summaries. With self-compaction, rollouts during the SWE-1.7 training run reach up to six hours in duration.

They also address the well-known problem of RL making models verbose. Rather than a constant length penalty, they use an alternating strategy: in unconstrained phases, the model optimizes only for task success; in budget phases, they penalize solutions that exceed a certain budget of a weighted cost function that includes tokens, turns, and total time spent in tool calls. With this structure, response length tends to compress on tasks within the model's ability, while long-horizon behavior on hard tasks is preserved.

What this means for the field

A few assumptions need updating after this release:

• Post-training ceilings are not fixed. Kimi K2.7 had already been heavily RL-trained. Cognition added another large RL run on top and got substantial gains. The ceiling is higher than the field assumed.
• You don't need one giant cluster. Distributed RL across heterogeneous, geographically dispersed compute is viable at 1T-parameter scale , if you engineer the weight-sync and fault-tolerance carefully.
• Benchmark quality matters as much as model quality. FrontierCode's framing , pushing the conversation from 'the agent completed the prompt' to 'the code is mergeable' , is a meaningful shift in how the industry should evaluate coding agents.

SWE-1.7 is available today in Devin across Web, Desktop, and CLI, running at 1000 tokens per second via Cerebras. At $1.97 per task on the FrontierCode Main set, it sits in a different cost bracket than Claude Opus 4.8 , which scores about four points higher but at significantly greater expense. For teams running Devin at scale, that cost gap compounds fast.