In December 2025, Google quietly added a new model variant to Antigravity: Gemini 3 Deep Think. No launch event. No blog post. Just a new option in the model selector. It took us two weeks to realise it was the most important addition to the platform since launch — because Deep Think doesn't just process faster or handle more tokens. It reasons differently.
What Deep Think Actually Does
Standard language models — including Gemini 3 Pro and Claude Opus — generate responses token by token. They're extraordinarily capable pattern matchers that produce fluent, contextually appropriate text. But they process in a single forward pass: input goes in, output comes out. What happens in between is sophisticated statistical computation, not deliberate reasoning.
Deep Think adds something different: extended thinking time. When you give Deep Think a complex problem, it doesn't immediately start generating an answer. It allocates computational budget to what Google calls "internal deliberation" — multiple passes over the problem, each refining the approach before any output is produced.
The result is visible in the UI: a "thinking" phase that can last 15-60 seconds for complex problems, followed by output that's qualitatively different from standard model responses. More precise. More nuanced. More likely to identify edge cases and potential failures.
Where Deep Think Changes the Game
Architecture Decisions
Ask Gemini 3 Pro how to structure a new microservice and you'll get a competent, conventional answer. Ask Deep Think the same question and you'll get an answer that considers your specific codebase's patterns, identifies potential conflicts with existing services, proposes migration strategies for the transition period, and flags operational concerns you haven't thought about.
Example from last week: We asked Deep Think to design the data model for a client's agent memory system. It proposed a schema, then — unprompted — identified a potential race condition in concurrent session writes, suggested a locking strategy, and recommended a specific Firestore document structure that would maximise read performance for the agent's most common queries. Pro would have given us the schema. Deep Think gave us the schema plus the three problems we would have discovered in production two weeks later.
Debugging Complex Issues
Deep Think is extraordinary at debugging. Not the kind of debugging where the error message tells you what's wrong — any model handles that. The kind where the application works 99% of the time and silently does the wrong thing 1% of the time.
We had a case where an OpenClaw agent was occasionally sending duplicate responses to WhatsApp messages. The logs showed nothing obvious. Pro suggested common causes (webhook retry, race condition in the response handler). Deep Think read the entire codebase, traced the message flow through the gateway, and identified that the WhatsApp webhook was being called twice by Meta's servers under specific network conditions — and that our idempotency check was using a message timestamp with second-level granularity instead of the message ID. Fix: one line of code. Time to diagnosis with Deep Think: 3 minutes. Time we would have spent debugging manually: probably a full day.
Code Review
We now run every significant PR through Deep Think before merging. Not for style issues or formatting — that's what linters are for. For logic issues. For "this works, but here's why it'll break when you scale" issues. For "you're not handling this edge case that your tests don't cover" issues.
The hit rate is remarkable. A meaningful proportion of reviews surface something genuinely important that we would have shipped to production otherwise. The cost of running Deep Think on a PR review: pennies. The cost of a production bug: hours of debugging, client impact, reputation damage.
When NOT to Use Deep Think
Deep Think's deliberation time is a feature, not a bug — but it comes at a cost. Every query takes 15-60 seconds to process. For tasks that don't benefit from extended reasoning, this is wasted time:
- Simple code generation: "Write a function that formats a date string" — use Flash or Pro
- Boilerplate: "Create a new React component with standard props" — use Pro
- Quick edits: "Change the button colour from blue to green" — use Flash
- Content generation: "Write a product description" — use Pro
Deep Think is for the moments that matter: architecture, debugging, security analysis, performance bottlenecks, and code review. Use it surgically, not universally.
The Model Selection Framework We Use Daily
| Task Type | Model | Why |
|---|---|---|
| Quick completions, simple edits | Gemini 3 Flash | Fastest response, lowest cost |
| Feature development, UI work | Gemini 3 Pro | Best balance of speed and quality |
| Writing, documentation | Claude (Anthropic) | Most natural prose, best nuance |
| Architecture, debugging, review | Gemini 3 Deep Think | Deepest reasoning, catches edge cases |
This isn't brand loyalty. We've tested every combination extensively. Different tools for different jobs. The developers who pick one model and use it for everything are leaving performance on the table.
Deep Think isn't the model you use most. It's the model that saves you when it matters most. And for the problems where reasoning depth is the difference between "it works" and "it works correctly under every condition" — it's irreplaceable.
