Gemini 3.6 Flash & Tiered Thinking: Did Google Forget Gemini 3.5 Pro?

Google quietly updated its AI ecosystem with the release of Gemini 3.6 Flash. This update not only brings blazing-fast response speeds and optimized inference costs but also introduces a brand-new reasoning configuration option in the API and Google AI Studio: Tiered Thinking.

However, what has particularly caught the attention of backend engineers and AI researchers is a strange absence: Gemini 3.5 Pro remains completely Missing in Action (MIA). While the Flash series jumped straight from 3.0 to 3.6, the Pro series remains stuck at version 3.1 Pro.

This article takes a deep dive under the hood of Tiered Thinking, explaining why it represents a major paradigm shift for modern AI Agents like Antigravity and Claude Code, while dissecting the underlying mysteries behind Google’s decision to skip Gemini 3.5 Pro.

1. The Dilemma of Hardcoded Thinking Budgets

Throughout 2025, as large language models transitioned into the era of Chain-of-Thought (CoT) reasoning, API providers such as OpenAI and Google introduced parameters enabling developers to adjust the model’s Thinking Budget.

For previous Gemini Flash releases, developers typically worked with 3 fixed presets:

• Low: Allocates 512 to 1,024 thinking tokens. Ideal for simple tasks like JSON formatting, code autocompletion, or basic text classification. Ultra-fast with near-instant responses.
• Medium: Allocates around 2,048 to 4,096 thinking tokens. Strikes a balance between speed and reasoning quality for moderate logic tasks.
• High: Expands the CoT reasoning chain up to 8,192 - 16,384 tokens. Designed for complex algorithm analysis, detecting race conditions in Go goroutines, or refactoring large data models.

{
  "model": "gemini-3.0-flash",
  "generationConfig": {
    "thinkingConfig": {
      "thinkingBudget": "high"
    }
  }
}

The Real-world Dilemma for Agent Builders

When building autonomous AI systems or AI Coding Agents running in production, hardcoding a fixed thinkingBudget introduces severe drawbacks:

1. Cost Inefficiency and Latency Spikes: Hardcoding high across an entire agentic loop forces even simple interaction turns (such as reading a file or verifying a path) to consume thousands of thinking tokens. This pushes loop latency up to 10-15 seconds per turn, degrading user experience and inflating API bills.
2. Under-thinking Hallucinations: Conversely, setting low or medium to save costs leads to immediate agent failures when encountering tasks requiring multi-file dependency analysis or deep multi-step logic.

This operational headache led Google to introduce Tiered Thinking on Gemini 3.6 Flash.

2. Under the Hood: How Tiered Thinking Works

Rather than constraining the model to a rigid token ceiling, Tiered Thinking (thinkingBudget: "tiered") transforms reasoning time into a dynamic, self-adjusting resource (Dynamic Token Allocation).

                      +-------------------+
                      |   User Prompt /   |
                      |   Agent Request   |
                      +---------+---------+
                                |
                                v
                      +-------------------+
                      | Pre-flight Router | (Analyzes Complexity)
                      +---------+---------+
                                |
        +-----------------------+-----------------------+
        |                       |                       |
        v                       v                       v
+---------------+       +---------------+       +---------------+
| Tier 1: Low   |       | Tier 2: Mid   |       | Tier 3: High  |
| (~512 tokens) |       | (~2K tokens)  |       | (~8K+ tokens) |
+-------+-------+       +-------+-------+       +-------+-------+
        |                       |                       |
        +-----------------------+-----------------------+
                                |
                                v
                      +-------------------+
                      | Final Response /  |
                      |  Tool Call Output |
                      +-------------------+

3-Step Execution Mechanics

1. Pre-flight Complexity Routing: The moment a request arrives, an ultra-lightweight router or the initial layers of Gemini 3.6 Flash evaluate prompt complexity based on context size, code structure density, and instruction ambiguity.
2. Dynamic Tier Routing:
   • Tier 1 (Lightweight): For simple tasks (“Write an email validator helper in Go”), the model activates a minimal CoT chain and returns output in under 500ms.
   • Tier 2 (Standard): For intermediate prompts (“Optimize an SQL query joining 4 tables with GROUP BY”), the model allocates ~2,000 thinking tokens to analyze query execution plans.
   • Tier 3 (Deep Reasoning): For complex queries (“Analyze potential channel deadlocks in a Go message broker”), the model dynamically expands CoT reasoning to maximum depth.
3. Early Exit Threshold: During CoT generation, if the model achieves a high confidence score before depleting the tier’s token budget, it halts reasoning immediately and streams the final output. You pay strictly for the actual thinking tokens generated.

Official Google GenAI SDK Usage

Here is how to configure Tiered Thinking using the new official Go SDK and Python SDK:

package main

import (
	"context"
	"fmt"
	"log"

	"google.golang.org/genai"
)

func main() {
	ctx := context.Background()

	// Initialize client using the new official google.golang.org/genai package
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		APIKey: "YOUR_API_KEY",
	})
	if err != nil {
		log.Fatalf("GenAI client init failed: %v", err)
	}

	// Call Gemini 3.6 Flash with tiered reasoning config
	resp, err := client.Models.GenerateContent(
		ctx,
		"gemini-3.6-flash",
		genai.Text("Analyze this Go code for potential goroutine leaks..."),
		&genai.GenerateContentConfig{
			Temperature: genai.Ptr[float64](0.2),
			ThinkingConfig: &genai.ThinkingConfig{
				IncludeThoughts: true,
				ThinkingLevel:   genai.ThinkingLevelHigh,
			},
		},
	)
	if err != nil {
		log.Fatalf("Gemini 3.6 API call failed: %v", err)
	}

	fmt.Println(resp.Text())
}

from google import genai
from google.genai import types

# Initialize client using the unified google-genai SDK
client = genai.Client(api_key="YOUR_API_KEY")

# Call Gemini 3.6 Flash model with Tiered Thinking
response = client.models.generate_content(
    model="gemini-3.6-flash",
    contents="Write a Python function implementing A* search for shortest path on a weighted graph.",
    config=types.GenerateContentConfig(
        temperature=0.2,
        thinking_config=types.ThinkingConfig(
            include_thoughts=True,
            thinking_level="HIGH"  # Or "TIERED"
        )
    )
)

print(response.text)

3. The Missing Gemini 3.5 Pro: 4 Hypotheses

Tracing Google’s release history reveals an unusual version curve:

Why did Google skip Gemini 3.5 Pro? AI engineers and researchers point to 4 technical hypotheses:

Hypothesis 1: Gemini 3.6 Flash “Tiered” is a Distilled 3.5 Pro

In LLM training, Knowledge Distillation transfers knowledge from a large Teacher Model into a compact Student Model. API endpoint traces suggest gemini-3.6-flash-tiered represents the distilled outcome of Google’s internal 3.5 Pro project, packaged directly into the efficient Flash 3.6 architecture.

Hypothesis 2: Inference Economics of TPU Infrastructure

Serving a massive Pro model to millions of daily agent requests across TPU v5e/v6e clusters is cost-prohibitive. Given aggressive API price competition:

• Pro model requests consume 5-8x more compute resources than Flash models.
• With Gemini 3.6 Flash Tiered solving 95% of software engineering tasks at low cost, maintaining an intermediate Pro 3.5 model creates product cannibalization.

Hypothesis 3: The Paradigm Shift to “Loop Latency” in AI Coding Agents

In agentic tools like Antigravity or Claude Code, Loop Latency dictates user experience over minor benchmark gains. A multi-file refactoring agent performs 10-15 interaction turns:

• Heavy Pro Model: 20 seconds per turn -> Total wait time: 5 minutes.
• Gemini 3.6 Flash Tiered: 1s for file reads, 8s for complex reasoning -> Total wait time: under 40 seconds.

This speed preservation keeps developers in their flow state.

Hypothesis 4: Preparing for Gemini 4.0 Pro

Google may have bypassed 3.5 Pro to focus compute resources on training Gemini 4.0 Pro with native multimodal and spatial reasoning capabilities.

4. Production Guidance: Which Preset to Choose?

5. Conclusion

The release of Gemini 3.6 Flash and Tiered Thinking highlights a mature product direction from Google—shifting from rigid token caps to dynamic, adaptive model reasoning.

Whether Gemini 3.5 Pro was distilled into Flash or set aside for Gemini 4.0 Pro, having a fast, adaptive, and cost-effective 3.6 Flash model is a huge win for developers building next-generation AI agents.