How to Migrate to Gemini 3.6 Flash Without Breaking Production

Gemini 3.6 Flash is generally available at $1.50 per million input tokens and $7.50 per million output tokens. Migrating requires more than changing the model ID: remove deprecated sampling parameters, replace thinking_budget, remove candidate_count, eliminate prefilled model turns, and retest function calling before production rollout.

Why This Migration Can Break

If your Gemini settings have been shared across several model generations, the model-name change is the easy part. The dangerous part is old configuration that is ignored today and may return HTTP 400 later.

Google's current guide identifies five areas to check:

• temperature, top_p, and top_k are deprecated;
• thinking_budget should become thinking_level;
• candidate_count is unsupported in Gemini 3.x;
• a request cannot end with a prefilled non-empty model turn;
• function-call and multi-turn state must be retested.

Pricing Snapshot

Model	Input / 1M	Output / 1M	Default thinking
Gemini 3.6 Flash	$1.50	$7.50	medium
Gemini 3.5 Flash-Lite	$0.30	$2.50	minimal

Gemini 3.6 Flash has the same input price as Gemini 3.5 Flash, but output falls from $9.00 to $7.50 per million tokens, a 16.7% reduction.

Do not route every task to 3.6 Flash just because it is newer. Flash-Lite remains a better first route for high-volume classification, extraction, and predictable transformation when it meets your acceptance criteria.

Setup

Use Python 3.11+ and update Google's GenAI SDK:

python -m venv .venv
source .venv/bin/activate
pip install -U google-genai

export GEMINI_API_KEY="your-key"

Never commit the API key.

The New Request

The current Interactions API example is intentionally small:

from google import genai


client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input=(
        "Review this migration plan and return the three "
        "highest-risk compatibility issues."
    ),
)

print(interaction.output_text)

Gemini 3.6 Flash defaults to medium thinking. Configure the level only when your evaluation shows a reason to change it:

from google import genai


client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="Analyze this multi-step debugging problem.",
    generation_config={
        "thinking_level": "medium",
    },
)

print(interaction.output_text)

Remove the Old Generation Config

This shared configuration should not move to the new models:

# Remove this configuration for Gemini 3.6 Flash.
old_config = {
    "temperature": 0.2,
    "top_p": 0.9,
    "top_k": 40,
    "candidate_count": 1,
    "thinking_budget": 4096,
}

Use the smaller configuration instead:

new_config = {
    "thinking_level": "medium",
}

Explicit system instructions and structured outputs are more reliable than deprecated sampling controls when you need a fixed response shape.

Remove Prefilled Model Turns

Legacy payloads sometimes end with a model turn to force a prefix:

{
  "contents": [
    {
      "role": "user",
      "parts": [{"text": "Translate 'Hello world' to Spanish."}]
    },
    {
      "role": "model",
      "parts": [{"text": "Translation:"}]
    }
  ]
}

Gemini 3.6 Flash rejects that pattern with HTTP 400. Move the format requirement into a system instruction:

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="Translate 'Hello world' to Spanish.",
    system_instruction=(
        "Output only the translation without introductory text."
    ),
)

Use structured outputs when your application needs machine-validated JSON.

Audit Function Calling

For multi-step agents, a successful text request does not prove the migration is complete. Test:

1. tool selection;
2. tool argument validity;
3. propagation of the function name and call ID;
4. tool-result handling;
5. multi-turn state through previous_interaction_id;
6. retry behavior after malformed calls or timeouts.

If you still use generateContent, verify that every FunctionResponse carries both call_id and name.

Add a Cost Calculator to Your Eval

from dataclasses import dataclass


@dataclass(frozen=True)
class Price:
    input_per_million: float
    output_per_million: float


GEMINI_36_FLASH = Price(1.50, 7.50)
GEMINI_35_FLASH_LITE = Price(0.30, 2.50)


def request_cost(
    input_tokens: int,
    output_tokens: int,
    price: Price,
) -> float:
    return (
        input_tokens * price.input_per_million
        + output_tokens * price.output_per_million
    ) / 1_000_000


print(request_cost(15_000, 8_000, GEMINI_36_FLASH))
# 0.0825

Thinking tokens are billed as output, so feed the billed token counts from the API into your analysis instead of estimating from visible response length.

Production Evaluation Checklist

Run 30 to 50 recent tasks through your current production model, Gemini 3.6 Flash, and Gemini 3.5 Flash-Lite. Keep prompts, tools, validators, and acceptance rules unchanged.

Record:

• input, output, and thinking tokens;
• P50 and P95 latency;
• validator pass rate;
• number of tool calls and retries;
• function-call errors;
• human correction time;
• cost per accepted task.

Google reports that 3.6 Flash uses 17% fewer output tokens than 3.5 Flash on the Artificial Analysis Index and up to 65% fewer on DeepSWE. Treat those as reasons to run an eval, not assumptions about your traffic.

Key Takeaways

• Update the model ID to gemini-3.6-flash.
• Delete deprecated sampling parameters now.
• Replace thinking_budget with thinking_level.
• Remove candidate_count and prefilled model turns.
• Retest function calls and multi-turn state separately.
• Route predictable high-volume work to Flash-Lite when it passes validation.
• Compare cost per accepted task, not only price per token.

Primary references: Google's launch announcement and latest-model migration guide.

You can also test Gemini alongside other models through CometAPI while keeping one evaluation harness.

P.S. I work with CometAPI. Google's prices, model IDs, and migration requirements are linked above; benchmark gains should be reproduced on your own workload.