We gave both agents the same ten bugs.

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. The same configuration has produced 7, 8, 9 and 10 on this set across previous runs, so 8 against 8 should be read as a tie and not as a measured equality.

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

Claude Code was given a tool we do not have. It ran with WebSearch enabled; Superbrain ships no search tool at all. Switching off a competitor's feature to match our own surface is not a comparison worth publishing, so it was left on. In the event it went unused.

The network was open, which means correctness here is not an isolation claim. It happens not to matter on this run: Claude Code made zero external calls, and Superbrain made five, all on django-11019, which it failed. Every instance either agent resolved was resolved without a lookup, and the audit in the bundle is what that rests on.

Ten instances from one repository, three runs each. A leaderboard figure covers 300 across eleven repos, so this is not comparable to one.

Both agents had the network open, and both used it. This is deliberate: Codex cannot be isolated, because its web search runs on OpenAI servers and its shell fetches ignore the proxy settings that jail everything else. Capping one side and not the other would measure nothing. The consequence is that the resolve counts are contaminated for both, and the audit files in the bundle name every instance where either agent reached outside the repository.

Codex reached outside the repository on 4 of 10 instances in every single run. Superbrain did so on 1 or 2. Same freedom, different behaviour.

Under isolation, in a separate run, Superbrain resolved 9 of 10 while making no external calls at all. That is the honest correctness figure, and it is not the one in the table above.

The two agents count turns differently. Superbrain reports one per model call; Codex reports one per session, so the figure shown for Codex is its tool and message count, which is the closest comparable thing rather than the same thing.

Cost uses OpenAI list price for the model both agents ran. Neither side gets a discount the other does not.

The tokens card compares our lightest run to their heaviest, which is the widest true gap rather than the typical one. On the middle run of each it is 12 percent, and across all three runs added together it is 6 percent. Every run total is printed above the cards so any of the three is checkable.

The cards use two different populations, and each says which. Tokens and cache writes are whole run totals across all ten issues. Cost is per issue across the nine both agents fixed, because that is the only way to compare the same work. The two disagree on tokens: 12 percent fewer across the whole run, 12 percent more on the shared issues, since the issues one agent failed are not in the paired set. Whole run cost is 22 percent lower, per issue cost is 30 percent lower. Every one of these is recomputable from the bundle.

Our dearest single issue costs more than theirs, $0.1899 against $0.1487. We are also about twice as slow: a full run takes us roughly 9 minutes against their 4 and a half.

Ten instances from one repository, three runs each. A leaderboard figure covers 300 across eleven repos, so this is not comparable to one.

Both agents had the network open and both used it, with identical freedoms. The resolve counts are therefore contaminated for both: these bugs are public and fixed upstream, and the audit files in the bundle name every instance where either agent reached outside the repository, with the URLs for every fetch.

Superbrain's sweep is partly a policy, and the policy is disclosed: when a bug is already fixed upstream, its harness retrieves the fix commit as a diff and ports that change onto the local code. That is standard backporting practice and it is also what wins the two hardest instances here. Under full isolation, in a separate run not in this bundle, Superbrain resolved 9 of 10 with zero external calls.

OpenCode ran the local test suite on more instances than any agent we have measured on this set. On this benchmark that discipline is not rewarded, because two instances have local suites that assert the old behaviour, but it is the right instinct and we say so.

Whole-run cost medians are close and in OpenCode's favour: $1.09 against $1.04, about 5 percent. Per resolved instance the order flips: $0.109 against $0.116, because the runs resolve different counts. Both numbers are printed; pick the one that matches your question.

Superbrain sends 16 percent MORE tokens per run on the medians. It costs roughly the same anyway because its cache writes are 39 percent lower, and a cache write is priced 12.5 times a cache read. Both figures are above the cards.

Superbrain is about one and a half times slower: a median run takes roughly 10 minutes against OpenCode's 7.

These two agents count turns in nearly the same unit, one entry per model call, so unlike the Codex tab the turn columns here are roughly comparable.

Cost uses OpenAI list price for the model both agents ran. Neither side gets a discount the other does not.

Ten instances from one repository, ONE run per agent. The tab beside this one publishes three runs each because a single run on this set is a draw from a distribution — the same configuration has produced 7, 8, 9 and 10 here. Read the tie at 10 of 10 as a tie, not as evidence either agent is more correct than the other.

Both agents had the network open, deliberately, and both used it: Superbrain reached outside the repository on 3 of 10 instances, OpenCode on 5. That is on purpose — this tab measures how efficiently a harness drives a fixed model, not whether the model remembers a public bug. It does mean the resolve counts are contaminated on both sides, and the audit files in the bundle name every URL.

Cost uses DeepSeek's published standing rate for V4 Pro, the model both agents ran. Both runs actually executed in DeepSeek's off-peak window, where every rate is exactly half, so real spend was half of every dollar figure here. The standing rate is used because it is the list price and it applies to both sides identically.

DeepSeek charges nothing for a cache write. Superbrain's usual structural advantage over OpenCode — 39 percent fewer cache writes on the Terra tab, where a write is priced 12.5 times a read — is therefore worth exactly zero here. This tab is the harder comparison for us, and it is the one where the harness work of the last week shows up instead.

Superbrain takes about 8 percent longer in wall clock: 13m13s against 12m15s across the ten.

Superbrain issues more tool calls to get there. It costs less anyway, because a smaller share of those calls are wasted and each one carries more of the page it asked for.

An earlier build of Superbrain lost this comparison on the same ten bugs: 8 of 10 at 2.5 times OpenCode's cost per resolved instance. That run and this one are both in the repository. The difference is harness work, not a different model or a different set.