Markdown version of this page

We raced Corti S1 against OpenAI’s GPT-6.2 Sol and Astra on six real bugs

We raced Corti S1 against OpenAI’s GPT-6.2 Sol and Astra on six real bugs

OpenAI released GPT-6.2 Sol and GPT-6.2 Astra on November 17, 2026. The next day we put Corti S1 against both on the six real bugs from our race against GPT-6.1 Sol, one attempt each, with each project’s own tests as the judge. S1 fixed all six and finished the set in 11:43, against 14:00 for GPT-6.2 Sol and 13:15 for GPT-6.2 Astra. It cost $0.77, against $0.97 and $2.88 at list prices.

It was a closer race than the first one. S1 won five rounds against GPT-6.2 Sol and four against GPT-6.2 Astra (four outright, counting all three), and was 1.2× and 1.1× faster overall, down from 1.8× against GPT-6.1 Sol. The pattern held, though: S1 starts editing sooner and spends less time reading and planning, 4:08 against 7:05 and 5:23.

Each race below replays the real run, sped up so a round takes about 15 seconds. The bar under each clock fills as time passes. We sorted every step by what it did: reading and planning, editing (green), testing, or finding the right Python install (hatched). The setup and rules are in How we ran it, after the six rounds.

Round 1, Matplotlib

Make histograms keep their set range in density mode.
View on GitHub

Matplotlib: Make histograms keep their set range in density mode. Corti S1 finished in 1:19, GPT-6.2 Sol finished in 1:29, GPT-6.2 Astra finished in 1:51, so Corti S1 won.

Playback at 7× speed.

The green on each bar marks the moments a model edits code. S1 makes its first change at 0:19. GPT-6.2 Sol’s first edit comes at 0:55 and GPT-6.2 Astra’s at 1:25.

Round 2, Pylint

Stop the code checker removing the wrong import path.
View on GitHub

Pylint: Stop the code checker removing the wrong import path. Corti S1 finished in 4:00, GPT-6.2 Sol finished in 4:18, GPT-6.2 Astra finished in 3:32, so GPT-6.2 Astra won.

Playback at 17× speed.

GPT-6.2 Astra wins this one by 28 seconds. S1 is editing at 0:53, more than a minute before either GPT-6.2 model (2:19 and 2:28). Then it spends 1:36 testing, its longest stretch of testing in any round, and about 10 seconds on a changelog entry the tests don’t read. It still beats GPT-6.2 Sol by 18 seconds.

Round 3, scikit-learn

Make a clustering model's two ways of predicting agree.
View on GitHub

scikit-learn: Make a clustering model's two ways of predicting agree. Corti S1 finished in 1:55, GPT-6.2 Sol finished in 2:41, GPT-6.2 Astra finished in 2:53, so Corti S1 won.

Playback at 12× speed.

This is the round S1 lost to GPT-6.1 Sol in the first race. This time S1 is editing at 0:22, and both GPT-6.2 models wait past two minutes, until 2:08 and 2:09.

Round 4, Django

Fix a crash showing 'time since' with time zones on.
View on GitHub

Django: Fix a crash showing 'time since' with time zones on. Corti S1 finished in 2:00, GPT-6.2 Sol finished in 1:28, GPT-6.2 Astra finished in 1:59, so GPT-6.2 Sol won.

Playback at 8× speed.

This is the only round S1 finishes last. It edits first again, at 0:39, then runs the Django tests 16 times, taking 30 steps where GPT-6.2 Sol takes 13. GPT-6.2 Sol finishes 32 seconds ahead.

GPT-6.2 Astra beats S1 to second place by less than a second, 1:59.5 against 2:00.4, so both clocks round to 2:00 in the table below.

Round 5, Flask

Refuse a blueprint that has an empty name.
View on GitHub

Flask: Refuse a blueprint that has an empty name. Corti S1 finished in 0:59, GPT-6.2 Sol finished in 2:06, GPT-6.2 Astra finished in 1:23, so Corti S1 won.

Playback at 8× speed.

S1’s widest win over GPT-6.2 Sol, 1:00 against 2:06. GPT-6.2 Sol keeps a to-do list and updates it four times in this round. Across the six it updates the list 23 times, GPT-6.2 Astra six times, and S1 never uses one.

Round 6, Django

Reject the wrong kind of value in a decimal field cleanly.
View on GitHub

Django: Reject the wrong kind of value in a decimal field cleanly. Corti S1 finished in 1:27, GPT-6.2 Sol finished in 1:56 with a fix that failed the tests, GPT-6.2 Astra finished in 1:33, so Corti S1 won.

Playback at 8× speed.

GPT-6.2 Sol finishes at 1:56, but its fix doesn’t pass the project’s tests, so this round goes to S1 whichever clock you read.

Against GPT-6.2 Astra it is S1’s closest win, 1:28 against 1:34.

All six rounds

RoundBugCorti S1GPT-6.2 SolGPT-6.2 Astra
1Matplotlib: Make histograms keep their set range in density mode1:201:301:52
2Pylint: Stop the code checker removing the wrong import path4:004:183:32
3scikit-learn: Make a clustering model's two ways of predicting agree1:552:412:54
4Django: Fix a crash showing 'time since' with time zones on2:001:292:00
5Flask: Refuse a blueprint that has an empty name1:002:061:23
6Django: Reject the wrong kind of value in a decimal field cleanly1:281:56 (failed)1:34
Total11:4314:0013:15

The totals include GPT-6.2 Sol’s failed attempt. S1 took the most steps, 122 against 100 and 71, and the most time testing, 4:47 against 3:53 and 3:20, and still finished the set 2:17 ahead of GPT-6.2 Sol and 1:32 ahead of GPT-6.2 Astra.

Cost is where the two GPT-6.2 models part ways. GPT-6.2 Sol cost $0.97 for the six, close to S1’s $0.77. GPT-6.2 Astra cost $2.88, 3.7× as much as S1, while writing the fewest output tokens of the three: 23,080, against 29,626 for S1 and 29,100 for GPT-6.2 Sol.

Cost is each attempt’s tokens at list prices. S1’s are on the Corti Models page.

How we ran it

S1 is the model family in Corti Models, which runs open-weight models on sovereign infrastructure through an OpenAI-compatible API (see how Corti Models works).

The bugs are the same six as last time, real issues from open source projects taken from SWE-bench Verified: Matplotlib, Pylint, scikit-learn, Django (twice), and Flask. All three models worked as coding agents in the OpenCode harness, the program that gives a model tools to read files, run commands, and edit code. Effort was set to max for all three, and each worked on a prepared checkout of the project. Every number here comes from each model’s first attempt at each task, run on November 18 and 19, 2026.

S1 ran each task once, and each race above puts that attempt beside both GPT-6.2 models. The project’s own tests decide what counts, and the first fix that passes them wins the round. All but one of the 18 attempts passed; the exception is GPT-6.2 Sol in round 6. The clock starts when a model picks up the task and stops at its final message, so it includes reading, thinking, running commands, and waiting for them to finish.

What this doesn’t show

Six tasks with one attempt each is a small sample, and one attempt is one draw from a model’s range. Run it again and the times will move. Because both comparisons share one S1 run, a slow S1 attempt counts against it twice. It also tests one kind of work, fixing a bug in a project the model can read and test, with one harness at one effort setting.

The split between reading, editing, and testing is our own sorting of each step by what it did, so read those times as approximate.

For measured results across larger test sets, including clinical ones, see our benchmarks.

To try S1 on your own bugs, start in the Corti Console with free credits and keep the coding agent you already use.