Gemini 3.8 Flash vs 3.7 Flash: what changed and should you upgrade?

Google shipped Gemini 3.8 Flash on September 2, 2026, three weeks after Gemini 3.7 Flash and six weeks after 3.6 Flash. Same intro price ($0.75 input, $3.75 output per million tokens through December 31), same 1M-token context, and, per Google’s own framing, about the same speed. What changed is how the model works: it takes smaller reasoning steps, verifies its own output, and calls tools in loops. That earns it a higher score on every published benchmark. It also makes each task cost more tokens.

So the upgrade question isn’t “is 3.8 Flash better?” On paper it is. The question is whether the extra quality pays for the extra tokens on your workload, and whether the two breaking changes touch your code. This comparison goes through what stayed the same, what improved, what it costs you, and a decision matrix by workload. Sources are Google’s launch post, the What’s new in Gemini 3.8 Flash page, and Artificial Analysis’s independent testing. For the full spec sheet, start with what Gemini 3.8 Flash is.

One more thing up front: Google says “Gemini 3.7 Flash remains fully supported” and has published no deprecation date. Nobody is forcing your hand.

Side by side

What is identical

Price, first. Both models sit on the same rows of Google’s pricing page: $0.75 in and $3.75 out through December 31, doubling to $1.50 and $7.50 on January 1, 2027. Caching, batch discounts, and the 5,000 free Google Search grounding requests per month (shared across every Gemini 3.x model) all carry over. If you want the per-line breakdown, the 3.7 Flash specs and pricing reference still applies to 3.8 Flash line for line.

Context and output limits are unchanged at 1,048,576 input tokens and 65,536 output tokens. Modalities are the same too: text, image, video, audio, and PDF in; text out. Neither model does audio generation, image generation, or the Live API.

Speed is a near-tie. Logan Kilpatrick at Google described 3.8 Flash as “same price as 3.7, is ~the same speed.” Artificial Analysis measured 302.1 output tokens per second on its high-reasoning run. That’s throughput once the model starts writing; time-to-first-token on the same run was 13.30 seconds, because at high the model thinks before it speaks.

The API surface is the same as well. The Interactions API is Google’s primary path for Gemini 3.x now, and the legacy generateContent endpoint “remains fully supported” with no sunset date. Code written for 3.7 Flash on either endpoint runs against gemini-3.8-flash after a model-string swap, with the exceptions covered under breaking changes.

What improved

Google’s headline for 3.8 Flash is “our most intelligent Flash model,” built for “long-horizon software engineering, autonomous agents, and complex enterprise workflows.” The design change behind that claim: on hard tasks, the model “executes extra reasoning steps, and calls tools iteratively,” taking “smaller reasoning steps” and verifying “its work along the way.” Here’s what that produces on the benchmarks Google and Artificial Analysis have published in text.

Google’s own tables. Google published three numeric comparisons against 3.7 Flash on the DeepMind Flash page. These are vendor-run.

Modest, consistent gains, and in each row 3.8 Flash also edges the larger models in Google’s table (Claude Opus 5 at 58.6% on Vals Finance, 54.4% on HLE-Verified); the three-way comparison with Claude Fable 5.1 and GPT-5.6 Sol takes that thread further. That’s a Flash-priced model outscoring models that cost several times more per token, which is the point Google wants you to take away.

Artificial Analysis, independently. The Artificial Analysis write-up puts 3.8 Flash at 59 on its Intelligence Index at high, up from 56 for 3.7 Flash and 52 for 3.6 Flash. That’s three points per release, and it ties 3.8 Flash with GPT-5.6 Sol at xhigh and Grok 4.6 at medium, one point above Claude Fable 5.1 at medium. On τ³-Banking, its tool-use eval, 3.8 Flash scored 45%, a 12-point jump over 3.7 Flash. If you run agents with real tool calls, that row matters more than the index.

Document-heavy agent work. Google says 3.8 Flash “completes more than three times as many tasks as Gemini 3.7 Flash” on long-running, document-heavy workflows. Internal eval, no public harness, so treat it as directional. It lines up with the model’s design, though: more verification steps help most where a single slip derails a 40-step job.

Coding, with a gap in the record. On DeepSWE v1.1, 3.7 Flash scored 65.3%, up from 49.0% on 3.6 Flash. Google says 3.8 Flash “outperforms most larger frontier models” there at “a fraction of the cost,” but the exact 3.8 percentage appears only in the model card’s image tables, not in text, so we won’t print a number. SWE-Bench Pro, Terminal-bench, and OSWorld figures for 3.8 Flash are not published in text at all. If those benchmarks drive your decision, wait for third-party runs.

Safety and injection resistance. Google reports a “significant leap” on Gray Swan prompt-injection testing without a number. The model card deltas versus 3.7 Flash are small: multilingual safety +5.4 points, text-to-text safety -0.4, unjustified refusals +1.1. Read that last one as a slight increase in over-refusal.

What it costs you

Per-token prices didn’t move. Per-task cost did. This is the trade-off Google states openly: the model “can use more tokens on longer running and complex tasks, by design,” and “might use more tokens to maximize performance, especially at higher effort levels.”

Artificial Analysis quantified it. Running its index, 3.8 Flash averaged 48,000 output tokens per task, 30% more than 3.7 Flash. At identical per-token pricing, that turns into a higher bill per completed task:

Three things fall out of that table. First, 3.8 Flash at high costs about 45% more per task than 3.7 Flash at high, and takes 14% longer wall-clock. Second, 3.8 Flash at medium, which is the default, lands within a cent of 3.7 Flash at high, so a “same budget” upgrade is available if medium quality clears your bar. Third, 3.8 Flash at low is the cheapest and fastest row on the table, which makes it the obvious pick for latency-sensitive routes where 3.7 Flash was running at high out of habit.

The 3.8 Flash pricing breakdown works this into daily volumes. The short version: if you’re paying per task, the upgrade is not free, and the thinking level is the dial you use to decide how much of the improvement you buy.

Breaking changes in brief

Two changes bite existing 3.7 Flash code directly.

thinking_level: "minimal" returns a validation error. 3.8 Flash accepts low, medium, and high only. If a 3.7 config carries minimal, map it to low. The thinking levels guide covers what each level does and the cost and latency of each.

Function responses must carry call_id and name. Every function_result on the Interactions API needs both fields, and every functionResponse on legacy generateContent needs the matching id plus name. Code that returned results keyed by name alone will fail on the second turn of a tool loop.

Beyond those, the 3.7 to 3.8 Flash migration guide walks through the Gemini 3 rules worth re-checking on the way across: keep temperature at the default 1.0 (Google warns lower values “may cause looping or degraded performance”), use thinking_level instead of an integer thinking_budget, drop candidate_count, and pass thought signatures back exactly as received. None of those are new to 3.8, but a 3.7 codebase that skipped them will surface the problems now.

Decision matrix by workload

The pattern: the harder and longer the task, the more 3.8 Flash’s “works harder” design earns its tokens. The shorter and more repetitive the task, the less it does, and the more the thinking level (or staying put) matters.

Run both models against the same test scenario in Apidog

The per-task numbers above come from Artificial Analysis’s harness, not yours. Before you swap the model string in production, run your own prompts through both models and compare the token counts. Apidog makes this a ten-minute job.

Set GEMINI_API_KEY as an environment variable in an Apidog environment and add one POST request to https://generativelanguage.googleapis.com/v1beta/models/{{model}}:generateContent with x-goog-api-key reading from the variable. Make model a scenario variable too. The body is the same for both runs:

{
  "contents": [{"parts": [{"text": "{{golden_prompt}}"}]}],
  "generationConfig": {"thinkingConfig": {"thinkingLevel": "medium"}}
}

Build a test scenario with two steps: the request with model set to gemini-3.7-flash, then the same request with gemini-3.8-flash. On each step, add assertions on usageMetadata.candidatesTokenCount and usageMetadata.thoughtsTokenCount with a ceiling that reflects your budget, plus a JSON-path assertion on whatever field your application reads. Run the scenario against a data set of ten or twenty golden prompts. The test report shows each step’s response and assertion results together, so you read both models’ token counts from one run and the +30% figure becomes your number instead of a benchmark’s.

Once the numbers look right, schedule the scenario so a quiet increase in thinking tokens after a model update fails a test instead of showing up on an invoice. Download Apidog to set it up; the free plan covers this workflow.

FAQ

Is Gemini 3.8 Flash faster than 3.7 Flash?

No. Google’s own description is “~the same speed,” and Artificial Analysis measured about 300 output tokens per second at high. Because 3.8 Flash reasons in more steps, wall-clock time per task went up on its harness (2.5 minutes vs 2.2 at high). Dropping to low brings it down to 0.8 minutes.

Does Gemini 3.8 Flash cost more than 3.7 Flash?

Not per token. Both are $0.75 input and $3.75 output through December 31, then $1.50 and $7.50. Per task, yes: Artificial Analysis measured $0.58 at high against $0.40 for 3.7 Flash at high, because 3.8 Flash writes about 30% more output tokens.

Will Google shut down Gemini 3.7 Flash?

Google says 3.7 Flash “remains fully supported” and has published no deprecation date. You can stay on it. The what’s new in 3.7 Flash post is still the reference for that model.

What breaks when I switch to 3.8 Flash?

Two things: thinking_level: "minimal" now returns a 400 INVALID_ARGUMENT error, and every function response must include both the call id (call_id on the Interactions API, id on legacy generateContent) and name. Everything else on the Gemini 3 API is unchanged.

How does this jump compare to 3.6 to 3.7?

3.7 Flash was a larger step: DeepSWE went from 49.0% to 65.3%, and the Artificial Analysis index from 52 to 56. The 3.8 step is +3 on the index and a redesign of how the model spends tokens. For the earlier generation, see 3.6 Flash vs 3.5 Flash, which covers the price cut that started this run of releases.

The short version

Upgrade if your workload is agentic, tool-heavy, or document-heavy. That’s where Google and Artificial Analysis both show gains, and where the extra tokens are buying completed tasks. Stay on 3.7 Flash, or move to 3.8 at low, if you’re running short, repetitive calls where per-task cost is the number you report. Either way, fix minimal and check your function responses first, then measure token counts on your own prompts before you trust anyone’s harness, including ours.