Flash, Pro, or Deep Think?

Part of a series on running AI workflows across model providers — this one's about a decision you'll make dozens of times and should stop guessing at.

Google gives you real range in the Gemini lineup: a cheap, fast tier built for volume, a stronger reasoning tier for harder problems, and — for the problems that are genuinely hard — a "Deep Think" mode that trades speed for a materially different kind of reasoning process underneath. Picking wrong in either direction costs you something: overpay for reasoning depth you didn't need, or underpay and ship answers that are subtly worse than they should be. Here's how to actually decide.

The three tiers, honestly described

Flash is the workhorse. It's fast, it's cheap, and for the large majority of everyday text generation, classification, and conversational tasks, it's genuinely good enough that reaching for anything heavier is wasted spend. If you haven't measured a real accuracy problem with Flash on your specific task, it's very likely not costing you what you think it is.

Pro is a step up in reasoning depth at standard latency — still a single forward pass, not the extended multi-stage reasoning of Deep Think, but noticeably stronger on tasks that involve more moving parts: multi-step analysis, longer documents where the model needs to track more context, coding tasks with more interdependent logic.

Deep Think isn't a separate model at all — it's a reasoning mode within Gemini 3 that spends meaningfully more compute at inference time, running a structured process: breaking a problem into sub-problems, exploring multiple candidate solution paths in parallel (especially useful for something like a coding challenge with more than one viable approach), then checking its own work for consistency before finalizing an answer. That structure is a real, different process from a standard single-pass response, not just "the same model thinking a bit longer."

What the benchmark numbers are actually worth

Deep Think's published results are strong on genuinely hard problems — abstract reasoning benchmarks, olympiad-level physics problems, competitive programming — which tells you it's real for the kind of task those benchmarks measure. What it doesn't tell you is whether your specific workload looks anything like an olympiad problem. Most production AI tasks — drafting a response, classifying a ticket, summarizing a document — don't. Benchmark strength on hard reasoning tasks is a signal that Deep Think exists for a reason, not a reason to route your everyday traffic through it.

A framework for actually choosing

Flash ──► most traffic    Pro ──► harder steps    Deep Think ──► rare, high-stakes reasoning

Most traffic belongs in the leftmost lane. The mistake is either never checking, or defaulting everything to the right.

Ask three questions about the specific call you're about to make, not about your product as a whole:

Does this task have more than one plausible right answer, where picking the best one requires comparing approaches? If yes, that's the kind of problem Deep Think's parallel-solution-search process is actually built for — a hard coding problem with multiple valid algorithms, a genuinely ambiguous analytical judgment call.

Does getting this wrong cost more than the extra latency and spend of a heavier model? A misclassified support ticket that gets caught downstream is cheap to be wrong about. A financial calculation, a legal-adjacent summary, a diagnosis-adjacent output — those are worth paying for the model most likely to get it right the first time.

Have you actually measured Flash failing on this, or are you assuming it will? This is the question most teams skip. It's very easy to assume a "harder-sounding" task needs the expensive model without ever running it against Flash first and checking.

A real use case: routing by task, not by product

A contract-review assistant is a good example of a single product that genuinely needs all three tiers, used deliberately rather than defaulting to one. Extracting basic metadata from a contract — party names, dates, contract type — is a Flash task; there's no ambiguity to reason through. Flagging unusual or non-standard clauses against a typical template is closer to a Pro task — it benefits from stronger contextual reasoning across a longer document. Actually comparing two structurally different indemnification clauses and explaining which one creates more risk, in a way a lawyer would find genuinely useful rather than superficial, is closer to the kind of multi-path comparative reasoning Deep Think is built for — and it's the step in the pipeline that runs least often, which is exactly when paying for the heaviest tier makes sense.

const metadataAgent = DNotifier.defineAgent({
  name: "contract-metadata",
  model: "gemini-3.8-flash",
  async run(ctx) { /* fast extraction */ },
});

const clauseFlagAgent = DNotifier.defineAgent({
  name: "clause-flagging",
  model: "gemini-3.1-pro",
  async run(ctx) { /* contextual comparison against typical templates */ },
});

const riskAnalysisAgent = DNotifier.defineAgent({
  name: "risk-analysis",
  model: "gemini-3-deep-think",
  async run(ctx) { /* only runs when the flagging step found something genuinely ambiguous */ },
});

Three tiers, three different jobs, each agent paying only for the reasoning depth its specific step actually needs.

Where teams get this wrong in both directions

Defaulting everything to Flash and wondering why quality plateaus on the genuinely hard subset of requests — usually a small fraction of total volume, but often the fraction that matters most (the escalations, the edge cases, the high-stakes calls).

Defaulting everything to Pro or Deep Think "to be safe" and paying materially more per call for reasoning depth that the bulk of routine traffic never needed in the first place. This is the more common mistake in practice — it feels safer, and the cost creep is easy not to notice until a monthly bill makes it obvious.

Frequently asked questions

Can I switch a specific agent's model tier without redeploying?

Model assignment happens in each agent's definition, so changing it is a code change, not a dashboard toggle the way provider selection is — but it's a small, isolated one, not a rewrite.

Is Deep Think available through the standard Gemini API, or only through Google's enterprise platform?

Both — Deep Think is accessible through pay-per-token Gemini API access with configurable reasoning depth, as well as through the enterprise platform with additional compliance and deployment controls, which we cover next in this series.

Does Deep Think always produce a better answer than Pro?

On problems that genuinely benefit from exploring multiple solution paths, generally yes. On straightforward requests, the extra reasoning process doesn't have much to work with, and you're mostly paying for latency and cost without a corresponding quality gain.

How much slower is Deep Think in practice?

Meaningfully — it's explicitly trading latency for accuracy through a multi-stage process, so it's not a fit for latency-sensitive, real-time interactions. It fits better as a background or async step than something a user is watching a spinner for.

Should I let the model decide its own reasoning depth automatically?

Some Gemini access paths expose configurable reasoning depth as a request parameter rather than requiring you to pick a fully separate model — worth checking the current API documentation for your specific integration, since this is an area Google has iterated on quickly.

The Bottom Line

Next in this series: Google's enterprise agent platform — what changed when Vertex AI got rebuilt and renamed, and where it fits next to a lighter-weight, provider-agnostic approach.

Read part one: Gemini on DNotifier: Setup Guide. Explore dnotifier.com.