Cognition's SWE-2 Pushes the Coding-Agent Pareto Frontier: Frontier-Class Scores at 64% Less Cost

On September 10, 2026, Cognition introduced SWE-2 and framed it around moving the Pareto frontier: not just a higher score, but the whole capability-versus-cost curve shifting at once. The headline numbers are blunt: 50.0% on FrontierCode 1.1 Main, within one point of Claude Fable 5.1, while costing 64% less. For teams staring at agent bills every morning, the story is not that single point of difference. It is that near-frontier quality now comes at a fraction of the price, and that sets a new price-performance baseline the rest of the market will be judged against.

1. What SWE-2 Actually Shipped

SWE-2 is Cognition's most advanced coding model yet. The company says it scaled reinforcement learning to the multi-trillion-parameter regime for the first time, building on the SWE-1.7 training infrastructure and recipe. The key addition is an RL algorithm that trains all reasoning-effort levels in a single run, so the entire cost-performance frontier advances together instead of one point at a time. On FrontierCode 1.1 Main and DeepSWE 1.1, it beats both SWE-1.7 and Grok 4.6 on score and cost, matches GPT-5.6 Sol and Fable 5/5.1 at a fraction of their price, and comes within a few points of GPT-6 Astra at a quarter of the cost. SWE-2 is available today in Devin Desktop and CLI, rolling out to Devin Web and Fusion.

# Route each task to the cheapest effort level that clears the bar.
EFFORT_COST = {"low": 0.4, "medium": 1.0, "high": 2.3, "xhigh": 4.8}

def pick_effort(task, success_curve):
    for level in ("low", "medium", "high", "xhigh"):
        if success_curve[level] >= task["min_pass_rate"]:
            return level, EFFORT_COST[level]
    return "xhigh", EFFORT_COST["xhigh"]

task = {"min_pass_rate": 0.80}
curve = {"low": 0.42, "medium": 0.81, "high": 0.93, "xhigh": 0.96}
print(pick_effort(task, curve))   # ('medium', 1.0)

2. Cost Penalties: Putting Spend Directly Into the Training Objective

The most interesting technical detail is how SWE-2 turns cost into a training signal. The team applies a linear cost penalty per effort level, each tuned to the local slope of the base model's Pareto frontier. The goal is to advance the model's entire frontier while preserving its shape, and to reflect actual user costs in training as directly as possible. In other words, the model is rewarded not only for getting the answer right, but for getting it right cheaply. Paired with the length-weighted reward baseline used since SWE-1.6 to stabilize training, this combination keeps RL tractable at multi-trillion-parameter scale. That is the defining move of 2026 agent RL: turn business cost into part of the gradient.

# Compare models on cost per RESOLVED task, not cost per token.
def cost_per_resolved(score, avg_cost):
    if score <= 0:
        return float("inf")
    return avg_cost / score

models = {
    "swe-2-medium": {"score": 0.50, "avg_cost": 0.36},
    "fable-5.1":    {"score": 0.51, "avg_cost": 1.00},
}
for name, m in models.items():
    print(name, round(cost_per_resolved(m["score"], m["avg_cost"]), 3))

3. Post-Trained From Kimi K3: Even an Open-Weight Model Still Has Headroom

SWE-2 is post-trained from Kimi K3, a 2.8T-parameter model that had already undergone extensive RL for agentic coding. Cognition says its RL still finds substantial headroom even on a heavily reinforced base, adding 5 to 6 points on many benchmarks and shifting K3's entire cost-performance frontier. To support that scale, the team improved RL rollout serving, trained an online draft model to raise decoding throughput, and used NVFP4/FP8 kernels with quantization-aware training to cut memory use, achieving lower train-inference mismatch than SWE-1.7 at similar throughput despite a base model with almost three times the parameters. On data, they tripled RL environments, added instruction-following overlays, and built a flywheel from prior SWE-2 checkpoints to iteratively harden their verifiers.

# Cap agent turns; SWE-2 medium reaches its first real edit at ~18 steps,
# versus a median of 48 steps for SWE-1.7 on the same benchmark.
def run_with_budget(agent, task, max_turns=25):
    for turn in range(1, max_turns + 1):
        step = agent.next(task)
        if step["type"] == "edit":
            return {"status": "edited", "turn": turn, "patch": step["patch"]}
    return {"status": "budget_exceeded", "turn": max_turns}

4. Behavioral Differences: Smarter Means Fewer Detours

SWE-2's efficiency gains and intelligence gains are tightly connected. Stronger engineering judgment lets the agent write more complete solutions while taking fewer detours and doing fewer redundant reads. Three observed behaviors matter. First, better test coverage: SWE-2 writes tests that check an implementation end-to-end, catching regressions and edge cases more reliably. Second, resourcefulness within the user's boundaries: when the obvious path is blocked, it looks for another route to the same answer; in one case, an MCP integration it needed was unavailable, so it reconstructed the data from Slack channel history it already had access to. Third, verification discipline: when challenged, it re-derives conclusions rather than re-asserting them, verifies hypotheses instead of agreeing, and runs artifacts to gather evidence. Those traits decide whether you can trust its output.

5. The Efficiency Math: 58% Fewer Turns, 81% Less Cost

The number coding teams should remember comes from FrontierCode 1.1 Main: SWE-2's medium effort level scores higher than SWE-1.7 while taking, on average, 58% fewer turns and costing 81% less. Concretely, SWE-2 medium makes its first real edit after a median of 18 steps versus 48 for SWE-1.7. The largest efficiency gains, the team says, come from focused exploration: higher intelligence lets the model judge which parts of the codebase actually matter, so it can begin implementation sooner. Effort levels also behave genuinely differently, with medium stepping into action much more quickly, which is especially valuable on simple tasks. Choosing an effort level per task is therefore no longer just a cost trick; it is a knob for quality and latency.

# Require re-derivation, not agreement, before accepting a claim.
def verification_gate(claim, evidence):
    required = ["ran_artifact", "reproduced_bug", "checked_edge_cases"]
    missing = [r for r in required if not evidence.get(r)]
    return {"claim": claim, "accept": not missing, "missing": missing}

ev = {"ran_artifact": True, "reproduced_bug": True, "checked_edge_cases": False}
print(verification_gate("fix resolves the regression", ev))

6. What To Do: Write the New Frontier Into Your Routing

Facing yet another cheaper, near-frontier model, the right move is not a blind switch but an update to routing and evaluation. Three steps. First, make cost per resolved task, not cost per token, your primary metric, or you will never see real value. Second, build effort-level routing and turn budgets per task difficulty, letting medium handle most PR-sized work and reserving higher tiers for hard refactors. Third, run regression evals on your own repository and historical tasks before shifting traffic, because public benchmarks differ from your languages, frameworks, and test density. Make the evaluation harness hold up: diff agent patches with the Text Diff Checker, validate run reports with JSON Formatter, and probe your eval service calls with API Tester. Turn cheap into real defense in depth, not another end-of-month invoice shock.

# Quantify the efficiency win from fewer turns and cheaper effort.
def savings(old, new):
    turn_cut = 1 - new["turns"] / old["turns"]
    cost_cut = 1 - new["cost"] / old["cost"]
    return {"fewer_turns_pct": round(turn_cut * 100),
            "cheaper_pct": round(cost_cut * 100)}

old = {"turns": 100, "cost": 1.00}
new = {"turns": 42,  "cost": 0.19}
print(savings(old, new))   # 58% fewer turns, 81% cheaper