DEV Community: develpmilk

How to Migrate to Gemini 3.6 Flash Without Breaking Production

develpmilk — Wed, 22 Jul 2026 09:56:57 +0000

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:

tool selection;
tool argument validity;
propagation of the function name and call ID;
tool-result handling;
multi-turn state through previous_interaction_id;
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.

How Can You Access 500+ AI Models Without Rewriting Your OpenAI SDK Integration?

develpmilk — Wed, 22 Jul 2026 08:58:24 +0000

How Can You Access 500+ AI Models Without Rewriting Your OpenAI SDK Integration?

If your application already uses the OpenAI Python SDK, you can connect it to an OpenAI-compatible gateway by changing the API key, base URL, and model ID. CometAPI's official site currently lists access to 500+ models through one API key, so the same client structure can be used while you test different model families.

Why I Built This

The first model integration is usually easy. The second one is where duplicated authentication, provider-specific clients, billing, retries, and error handling start to spread through the codebase.

For an early prototype, that duplication may be acceptable. For a product that needs model evaluation or fallback, I prefer to keep the application-facing interface stable and move provider selection behind one boundary.

Setup

Requirements:

Python 3.11+
The current openai Python package
A CometAPI API key stored outside the source code
A model ID confirmed in the current model catalog

python -m venv .venv
source .venv/bin/activate
pip install openai

export COMETAPI_API_KEY="your-key"
export COMETAPI_MODEL="your-current-model-id"

Minimal Working Example

import os

from openai import OpenAI


client = OpenAI(
    api_key=os.environ["COMETAPI_API_KEY"],
    base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
    model=os.environ["COMETAPI_MODEL"],
    messages=[
        {
            "role": "user",
            "content": "Return one practical reason to test more than one model.",
        }
    ],
)

print(response.choices[0].message.content)

The important part is not the number of changed lines. It is the boundary: application code talks to one OpenAI-compatible client, while the model ID remains configuration.

Add a Small Model Abstraction

Avoid scattering model IDs throughout the application. Put the choice in one function so experiments, rollbacks, and environment-specific routing stay manageable.

import os

from openai import OpenAI


client = OpenAI(
    api_key=os.environ["COMETAPI_API_KEY"],
    base_url="https://api.cometapi.com/v1",
)


def complete(prompt: str, model: str | None = None) -> str:
    selected_model = model or os.environ["COMETAPI_MODEL"]
    response = client.chat.completions.create(
        model=selected_model,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content or ""


if __name__ == "__main__":
    print(complete("Summarize the value of model portability in two sentences."))

What Changes in Production?

An OpenAI-compatible request format reduces integration work, but it does not make models interchangeable. Before routing production traffic, test the dimensions that affect your workload.

Check	Why it matters
Model ID and availability	Catalogs change; validate before deployment
Tool-calling behavior	Schemas and edge cases can vary by model
Structured output adherence	JSON validity should be measured, not assumed
Timeout and retry policy	Retries can duplicate non-idempotent work
Latency distribution	P95/P99 matters more than one fast demo
Cost per solved task	Token price alone ignores retries and review time

I would run a fixed evaluation set before switching a production default: at least 20 representative prompts, expected-output checks, latency capture, error classification, and a manual review of the failures.

Key Takeaways

Keep the API key and model ID in environment variables.
Treat OpenAI compatibility as an integration interface, not a quality guarantee.
Centralize the model choice instead of hard-coding it across features.
Compare cost per accepted result, not only price per token.
Add fallback only after defining which errors are safe to retry.

The official OpenAI SDK guide covers the current setup, while the CometAPI homepage lists the current catalog scope.

P.S. I used CometAPI for this example. Full disclosure: I work with CometAPI, but the code path and verification steps above are reproducible.