Google Gemini 3

Gemini 3 is Google’s frontier multimodal model family, launched on November 18, 2025 with an unusually wide same-day rollout: Search’s AI Overviews, the Gemini app, AI Studio, Vertex AI, the Gemini CLI, and a new agentic development environment called Antigravity all shipped on Gemini 3 on day one. That launch strategy is itself a signal about where Google sees the model’s value: not as a standalone chatbot to be evaluated in isolation, but as the reasoning layer underneath products a billion people already use. The family now spans four tiers (Flash-Lite, Flash, Pro, and the reasoning-maximized Deep Think), and its most consequential API change is a small one: reasoning depth is now a discrete thinking_level a caller picks, not a token budget they have to guess at.

The Model Lineup

Gemini 3 is not one model but a tier ladder, each point tuned for a different cost-latency-capability trade-off. All four tiers, including the cheapest, ship with at least a 1 million token context window, which Google has treated as a baseline capability rather than a Pro-only upsell since the Gemini 3 launch.

Deep Think is the direct descendant of the mode Google used to win a gold-medal-level result at the International Mathematical Olympiad and the ICPC world finals; in the Gemini 3 family it is exposed as a selectable mode on top of Pro rather than a separate model family, positioned for the small slice of queries where getting the answer right matters more than getting it fast.

# Scenario: routing incoming requests to the cheapest tier that can still
# do the job, instead of sending everything to Pro by default.
def pick_tier(task_kind: str) -> str:
    return {
        "bulk_tag":       "gemini-3-flash-lite-preview",
        "chat":           "gemini-3-flash-preview",
        "long_doc_audit": "gemini-3-pro-preview",
        "hard_research":  "gemini-3-pro-preview",   # + thinking_level=HIGH, Deep Think mode
    }.get(task_kind, "gemini-3-flash-preview")

Reasoning Depth as a Discrete Choice

Earlier reasoning models exposed a raw thinking-token budget, forcing every caller to guess how many tokens a given question was worth. Gemini 3 replaces that with thinking_level, a small enum: Flash-Lite and Flash support MINIMAL, LOW, MEDIUM, and HIGH; Pro exposes LOW and HIGH (default HIGH). MINIMAL is close to zero extra thinking, tuned for throughput over depth; HIGH lets the model reason as long as it judges necessary before answering. This is the same underlying idea as test-time compute, but packaged as an operational dial rather than a budget you tune by trial and error.

# Scenario: a code-review bot. Syntax-level lint findings don't need deep
# reasoning; architectural review comments do.
lint_pass = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents=diff_text,
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level=types.ThinkingLevel.MINIMAL)
    ),
)

architecture_pass = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents=f"Review this diff for architectural regressions:\n{diff_text}",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level=types.ThinkingLevel.HIGH)
    ),
)

The widget below models the trade-off directly: for a fixed task, moving thinking_level up buys accuracy on hard questions but costs latency and output-token spend, and the crossover point depends on how much of the task is actually hard.

Try this: push "share of hard queries" to 80% and slide from MINIMAL to HIGH. Blended accuracy climbs sharply. Now drop hardness to 5% and repeat: the curve goes nearly flat, because almost every query was already solved at MINIMAL, and the extra latency and cost bought almost nothing.

Agentic and Computer-Use Benchmarks

Gemini 3’s launch benchmark set leaned heavily agentic rather than purely conversational: MMMU-Pro for multimodal reasoning, MCP Atlas for tool-calling and orchestration through the Model Context Protocol, and OSWorld for computer-use agent tasks (operating a real desktop GUI end to end). That benchmark mix mirrors the same industry shift covered in the GPT-6 Astra entry: evaluation has moved from single-turn answer quality toward whether a model can drive a multi-step session to a correct real-world outcome.

# Scenario: an agent that has to both browse a live webpage and call a
# structured tool, the two skills OSWorld and MCP Atlas each isolate.
from google.genai import types

resp = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="Find the current AWS S3 pricing for us-east-1 and log it via the pricing_tool.",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(google_search=types.GoogleSearch()),
            types.Tool(function_declarations=[PRICING_TOOL_SCHEMA]),
        ],
        thinking_config=types.ThinkingConfig(thinking_level=types.ThinkingLevel.HIGH),
    ),
)

Antigravity: An Agentic IDE Built Around the Model

Alongside the model, Google shipped Antigravity, a development environment built for “task-oriented” coding: instead of a human driving an autocomplete-augmented editor turn by turn, the developer hands Antigravity a goal and Gemini 3 plans and executes the multi-file, multi-command work required to reach it, similar in spirit to the agent harness pattern used by Claude Code and other coding agents, but built specifically around Gemini 3’s tool-calling and long-context strengths.

flowchart TD
    A[Developer states a goal] --> B[Antigravity: Gemini 3 Pro plans steps]
    B --> C{Step type}
    C -->|routine edit, lint fix| D[Gemini 3 Flash @ MINIMAL/LOW]
    C -->|design decision, refactor| E[Gemini 3 Pro @ HIGH]
    C -->|hard algorithmic problem| F[Deep Think]
    D --> G[Apply change, run tests]
    E --> G
    F --> G
    G -->|tests fail| B
    G -->|tests pass| H[Present diff for review]

    classDef default fill:#ffffff,stroke:#4338CA,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef data    fill:#EEF0F7,stroke:#0D9488,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef process fill:#F7F8FC,stroke:#6366F1,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef output  fill:#4338CA,stroke:#4338CA,stroke-width:2px,color:#ffffff,rx:8px,ry:8px;
    class D,E,F,G process;
    class H output;

This is the same architectural lesson that shows up across most 2025-2026 agent deployments: the expensive, high-thinking_level model call is reserved for the steps that actually need it, and routine steps run on a cheaper tier or a lower thinking level, exactly as demonstrated in the routing snippet earlier in this entry.

Pricing Across the Tier Ladder

API pricing scales with both tier and context length, and the gap between the cheapest and most expensive tier is roughly forty-fold on output tokens.

The practical read is the same one that governs every tiered model family: default to Flash for the bulk of traffic, reserve Pro for tasks where the context or the reasoning genuinely needs it, and treat Deep Think as an occasional, deliberately invoked mode rather than a default setting.

What’s New (2025-2026)

Same-day, whole-portfolio deployment is the headline shift Gemini 3 represents over prior Gemini generations: Search, the consumer app, the CLI, Vertex AI, and a brand-new IDE all launched on the same model on the same day, rather than the model reaching each surface months apart.

Reasoning control simplified from a token budget to a named level. Where earlier reasoning APIs (including Gemini’s own 2.5-era thinking_budget) asked callers to guess a token count, thinking_level’s four-value enum is easier to reason about and easier to route on programmatically, mirroring the same move made by GPT-6 Astra’s effort parameter and GLM-5.1’s reasoning modes.

Agentic benchmarks became launch benchmarks, not follow-up material. MCP Atlas and OSWorld shipping alongside MMMU-Pro at launch reflects the same industry-wide move toward evaluating sustained, tool-using sessions rather than single answers.

Context windows above 1M tokens became a baseline, not a premium feature. Every Gemini 3 tier, including Flash-Lite, ships with at least a 1M token window, pushing the differentiator from “who has the biggest window” toward “who can use that window’s tokens effectively,” the same question raised in the context rot entry.

Limitations Worth Naming

Gemini 3 Pro’s 2M-token ceiling and Flash’s 1M-token window are both nominal capacities, not guarantees of effective recall; retrieval and reasoning quality still degrade unevenly across a long context, and teams building on the model should validate recall behavior on their own document shapes rather than trusting the headline number, the same caution the context rot entry raises about any large-context model. Deep Think’s latency and cost profile also make it unsuitable as a default: it is priced and paced for the small slice of genuinely hard queries, and routing every request through it (rather than reserving it, as the widget above illustrates) erases most of the cost and speed advantage the tiered lineup is designed to offer.

# Scenario: a document-QA endpoint that serves both a live chat widget
# (needs a fast, cheap answer) and a nightly batch job that re-checks
# every answer against source documents (can afford to think longer).
from google import genai
from google.genai import types

client = genai.Client()

def answer(question: str, sources: str, *, careful: bool) -> str:
    resp = client.models.generate_content(
        model="gemini-3-pro-preview",
        contents=f"Sources:\n{sources}\n\nQuestion: {question}",
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                # LOW for the live widget, HIGH for the batch auditor.
                thinking_level=(
                    types.ThinkingLevel.LOW if not careful
                    else types.ThinkingLevel.HIGH
                )
            ),
        ),
    )
    return resp.text

# Live chat path: low latency, good enough for most questions.
live_answer = answer("What's the refund window?", policy_doc, careful=False)

# Nightly audit path: same model, same prompt shape, deeper reasoning.
audited_answer = answer("What's the refund window?", policy_doc, careful=True)