Google’s Gemini 2.5 Pro topped this week’s reasoning and coding leaderboards — 82.4% on GPQA Diamond, 94.1% on HumanEval+, 87.6% on LiveCodeBench V6 — and the AI internet duly erupted. Before you reroute your API calls, though, the numbers deserve a closer read. Deep Think is not a new model. It is a reasoning mode bolted onto Gemini 2.5 Pro that multiplies your token costs by roughly 4x, and the benchmarks it leads on are not the ones that map to your day-to-day sprint work.
One model, two modes #
Unlike OpenAI’s approach of shipping separate reasoning models (o3, o4-mini, and now Sol), Google built Deep Think as a toggle on the existing Gemini 2.5 Pro. You use the same API endpoint, the same context window, the same multimodal inputs. The difference is in what happens at inference time.
Instead of generating a single chain of thought and committing to it, Deep Think runs multiple parallel reasoning paths simultaneously, evaluates each against internal quality criteria, and surfaces the best answer. Google pairs this with novel reinforcement learning techniques that specifically reward step-by-step correctness. The result is noticeably better on problems with many valid solution paths — mathematical proofs, multi-factor architecture decisions, security analysis across a wide threat model. For a prompt like “summarize this document,” the added reasoning produces latency without payoff.
Control is exposed through two APIs. The original approach uses ThinkingConfig
:
response = model.generate_content(
prompt,
generation_config=genai.GenerationConfig(
thinking_config=genai.ThinkingConfig(thinking_budget=8192)
)
)
print(response.usage_metadata.thinking_token_count)
The newer Interactions API simplifies this to thinking_level="low" | "medium" | "high"
, and you can enable thinking_summaries="auto"
to get structured visibility into the model’s reasoning — useful for debugging failures in complex pipelines. Whatever you do in production: set a thinking_budget
cap. Uncapped Deep Think calls can extend into minutes and rack up significant token charges before you realize it. Check the Gemini API thinking documentation for the full parameter reference.
The benchmark split that actually matters #
Here is the part most launch-day coverage glossed over:
| Benchmark | Gemini 2.5 Deep Think | Claude Fable 5 |
|---|---|---|
| GPQA Diamond (science/reasoning) | 82.4% | 79.1% |
| LiveCodeBench V6 (competitive coding) | 87.6% | ~80% |
| HumanEval+ (coding challenges) | 94.1% | N/A |
| SWE-bench Pro (real codebase bug fixes) | 76.4% | 88.6% |
| SWE-bench Verified (agentic coding) | 63.8% | 70.3% |
LiveCodeBench and HumanEval measure competitive programming: algorithmic puzzles, optimization problems, the kind of challenge you’d see on Codeforces or LeetCode hard. SWE-bench measures something different — reproducing fixes for real GitHub issues in actual codebases. Navigating an unfamiliar project structure, understanding existing conventions, applying a targeted patch without breaking anything else.
If your workload looks like the first category — a research pipeline solving constrained optimization, a security tool mapping attack surfaces, a codebase generating theorem proofs — Deep Think is a genuine upgrade. If it looks like the second — tickets, PRs, daily bug triage — Fable 5 is still ahead.
When the 4x premium is worth paying #
Thinking tokens are billed at standard output token rates. That means every token the model spends reasoning — before it writes a single word of visible output — hits your invoice at the same rate as your actual response. At scale, this matters. Review the full breakdown on the Gemini API pricing page before committing.
At 10 million daily output tokens:
- Gemini 2.5 Pro (standard): ~$100/day
- Gemini 2.5 Pro (Deep Think): ~$400/day
- Claude Fable 5: ~$250/day
The math only works if Deep Think meaningfully changes your output quality on that specific task type. For mathematical research, complex security audits, and architectural decisions with cascading dependencies, the accuracy improvement at 5–15% over standard mode can easily justify the cost. For boilerplate generation, content summarization, or standard CRUD scaffolding, you’re paying 4x for no measurable benefit.
Where things stand right now #
As of today, Deep Think is live for Google AI Ultra subscribers ($249.99/month) via the Gemini app. Developer API access is in a “trusted tester” phase, with broader availability described as “coming weeks.” If you need it immediately for production, you do not have it yet — unless Google specifically invited your organization. Read Google’s official Deep Think announcement for the rollout timeline.
Worth noting: OpenAI previewed GPT-5.6 Sol on June 26, a model explicitly targeting complex reasoning and research-grade tasks, currently limited to around 20 pre-approved organizations under a US government directive. When Sol reaches broader API access, this leaderboard will get tested again. Benchmark lead times in this space are measured in weeks, not quarters.
The bottom line #
Deep Think is a precision tool. It earns its place in AI-assisted mathematical research, security analysis, and anything where exploring multiple solution paths before committing is genuinely worth the latency. It does not replace Claude Fable 5 for the kind of iterative, real-codebase work that SWE-bench captures. The benchmark headlines got the performance right — the framing just left out which benchmarks actually reflect your use case.
When API access opens broadly, the right move is not to wholesale migrate your integrations. It is to identify the specific call types in your pipeline where Deep Think’s parallel reasoning pays off, configure thinking budgets to cap cost exposure, and leave standard mode in place for everything else. The API is designed for exactly this — you can tune per request.