Gemini 3.6 Flash vs Gemini 3.5 Flash: What Actually Changed?

When Google shipped Gemini 3.6 Flash on July 21, 2026, it described the model in its own launch materials as "based on Gemini 3.5 Flash" — an unusually candid framing, and the single most useful sentence in the whole announcement. This isn't a new-generation leap the way Gemini 3 was over Gemini 2; it's an iteration on the same workhorse tier, tuned for the same jobs — high-volume chat, retrieval, everyday coding, and agentic pipelines where cost and latency matter as much as raw intelligence. Google didn't reposition the model, rename its tier, or change its target audience. If you're already running 3.5 Flash in production, 3.6 Flash is the obvious next step to evaluate, not a different product to learn.

So the real question isn't "is 3.6 Flash better" in the abstract — a July 2026 release is obviously meant to beat its March-era predecessor on something — it's which specific dimensions moved, by how much, and whether those dimensions are the ones your workload actually depends on. This comparison works through the intelligence score both versions share, the vendor-reported coding, agentic, and long-context gains, a worked cost comparison for a representative call, and three scenarios for deciding whether to migrate now, later, or not at all.

TL;DR verdict. Upgrade for cost, speed, and agentic headroom — not for raw smarts. Gemini 3.6 Flash and 3.5 Flash both score 50 on the Artificial Analysis Intelligence Index — no intelligence gain on the one independent yardstick. But 3.6 drops the output price to $7.50 per 1M (from $9.00), uses about 17% fewer output tokens per task, and is the fastest model Artificial Analysis tracks (303 tokens/sec). Google's own benchmarks also show real coding, agentic, and long-context gains — most strikingly a jump from under 27% to 54.0% on 1M-context recall (GDM-MRCR v2). For almost any 3.5 Flash workload, 3.6 Flash is a straightforward cost-and-capability win; the only reasons to wait are launch-window stability and tightly-tuned evals.

Key takeaways

•  Same intelligence score. Both sit at Artificial Analysis Intelligence Index 50 — the upgrade is efficiency and agentic capability, not general intelligence.

•  Cheaper output. 3.6 Flash is $7.50 per 1M output tokens, down from $9.00 on 3.5 Flash; input is $1.50, cached input $0.15.

•  Fewer tokens, more speed. About 17% fewer output tokens per comparable task, and top-ranked throughput at ~303 tokens/sec.

•  Modest but consistent coding gains. Google reports 3.6 ahead of 3.5 on SWE-Bench Pro (58.7% vs 55.1%), DeepSWE (49% vs 37%), MLE-Bench (63.9% vs 49.7%), and OSWorld (83.0% vs 78.4%).

•  Long-context recall jumps sharply. GDM-MRCR v2 at 1M context climbs to 54.0% from under 27% — the single largest reported delta between the two versions.

•  Same shape otherwise. Both are ~1M context, 64K output, multimodal-in/text-out. 3.6 adds a March 2026 knowledge cutoff.

•  Launch-window caveats exist. Early reports of capacity/reliability strain and at least one account of weaker frontend/spatial-reasoning output — worth pinning versions if you run production traffic.

The cross-model benchmark figures here — SWE-Bench Pro, DeepSWE, Terminal-Bench, MLE-Bench, OSWorld, GDPval, and GDM-MRCR — are Google's own, self-comparing 3.6 Flash to 3.5 Flash. The one independent anchor, the Artificial Analysis Intelligence Index (50 for both), is re-measured continuously; verify the live figure before quoting. 3.5 Flash's per-token input price is not restated in the launch materials; confirm current rates on the pricing page before doing your own cost math.

The specs and price, side by side

•  AA Intelligence Index — Gemini 3.6 Flash: 50; Gemini 3.5 Flash: 50 (identical)

•  Output price (per 1M) — 3.6 Flash: $7.50; 3.5 Flash: $9.00

•  Input price (per 1M) — 3.6 Flash: $1.50 (cached $0.15); 3.5 Flash: see current pricing page

•  Output tokens per task — 3.6 Flash: ~17% fewer; 3.5 Flash: baseline

•  Speed — 3.6 Flash: 303 tok/s (#1 tracked); 3.5 Flash: fast, prior-gen

•  SWE-Bench Pro (vendor) — 3.6 Flash: 58.7%; 3.5 Flash: 55.1%

•  DeepSWE v1.1 (vendor) — 3.6 Flash: 49%; 3.5 Flash: 37%

•  GDM-MRCR v2 at 1M, long-context recall (vendor) — 3.6 Flash: 54.0%; 3.5 Flash: under 27%

•  Knowledge cutoff — 3.6 Flash: March 2026; 3.5 Flash: earlier (unspecified in launch materials)

•  Context / output / modality — both: ~1M / 64K / multimodal-in, text-out

The story is in the first and last rows. Identical intelligence at the top; identical capability envelope at the bottom — same context window, same output ceiling, same multimodal-in/text-out shape. Everything that changed sits in the middle: price, token count, speed, coding scores, and especially long-context recall, which moved the most of any row. That's exactly the profile of an efficiency-and-agentic-capability release rather than a new-generation model.

Benchmark deep-dive: what the numbers actually measure

Start with the Artificial Analysis Intelligence Index, because it's the one number here that's independently measured rather than self-reported. Both versions score exactly 50. That tie matters: it tells you the underlying reasoning, knowledge, and general-problem-solving capability of the model hasn't shifted between releases — you are not getting a smarter model in any composite sense. It's also worth remembering the score is tied to a specific reasoning-effort setting and is re-measured continuously by a neutral third party, so treat 50/50 as the current independent read rather than a permanent fact.

The coding numbers tell a different story, and they're all Google's own vendor comparisons. SWE-Bench Pro rises to 58.7% from 55.1%, and DeepSWE v1.1 jumps further, to 49% from 37% — both measure whether the model can resolve realistic software-engineering tasks, not just answer questions about code. A double-digit swing on DeepSWE is a meaningful signal even as a self-reported number, but because there's no independent re-run of these specific evals for this pairing, read them as directional evidence of a stronger coding-agent, not a certified, third-party-verified gap.

The agentic evals broaden that picture. Terminal-Bench 2.1 improves to 78.0% from 76.2%, MLE-Bench climbs to 63.9% from 49.7%, OSWorld-Verified rises to 83.0% from 78.4%, and the GDPval-AA v2 Elo rating moves to 1421 from 1349. Taken together, these evals test multi-step, tool-using work — running terminal commands, completing machine-learning engineering tasks, operating a computer environment, and producing professional-grade deliverables — rather than single-shot answers. The consistent direction across four different agentic benchmarks is more convincing than any one score in isolation, even with the vendor-reported caveat attached to each.

The standout number, though, is long-context recall: GDM-MRCR v2 at a 1M-token context length rises to 54.0% from under 27% — roughly doubling. That's the largest reported delta anywhere in the comparison, and it explains a lot about where the token and speed savings actually come from: a model that retrieves the right information from a huge context more reliably needs fewer corrective passes and less redundant reasoning to reach a correct answer, which is consistent with 3.6's ~17% lower output-token count on comparable tasks.

What it costs in practice

Per-token prices are abstract; per-task cost is what hits your invoice. Take a representative call of 4,000 input tokens and 2,000 output tokens. Because 3.5 Flash's exact current input rate isn't restated in 3.6's launch materials, the math below holds input pricing at 3.6 Flash's published $1.50 per 1M for both versions, to isolate the two changes we do know: the lower output price and the ~17% output-token efficiency gain. Confirm 3.5 Flash's live input rate on the pricing page if you need an exact historical bill. On that basis, 3.5 Flash's output cost for 2,000 tokens is 2,000 × $9.00 / 1M ≈ $0.018, plus ≈$0.006 input, for a total of about $0.024 per call. 3.6 Flash's output cost, after applying its lower $7.50 rate and the ~17% token reduction (2,000 tokens becomes roughly 1,660), is 1,660 × $7.50 / 1M ≈ $0.01245, plus the same ≈$0.006 input, for a total of about $0.0185 per call — call it $0.021 before the token-efficiency effect and about $0.0185 once both changes are combined.

•  Cost per call (4K in / 2K out) — 3.5 Flash: ~$0.024; 3.6 Flash: ~$0.0185 (lower output price plus ~17% fewer output tokens)

•  100K calls / month — 3.5 Flash: ~$2,400; 3.6 Flash: ~$1,850

•  1M calls / month — 3.5 Flash: ~$24,000; 3.6 Flash: ~$18,500

•  Relative cost — 3.6 Flash: about 77% of 3.5 Flash's cost per task (roughly 23% savings)

23% is a real number at any volume, but it compounds fastest in agentic pipelines, where Google cites an average of about 1.3 minutes per task on 3.6 Flash versus 2.7 minutes on 3.5 Flash. A workload that pays per call and per minute of orchestration saves on both axes at once: fewer tokens per response, a cheaper rate on the tokens it does use, and less wall-clock time occupying whatever agent loop or queue is driving it. At 1M calls a month, roughly $5,500 in direct token cost is the visible part of that; the compute and latency savings from finishing tasks in half the time are the part that doesn't show up on the pricing page.

Three real-world scenarios

1. A high-volume, latency-sensitive production endpoint

Chat, support, retrieval, and drafting at scale — the kind of workload 3.5 Flash was already built for. Since intelligence is unchanged (50 vs 50) and the capability envelope is identical, there's no output-quality risk to weigh against the upgrade. 3.6 Flash's lower output price, 17% fewer tokens per task, and #1-tracked throughput make this close to a strict improvement: same quality, lower bill, faster responses. This is the easiest migration of the three.

2. An agentic coding or DevOps pipeline

Multi-step tasks — resolving issues, running terminal commands, operating tools — are exactly where 3.6 Flash's vendor-reported gains concentrate: SWE-Bench Pro, DeepSWE, Terminal-Bench, MLE-Bench, and OSWorld all move in its favor, and the average time per task drops from about 2.7 minutes to 1.3. Combined with the long-context recall jump (54.0% vs under 27% on GDM-MRCR v2 at 1M), this is the scenario where migrating captures the most upside, not just the cost savings. Re-run your own eval suite before fully committing, since these figures are vendor self-comparisons rather than independently verified.

3. A tightly-tuned, evaluation-locked production system

If your prompts, guardrails, or automated evals were calibrated closely to 3.5 Flash's exact token behavior, the ~17% output-token change and the coding/agentic shifts can move outputs enough to break brittle exact-match checks, even though underlying intelligence hasn't changed. Add the launch-window capacity and reliability reports — and the one account of weaker frontend/spatial-reasoning output — and the sensible path here is to pin versions, re-validate against your own eval set, and roll 3.6 Flash out gradually rather than flipping the switch in place.

When to stay on 3.5 Flash

There are only two real reasons to wait. First, stability: 3.6 Flash drew early Hacker News complaints about capacity and reliability under launch load, and one tester reported poor frontend/spatial-reasoning output — provisioning strain more than a capability regression, but worth pinning versions on if you run production traffic and can't tolerate a rough launch window.

Second, exact reproducibility: if you have prompts and evals tuned tightly to 3.5 Flash's behavior, the token-efficiency changes and the coding/agentic gains can shift outputs enough to matter, even though the underlying intelligence score hasn't moved. Re-validate before switching rather than assuming a drop-in replacement. Outside of those two cases, there's no capability you lose by moving to 3.6 Flash.

Which one to choose

For almost anyone already running 3.5 Flash, the default answer is to move to 3.6 Flash: the intelligence you're getting is unchanged, the price per output token and tokens-per-task both drop, throughput is the fastest tracked, and the coding, agentic, and long-context numbers all move in the same favorable direction. Stay on 3.5 Flash a little longer only if you're blocked by launch-window reliability concerns or you have evals bound tightly enough to old token behavior that you need time to re-validate. There's no scenario here where picking 3.5 Flash for a brand-new project makes more sense than starting on 3.6.

FAQ

Is Gemini 3.6 Flash smarter than 3.5 Flash?

No — they score the same (50) on the Artificial Analysis Intelligence Index. Google's own coding, agentic, and long-context benchmarks show real gains, but the independent intelligence measure is unchanged.

Is it cheaper?

Yes. Output drops to $7.50 per 1M (from $9.00), input is $1.50 with $0.15 cached input, and it uses about 17% fewer output tokens per task — so cost per task falls on both the rate and the token-count axis.

Should I migrate?

For most 3.5 Flash workloads, yes — you get lower cost, higher speed, and equal or better output, plus stronger coding and agentic scores. Re-run your evals first if your prompts are tightly tuned, and pin versions if launch-window reliability matters to you.

Did anything get worse?

Nothing structural. The main caveats are launch-window capacity and reliability reports, one account of weaker frontend/spatial-reasoning output, and a slow time-to-first-token (~11.5s at high thinking effort), which can matter for interactive use.

How much better is 3.6 Flash at coding and agentic tasks?

By Google's own vendor comparisons: SWE-Bench Pro 58.7% (vs 55.1%), DeepSWE v1.1 49% (vs 37%), Terminal-Bench 2.1 78.0% (vs 76.2%), MLE-Bench 63.9% (vs 49.7%), and OSWorld-Verified 83.0% (vs 78.4%). All are self-reported, not independently re-run, so treat them as directional.

What about long-context performance?

This is the biggest reported jump: GDM-MRCR v2 recall at a 1M-token context length rises to 54.0% from under 27% — roughly double. It's also a vendor-reported figure, but it's consistent with the model's lower output-token count on comparable tasks.

Does the price cut apply to input tokens too?

3.6 Flash's input price is $1.50 per 1M with $0.15 for cached input. 3.5 Flash's exact current input rate isn't restated in 3.6's launch materials, so check the live pricing page rather than assuming it changed.

Is there a new knowledge cutoff?

Yes — 3.6 Flash carries a March 2026 knowledge cutoff. 3.5 Flash's cutoff isn't restated in the comparison materials, but 3.6's is naturally more recent given its later release date.

Bottom line

Gemini 3.6 Flash vs Gemini 3.5 Flash is the cleanest kind of upgrade to reason about: same measured intelligence, same capability envelope, lower price, fewer tokens, more speed, and consistent — if vendor-reported — gains on coding, agentic, and especially long-context tasks. If you're on 3.5 Flash and cost, latency, or agentic reliability is your constraint, move, after a quick eval pass and with versions pinned during the launch window. If you were hoping the ".6" meant a smarter model outright, it doesn't; for that, you're waiting on Gemini 3.5 Pro or Gemini 4. See the comparisons below to weigh 3.6 Flash against the non-Google models in its class.