Gemini 3.1 Pro for Developers: The Thinking Toggle, Agentic Coding, and Why It Matters

Visualize performance and intensity levels with this modern, AI-inspired circular data dashboard for clear data insights.

Google dropped Gemini 3.1 Pro into preview yesterday, and while the ".1" in the name might suggest a modest patch, the reality is anything but. This is a model that more than doubles its predecessor's reasoning scores, introduces a landmark three-tier "thinking toggle," and ships tightly woven into the tools developers already live in — Android Studio, Gemini CLI, GitHub Copilot, and Google Antigravity. If you build software, this release deserves your attention.

What Changed from Gemini 3 Pro?

Gemini 3 Pro launched in November 2025 as Google's flagship model for complex reasoning and coding. Three months later, 3.1 Pro builds on that foundation with a focus on two things: raw intelligence and agentic reliability.

The benchmark story is striking. On ARC-AGI-2 — a test designed to measure novel abstract reasoning — 3.1 Pro scored 77.1%, up from 31.1% on Gemini 3 Pro. That's more than double, and it puts 3.1 Pro ahead of Claude Opus 4.6 (68.8%) and GPT-5.2 (52.9%). On SWE-Bench Verified, which tests real-world software engineering ability, 3.1 Pro reached 80.6%, neck-and-neck with Claude Opus 4.6 at 80.9%. On MCP Atlas — a benchmark that measures multi-step agentic workflows using the Model Context Protocol — 3.1 Pro jumped from 54.1% to 69.2%, a 15-point leap that signals a meaningful upgrade in how reliably it executes complex, multi-turn tasks.

These aren't just leaderboard points. For developers building agents, evaluating codebases, or automating workflows, these numbers translate directly into fewer failed runs, better multi-file reasoning, and outputs you can trust.

The Thinking Toggle: The Feature That Changes Everything

The single most consequential addition in Gemini 3.1 Pro is not a benchmark number. It's the new three-tier thinking level system, and it fundamentally changes how developers can balance cost against intelligence.

Gemini 3 Pro had two thinking modes: low and high. With 3.1 Pro, Google introduces a medium tier and completely redefines what high means.

Here's how the three levels map to use cases:

Low is fast and inexpensive. Use it for autocomplete, syntax explanations, simple lookups, or any request where speed matters more than deep reasoning. Think of it as the model operating on instinct.

Medium delivers what the old "high" setting used to provide — solid, careful reasoning that's appropriate for most everyday development tasks. Code reviews, moderate refactors, unit test generation: medium handles all of these efficiently.

High is where 3.1 Pro becomes genuinely new territory. At this level, the model behaves as what Google calls a "mini version of Gemini Deep Think" — its specialized reasoning model. This is the setting you reach for when debugging a race condition across multiple files, designing a complex algorithm, or reasoning through an API integration with lots of edge cases.

Setting the thinking level in the API is a single parameter:

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Debug this race condition in my Go server...",
    config={
        "thinking_config": {"thinking_level": "HIGH"}
    }
)

For routine tasks, swap "HIGH" for "LOW" or "MEDIUM" and your costs drop accordingly — without switching models or endpoints.

Thought Signatures: The New API Requirement

One important implementation detail: Gemini 3 models use Thought Signatures to maintain reasoning context across multi-turn API calls. These are encrypted representations of the model's internal reasoning state, and they need to be passed back to the model with each request, exactly as received. For Function Calling and Image Generation workflows, the API enforces strict validation — missing signatures will return a 400 error. For text and chat, omitting them won't crash your app, but it will degrade reasoning quality. Build the signature handling into your request loop from day one.

Why This Architecture Matters for Production

The thinking toggle is more than a cost dial. It addresses a pain point that's been quietly frustrating enterprise AI teams: the need to route requests across multiple specialized models based on task complexity. That's operationally messy — different endpoints, different rate limits, different pricing tiers to manage.

With 3.1 Pro, you run a single model endpoint and adjust reasoning depth per request. Simple task? Low. Complex agentic workflow? High. The intelligence scales with the problem, and the billing reflects only what you used.

Agentic Coding: What's Actually Improved

The agentic coding improvements in 3.1 Pro are partly about the model and partly about the ecosystem around it.

On the model side, Google introduced a dedicated endpoint — gemini-3.1-pro-preview-customtools — optimized specifically for agent development scenarios. It tunes the calling priority for commonly used developer tools like view_file and search_code, and supports hybrid bash-plus-custom-function workflows that are typical in real agent pipelines. If you've been building agents on 3 Pro and noticed the model occasionally ignoring your custom tools in favor of default bash behavior, this endpoint is the fix.

File uploads have also expanded from 20MB to 100MB. Combined with the 1 million token context window — enough to hold an entire medium-sized codebase — this means you can now send large repos or long video recordings directly into context without chunking. YouTube URL support is another new addition: developers can pass a YouTube link directly in a prompt, and the model will analyze the video without a separate download-and-upload step.

On the benchmark side, Terminal-Bench 2.0 (agentic terminal coding) moved from 56.9% on 3 Pro to 68.5% on 3.1 Pro, and BrowseComp (agentic web search and research tasks) jumped from 59.2% to 85.9%.

Where You Can Use It Today

Google shipped 3.1 Pro across a wide range of developer surfaces simultaneously, which is notable in itself.

Gemini API / Google AI Studio is the fastest path in — no subscription needed, and you can experiment with thinking levels right in the AI Studio playground before writing a line of code. The model string is gemini-3.1-pro-preview.

Gemini CLI gives you terminal-based access, which integrates naturally into scripted workflows and local development environments. If you're the kind of developer who lives in the terminal, this is where you'll feel most at home with 3.1 Pro.

Android Studio brings 3.1 Pro into Agent Mode, which lets you describe complex goals in natural language — refactor this module, generate unit tests for this class, fix the build errors — and have the agent formulate and execute a multi-file plan. You review and approve each proposed change, with an optional auto-approve mode for when you want to iterate fast. The 1 million token context window means the agent can reason over your entire project structure, not just the file you have open.

GitHub Copilot users across VS Code, Visual Studio, github.com, and GitHub Mobile can select Gemini 3.1 Pro in the model picker. Early testing reported it excels at efficient edit-then-test loops with high tool precision, achieving strong resolution success with fewer tool calls per benchmark.

Google Antigravity, Google's agentic development platform, and Vertex AI / Gemini Enterprise round out the options for teams that need production-grade deployments with custom rate limits and Google Cloud's security posture.

Pricing: The Competitive Edge

At $2.00 per million input tokens and $12.00 per million output tokens, Gemini 3.1 Pro is priced identically to Gemini 3 Pro — meaning Google is delivering dramatically higher capability at the same price point. The blended rate (assuming a 3:1 input-to-output ratio) comes to roughly $4.50 per million tokens.

To put that in context: Claude Sonnet 4.6 runs $6.00 blended per million tokens, Claude Opus 4.6 runs $10.00, and GPT-5.2 sits around $4.80. Gemini 3.1 Pro currently leads the price-performance curve among frontier models for most common developer use cases — you're getting top-tier reasoning benchmarks at a lower input cost than any major competitor.

For long-context tasks exceeding 200,000 tokens, pricing steps up to $4.00/$18.00 per million tokens — a tiered structure that reflects the higher compute cost of processing very large contexts, while still being competitive for the use cases that genuinely require it.

There is currently no free tier for gemini-3.1-pro-preview in the Gemini API, though you can try it free in Google AI Studio.

Real-World Signals

Beyond benchmarks, a few early production signals are worth noting.

Cartwheel, an AI animation company, reported that 3.1 Pro has substantially improved understanding of 3D transformations — specifically helping close a long-standing rotation order bug in an export pipeline that had resisted resolution with other models.

Hostinger, whose Horizons vibe-coding product lets non-developers build apps from natural language, noted that 3.1 Pro understands "the vibe behind a user's prompt" — generating code that reflects product direction and style, not just syntax. That's a meaningful signal for developers building creative tools or user-facing AI products.

Legal AI company Harvey is testing 3.1 Pro for long-context document analysis, which suggests the 1M token window is drawing serious interest beyond the developer community.

Things to Know Before Adopting

3.1 Pro is still in preview, not general availability. Google has been explicit that they're releasing it in preview specifically to validate updates and continue advancing agentic workflows before a full GA launch. That means API behavior may change, rate limits are more restrictive than production tiers, and deprecation will come with at least two weeks' notice.

If you're building production agents, it's worth testing against your specific workloads rather than relying on general benchmarks alone. LMArena scores — which measure real user preferences in blind comparisons — show 3.1 Pro as only marginally better than 3 Pro in some practical tasks, and Claude Opus 4.6 still holds an edge in extended text and complex multi-file code edits in certain evaluations. Benchmarks and real-world vibes don't always align.

Also remember that gemini-3.1-pro-preview-customtools is the dedicated endpoint for agent workflows. If you're using the standard preview endpoint and your custom tools are being ignored in favor of bash commands, switch to the customtools variant.

The Bottom Line

Gemini 3.1 Pro is a genuinely significant update for developers, not a minor patch. The three-tier thinking toggle is the headline feature — it gives you fine-grained control over cost versus intelligence within a single model, which simplifies production architectures and makes 3.1 Pro a credible choice for a broader range of tasks than any previous Gemini model. The agentic improvements, file upload expansion, dedicated custom tools endpoint, and deep integration across Android Studio, Gemini CLI, and GitHub Copilot make this a model that fits into your workflow rather than requiring you to build around it.

The fact that all of this arrives at the same price point as Gemini 3 Pro makes the calculus straightforward: if you were already using 3 Pro, upgrade. If you haven't tried Gemini in your stack, 3.1 Pro is the most compelling reason yet.

Start in Google AI Studio — it's free, no setup required, and the thinking level toggle is right there in the UI.

Model string: gemini-3.1-pro-preview | Custom tools endpoint: gemini-3.1-pro-preview-customtools | Pricing: $2.00/$12.00 per 1M tokens | Context window: 1M input / 64K output

thinking-model

Related Topics

Gemini 3.1 Pro for Developers: The Thinking Toggle, Agentic Coding, and Why It Matters