What Is DeepSWE? The RL Coding Agent and the Benchmark

"DeepSWE" is one of the most confusing names in AI coding evaluation, because it refers to two unrelated projects. One is a fully open-source coding agent trained from scratch with reinforcement learning; the other is a separate benchmark that measures how well frontier coding agents handle original, long-horizon software tasks. This post explains both — and makes clear which one you are looking at when you see a "DeepSWE v1.1" score.

In our live benchmark comparison, the DeepSWE v1.1 row is the benchmark (from Datacurve). For a refresher on how coding evals work in general, start with the complete guide to LLM benchmarks.

Two projects, one name

The key takeaway: any reference to a "DeepSWE v1.1" score — including the number reported for frontier models like GPT-5.6 Sol — points to the Datacurve benchmark, not the Agentica model, which never had a "v1.1."

The DeepSWE benchmark (Datacurve)

The DeepSWE benchmark measures coding agents on 113 original tasks spanning TypeScript, Go, Python, JavaScript, and Rust, drawn from dozens of repositories. Its defining design goal is contamination resistance: because every task is written from scratch rather than scraped from public GitHub issues, models cannot have memorized the answers during pre-training. That directly targets the biggest weakness of older evals — see our explainer on benchmark contamination.

Each task runs in an isolated environment and is graded by hand-written, program-based verifiers that check behavior rather than matching a reference diff. Datacurve reports very low error rates for this grading (well under 2% false positives and false negatives). The v1.1 revision moved grading into a separate, sandboxed verifier environment for stronger isolation, which is why you will see v1 and v1.1 numbers quoted distinctly. You can browse current results on the DeepSWE benchmark page.

Conceptually it sits alongside SWE-bench and Terminal-Bench as an agentic, execution-graded coding eval — but with fresh, multi-language tasks meant to stay meaningful as models improve.

DeepSWE-Preview (the model): RL from scratch

The original DeepSWE — DeepSWE-Preview — is a 32B coding agent trained on top of Qwen3-32B using only reinforcement learning, with no supervised fine-tuning or distillation from a stronger teacher. Agentica and Together AI open-sourced everything under an MIT license: the weights, the 4,500-task training dataset, the training code (their rLLM framework, built on Verl), and the training and evaluation logs. It was trained across roughly six days on 64 H100 GPUs.

On SWE-bench Verified, DeepSWE-Preview posts these numbers:

The authors call this state of the art for open-weight coding agents — but note the scope: the "#1 open-weights" claim applies to the 59% test-time-scaling result. On raw single-attempt Pass@1 (42.2%), DeepSWE-Preview is only "one of the best"; a couple of other open models score higher single-shot. That distinction matters when you compare it against the frontier models in our best LLM for coding roundup.

How the RL training actually works

DeepSWE-Preview uses GRPO++, a hardened variant of Group Relative Policy Optimization adapted for multi-step agents. During training the agent works inside a wrapper around R2E-Gym, an environment of executable software tasks, using four tools: run bash, search, edit files, and finish/submit. The reward is deliberately sparse and binary: the agent earns 1 only if its submitted patch passes the selected tests within a time limit, and 0 otherwise. There is no partial credit.

GRPO++ layers several stabilizing tweaks borrowed from DAPO, Dr. GRPO, and RLOO, plus two of the team's own:

• Clip high & no KL loss — encourages exploration and frees the policy from staying near its starting behavior.
• Length normalization & no reward-standard-deviation — removes GRPO's bias toward padding wrong answers and toward easy problems.
• Leave-one-out advantage — lowers gradient variance without adding bias.
• Compact filtering (their contribution) — masks trajectories that hit the context limit, time out, or run out of steps, so reward is only assigned when the agent deliberately submits. This is the main trick that prevents reward collapse.
• No entropy loss (their contribution) — the usual entropy bonus caused runaway instability, so it was dropped.

A striking result: with just 200 steps of RL, SWE-bench Verified Pass@1 rose from about 23% to 42% — pure reinforcement learning, no imitation of a stronger model.

Test-time scaling: how 42% becomes 59%

The jump from 42.2% to 59% does not come from a bigger model or a longer context (the team found extending output beyond ~32K tokens barely helps). It comes from sampling many trajectories and picking the best one with a hybrid verifier: an execution-based stage generates tests and keeps patches that pass the most, and an execution-free stage (a separately trained "DeepSWE-Verifier" model) ranks the survivors. Most of the gain is already captured at 8 rollouts, so the practical cost is roughly 8–16x the single-attempt inference plus verifier compute — a real trade-off to weigh for production use.

Limitations and things to watch

• The name collision itself. A "DeepSWE v1.1" score is the Datacurve benchmark; "DeepSWE-Preview" is the RL model. They are unrelated.
• SOTA is scoped to test-time scaling. DeepSWE-Preview's headline 59% uses Best@16; its single-shot 42.2% is not the top open-weights number.
• Cost of the 59%. Hybrid scaling multiplies inference cost, so single-attempt numbers are the fairer apples-to-apples comparison against most frontier scores.
• Underlying-benchmark caveats. SWE-bench Verified has known contamination and design concerns — part of why a fresh eval like the DeepSWE benchmark exists in the first place. For the full picture, read the contamination explainer.

Key takeaways

• Two DeepSWEs: an open-source RL coding agent (DeepSWE-Preview, Agentica + Together AI) and a separate contamination-resistant benchmark (Datacurve, with v1/v1.1).
• In our table, the DeepSWE v1.1 row is the Datacurve benchmark — 113 fresh, multi-language, execution-graded tasks.
• The model's story: pure RL on Qwen3-32B, MIT open-source end to end, 42.2% Pass@1 rising to 59% with hybrid test-time scaling.
• Read scores carefully: distinguish single-attempt from test-time-scaled numbers, and the model from the benchmark.
• Compare every model on the DeepSWE benchmark page or the live comparison table.