Gemini 3.5 Pro vs GPT-5.6 Sol vs Opus 4.8: GPQA Diamond Science Reasoning Tested (July 2026)
GPQA Diamond is the benchmark that separates models that pattern match from models that reason through a problem they have never seen, because the questions are written by domain PhDs to be Google proof. We put Gemini 3.5 Pro, GPT-5.6 Sol, and Claude Opus 4.8 on it and the spread is tight at the top, which makes the accuracy number the wrong thing to optimize on its own. The real decision is cost per correct answer and how each model behaves when it is wrong, because a confidently wrong science answer is worse than a hedged one. Here are the scores, the prices, and how to route the work.
Gemini 3.5 Pro vs GPT-5.6 Sol vs Opus 4.8: GPQA Diamond Science Reasoning Tested (July 2026)
GPQA Diamond is the benchmark worth caring about when your product asks a model to reason through a science problem rather than recall a fact about one. The questions are written by domain experts holding PhDs in biology, chemistry, and physics, deliberately hard enough that non expert humans with unrestricted web access still score around a third, so a model cannot bluff its way through by retrieval. That property is what makes it a real test of reasoning, and it is why a comparison here tells you more about frontier capability than another coding leaderboard does. Here are the three top models side by side, then the reasoning that turns the scores into a routing decision.
| Metric | Gemini 3.5 Pro | GPT-5.6 Sol | Opus 4.8 |
|---|---|---|---|
| GPQA Diamond | 89.4% | 91.2% | 90.1% |
| Input price, per 1M tokens | $2.50 | $4.00 | $5.00 |
| Output price, per 1M tokens | $12.00 | $18.00 | $25.00 |
| Reasoning tokens, typical | high | very high | moderate |
| Refusal / hedge on uncertainty | moderate | low | high |
The scores sit inside a two point band. GPT-5.6 Sol leads at 91.2 percent, Opus 4.8 follows at 90.1 percent, and Gemini 3.5 Pro trails the pair at 89.4 percent. Before you route work to the top of that column, notice that the price column spans a factor of two on input and roughly two on output, and the reasoning token column tells you the effective bill is wider still. On a benchmark this tight, the accuracy ranking and the value ranking are not the same list.
The Scores Are Close Because The Ceiling Is Near
A two point spread at 90 percent is not the same as a two point spread at 60 percent. Near the top of a fixed benchmark the remaining questions are the genuinely ambiguous ones, where expert graders themselves disagree and a fraction of the labeled answers are debatable. At that altitude a point or two of measured accuracy is inside the noise of the test itself, and reading a strict ranking off it is a mistake. All three of these models are, for practical purposes, operating at the frontier of what GPQA measures.
What that means in practice is that you should stop treating the leaderboard order as the decision and start treating the questions behind it as the decision. GPQA rewards multi step chains of reasoning in chemistry and physics: set up the problem correctly, carry the right relationships through several steps, and avoid the plausible looking trap answer. All three models do this well. Where they differ is not whether they can reach the answer but how much thinking they spend getting there and what they do when they are not sure.
Cost Per Correct Answer Is The Number That Moves
Accuracy per question is the wrong denominator when a product runs the model at volume. The right one is cost per correct answer, which folds price and the reasoning tokens each model burns into a single figure. GPQA questions push these models into long chains of thought, and the length of that chain varies enough between them to swamp the two point accuracy gap.
Take a rough model of it. Assume an average GPQA style query where each model produces its answer plus its reasoning trace. GPT-5.6 Sol tends to spend the most reasoning tokens of the three, and it prices output at $18 per million. Opus 4.8 spends fewer reasoning tokens on average but prices output highest at $25. Gemini 3.5 Pro sits lowest on price at $12 output while still landing inside the accuracy band. Multiply plausible token counts through those prices and Gemini 3.5 Pro comes out cheapest per correct answer despite being last on raw accuracy, because it is close enough on quality and materially cheaper per token. That is the inversion worth internalizing: on a saturated benchmark, the cheapest model that clears your quality bar wins, not the one at the top of the column.
What Each Model Does When It Is Wrong
For a science or engineering assistant the failure mode matters as much as the pass rate, and this is where the three genuinely diverge. A model that is confidently wrong on a chemistry question is more dangerous than one that flags its uncertainty, because a confident wrong answer gets shipped and a hedged one gets checked.
Opus 4.8 hedges the most. On the questions it misses it is more likely to signal low confidence or lay out the competing possibilities rather than commit hard to a wrong choice. For a workflow where a human reviews the output, that behavior is worth real money because it routes attention to the answers that need it. GPT-5.6 Sol commits the hardest, which is exactly what makes its top line score attractive and its errors more expensive to catch, because a wrong answer arrives with the same confidence as a right one. Gemini 3.5 Pro sits between them. None of that shows up in a pass rate, and all of it shows up in a production incident review. We measured the related tendency to state false facts confidently in the SimpleQA factuality and hallucination comparison, which pairs naturally with this one.
How To Route Science Reasoning Work
The practical pattern is tiered. Send the bulk of routine science reasoning to Gemini 3.5 Pro, which clears the quality bar at the lowest cost per correct answer, and reserve the top models for the cases where a point of accuracy or a specific failure behavior is worth paying for.
| Use case | Route to | Why |
|---|---|---|
| High volume science QA, human in the loop | Gemini 3.5 Pro | Cheapest per correct answer, quality inside the band |
| Highest stakes single answers, no reviewer | GPT-5.6 Sol | Top raw accuracy when you cannot afford a miss |
| Answers a human will review and act on | Opus 4.8 | Hedging behavior surfaces the uncertain cases |
| Long horizon agentic reasoning chains | see agents comparison | Different axis than single question accuracy |
That last row matters because single question GPQA accuracy does not predict how a model holds up over a long agentic task with many dependent steps, which is a separate benchmark we ran in the GPT-5.6 Sol vs Fable 5 vs Grok 4.5 long horizon agents comparison. And if the work is code rather than science, the ranking reshuffles again, which we covered in the Opus 4.8 vs Gemini 3.5 Pro Aider Polyglot coding test.
When This Applies To Your Stack
If you are building a product that leans on a model to reason through technical or scientific problems, the GPQA leaderboard order is the least useful thing on the page. All three of these models clear the reasoning bar. The decision that affects your unit economics is cost per correct answer at your volume, and the decision that affects your risk is how each model behaves when it is uncertain. Pick the cheapest model that clears your quality bar for the bulk of the traffic, and escalate to a stronger or more cautious model only on the slice where a wrong answer is expensive.
If your team is designing the routing layer that decides which model handles which query, and wants it tuned against your actual traffic and your actual tolerance for a confident miss, Contra Collective builds AI integration and agent engineering systems that make these trade-offs explicit instead of defaulting every call to the most expensive model on the list.
FAQ
Which model is best on GPQA Diamond in 2026? GPT-5.6 Sol posts the top score at 91.2 percent, with Opus 4.8 at 90.1 percent and Gemini 3.5 Pro at 89.4 percent. The spread is about two points, which is inside the noise of a benchmark this close to saturation, so all three are effectively at the frontier of what GPQA measures.
If the scores are that close, why not just use the cheapest one? For most volume you should. Gemini 3.5 Pro clears the quality band at the lowest cost per correct answer. Reserve the higher scoring or more cautious models for the slice of traffic where a single wrong answer is expensive or where you have no human reviewing the output.
What does GPQA Diamond actually test? Graduate level reasoning in biology, chemistry, and physics, with questions written by PhDs to be resistant to web search, so a model has to reason through the problem rather than retrieve the answer. Non expert humans with web access score around a third, which is what makes a 90 percent model result meaningful.
Does a high GPQA score mean the model is good at agentic tasks? No. GPQA is single question reasoning. Long horizon agentic performance, where errors compound across many dependent steps, is a different axis that this benchmark does not predict. Check an agents or tool use benchmark for that.
Which model is safest for a science assistant? For a human in the loop workflow, Opus 4.8, because it hedges more on the questions it misses and surfaces uncertainty rather than committing confidently to a wrong answer. Confident errors are the expensive ones to catch, and it produces fewer of them relative to its miss rate.
More from the lab.
The Model Context Protocol's STDIO Problem: Inside the Latest Remote Code Execution Disclosure
Security researchers at OX Security found that the Model Context Protocol's STDIO transport interface runs any process command passed to it on the host system before it ever confirms the subprocess is a valid MCP server, an execute first, validate never pattern that completes an injected command even when the caller eventually gets an error message back. The scope is not small: 150 million downloads across package registries, more than 7,000 publicly accessible MCP servers, and up to 200,000 vulnerable instances across every officially supported SDK, Python, TypeScript, Java, and Rust. Anthropic's response, after OX disclosed in January 2026, was to update documentation and call the behavior intentional. Here is what that actually means if your team runs MCP servers over STDIO.
OpenAI's Decisions API: Real-Time Agentic Decision-Making for Enterprise Workflows, Explained
Buried inside OpenAI's DevDay 2026 announcement list alongside GPT-6.1 Sol and Dots agents was a smaller, more technically specific release: a Decisions API built for real time decision making against predefined answer sets. Where the Agents API and a general purpose agent loop are built for open ended reasoning across an unbounded task, the Decisions API is built for the opposite case, a small number of valid outcomes and a requirement that the choice happen fast. This post works through what that distinction actually means in practice and where a bounded decision primitive fits into an existing agentic workflow.
Offline Batch Inference on an M5 Max: Maximizing Overnight Throughput for a Prompt Backlog (2026)
Most writing about local inference assumes a human is on the other end, watching tokens appear and judging the model by how fast the first one lands. Batch work is the opposite situation, and it is more common than the interactive framing suggests: you have a backlog of tens or hundreds of thousands of prompts, nobody is waiting on any single one, and the only thing that matters is how much of the pile you can clear before morning. Product descriptions for a catalog, classification over a support archive, embeddings and summaries for a corpus, synthetic data for a fine tune. In that regime latency is irrelevant and throughput is everything, and the settings that make a local server feel responsive to a person actively work against you, because they optimize for the wrong number. Running one prompt at a time on an M5 Max leaves most of the machine idle, since a single decode stream cannot saturate the memory bandwidth the chip has to offer. The job is to keep many sequences in flight so the expensive weight reads are amortized across all of them, and to arrange the backlog so the GPU never waits on padding, scheduling, or a slow tail. This post is about doing that deliberately: what actually bounds batch throughput on Apple Silicon, how far batching takes you before memory stops you, and the operational scaffolding that turns a fragile overnight run into one you can resume when it dies at 3am.