Benchmarks

We gave both agents the same ten bugs.

Real bugs from django, taken from SWE-bench Lite. Same model on both sides, same instructions, same code, no internet. A grader nobody controls decides whether the fix worked. Below is what happened, including the three we did not fix.

SWE-bench Lite, django subsetClaude Sonnet 510 bugsNo internetOfficial grader
Fewer tokens64%94k against 265k on a typical issue
Lower cost38%$0.0648 against $0.1039 on a typical issue
Cheaper worst case3.1xOur dearest issue $0.1348, theirs $0.4163
Bugs fixed7 vs 8Too close to call at ten issues. We explain why below.

Did it actually fix the bug?

Each square is one bug. Filled means the fix passed the project's own tests, checked by the official grader. Superbrain fixed 7, Claude Code fixed 8. One of those is a coin flip, not a gap, and we show the working further down.

Superbrain7 of 10 fixed
Claude Code8 of 10 fixed

What each fix cost

The seven bugs both agents fixed. Same bug, same model, so the difference is how much context each one moved to get there. Superbrain was cheaper on six of seven.

SuperbrainClaude Code
Uploaded files got inconsistent permissions6.4x cheaper
$0.0648
$0.4163
Multi line SQL broke query ordering1.3x pricier
$0.1311
$0.1039
Migration output wrapped in a transaction it should not have1.3x cheaper
$0.0573
$0.0730
A duration field printed the wrong format in its error1.6x cheaper
$0.1348
$0.2169
A username validator accepted a trailing newline1.4x cheaper
$0.0590
$0.0820
HTTP responses mangled memoryview content2.1x cheaper
$0.0978
$0.2062
Deleting an object left a stale primary key1.3x cheaper
$0.0491
$0.0616

The bad days are what cost you

Every dot is one bug, placed by what it cost. Superbrain's dots stay bunched. Claude Code is quick and cheap on easy bugs, then spends $0.4163 on the one it finds hard. If you are budgeting a team, you pay for the worst day, not the average one.

Superbraincheapest $0.0491 · dearest $0.1348
Claude Codecheapest $0.0616 · dearest $0.4163
$0$0.42 per issue

Where it went wrong

Three bugs went unfixed. Two of them beat both agents. Here is what happened in each.

both failed

Both agents got a one line fix wrong

The change is a single line and the issue text spells it out. Both agents wrote it correctly in earlier runs and both missed it here. Superbrain produced 1,376 bytes where 555 was right. Nothing external was involved, so this is run to run variance, and it is the strongest reason to read the resolve column as a tie.

both failed

Neither agent solved the media merge

The hardest bug in the set. It needs 16 tests to pass. Superbrain got none of them, Claude Code got 2, and neither broke anything that already worked. In earlier runs with the network open, each agent solved it exactly once, and only by downloading the already fixed release from PyPI. With the network closed, neither can.

we failed

Superbrain lost the only instance that separates the two

The required behaviour is a warning message that appears nowhere in the issue and nowhere in the repository. Its test is added by the grader afterwards. Claude Code produced the upstream wording from memory, paraphrased rather than copied. Superbrain did not, because it will not assert what the codebase cannot support. On this instance the benchmark rewards recall and scores grounding as a miss.

What this does not prove

Ten bugs is a small sample. These are the things we would want someone to hold against the numbers.

Ten instances from one repository. A leaderboard figure covers 300 across eleven repos, so this is not comparable to one. The interval on a rate this small is roughly 30 points either way.

One run per instance. Across three runs Superbrain scored 8, 8 and 7 while failing different instances each time, so 7 and 8 are the same measurement here. Read the resolve column as a tie.

Neither agent had a working Python environment, so neither could run the test suite while working. Both were handicapped the same way.

Network isolation is a strong control, not a sandbox. Every run is audited for lookups and the audit ships with the result.

How it ran

Everything held identical except the agent.

The task

The GitHub issue text, word for word, plus one line saying do not edit the tests. Same string to both agents.

The model

Claude Sonnet 5 on both sides, pinned, both billed to the same API key.

The code

A fresh django checkout per bug, at the commit before the fix landed, with no later history in it.

No internet

The fix for every one of these bugs is public. We closed the network so neither agent could look it up, and audited every transcript to check.

The scoring

The official SWE-bench grader, in Docker. A bug counts as fixed only if the failing tests pass and the passing ones still do.

The pricing

One rate card for both. We do not use either agent's self reported cost, because they price cached tokens differently.

Check it yourself

We ran this, so do not take our word for it. Rerun the official grader against our patches and see if you get the same 7 and 8.

python -m swebench.harness.run_evaluation --dataset_name princeton-nlp/SWE-bench_Lite   --split test --predictions_path predictions/superbrain.jsonl --run_id verify
Download the evidence

76 KB. Patches, grader output, container logs, per bug usage and the isolation audit. No agent transcripts, since those carry both companies' internals.