Gemini 3.5 Flash generates 2.6x the output tokens per second of Gemini 3.1 Pro, costs 25% less per token, and edges out Pro on Artificial Analysis's Intelligence Index (50 vs 46). Gemini 3.1 Pro still leads by 5 points on ARC-AGI-2 (77.1% vs 72.1%), and Flash's score on long-context retrieval drops from 84.9% to 77.3% once you push past 128k tokens. Which model to use depends on the task: Flash optimizes for throughput and tool-calling latency, Pro optimizes for multi-step reasoning depth, and aggregate benchmarks average those two priorities into a single score that hides which one your workload actually needs.
Benchmark scorecard: where each model actually leads
| Metric | Gemini 3.5 Flash | Gemini 3.1 Pro | Winner |
|---|---|---|---|
| Intelligence Index (Artificial Analysis) | 50 | 46 | Flash |
| ARC-AGI-2, abstract reasoning (BenchLM) | 72.1% | 77.1% | Pro |
| MRCR v2 at 128k context (nxcode) | 77.3% (down from 84.9% at shorter context) | not publicly reported at same length | Insufficient data |
| Multimodal average score (BenchLM) | 83.8 | 82.6 | Flash |
| Output speed (BenchLM) | 284.2 tok/s | 109 tok/s | Flash (2.6x) |
| GDPval-AA Elo, real-world agent tasks (apiyi) | 1656 | 1314 | Flash |
Flash wins on the metrics that measure throughput and general-purpose task handling. Pro has a clear, documented lead on ARC-AGI-2 reasoning depth; on long-context retrieval, Flash has a documented regression past 128k tokens but Pro's equivalent score isn't publicly available, so call that one inconclusive rather than a Pro win. That split maps directly onto what kind of task you're running, which is more useful than the single aggregate Intelligence Index number.
One methodology caveat from BenchLM's own comparison: of the roughly 34 benchmarks where both models have published results, only 3 categories are directly comparable — Pro has exclusive results on 14 benchmarks, Flash on 17, and thinking-budget settings aren't always matched between the two. Treat the table above as directionally reliable; the ARC-AGI-2 and MRCR v2 gaps are large enough to trust, but a 1-2 point difference on a shared metric shouldn't be read as decisive.
Where Flash's lead breaks down
The ARC-AGI-2 gap (5 points) is the largest single-category difference BenchLM's comparison found between the two models. ARC-AGI-2 is built specifically to resist pattern-matching shortcuts, so a 5-point gap there is a stronger signal about reasoning depth than a similar gap on a more conventional benchmark. nxcode's MRCR v2 result adds a second data point in the same direction: Flash's own retrieval accuracy drops from 84.9% to 77.3% as context grows toward 128k tokens. Pro's score at the same length isn't publicly reported, so this isn't a documented head-to-head loss for Pro — but it is a documented regression for Flash that Pro's benchmark table doesn't show.
Anecdotal note, not benchmark evidence: a Reddit r/GeminiAI thread asking users which model they prefer for hard tasks got commenters describing Flash as beating Pro "in everything except long context, abstract [reasoning]." It's a handful of opinions, not data — but it happens to describe the same two exceptions the benchmarks show, which is a mildly useful sanity check rather than proof of anything on its own.
Pricing and caching: the real cost picture
Base pricing narrows the price advantage more than it first appears:
- Gemini 3.5 Flash: $1.50 / million input tokens, $9 / million output tokens
- Gemini 3.1 Pro: $2 / million input tokens, $12 / million output tokens
That's a 25% discount on paper, not the 4-8x gap Flash previously held over older Pro models. The bigger lever is caching:
- Flash cache writes are free; cached input costs $0.15/million tokens
- Pro cache writes cost $0.38/million tokens; cached input costs $0.50/million tokens — over 3x Flash's cached-input rate
For any workflow that re-sends the same system prompt or document context across multiple turns — chat agents, coding assistants with a persistent codebase context, multi-turn support bots — that caching gap compounds fast. A single request barely shows the difference; a thousand-turn agent session does.
The gap also isn't constant. apiyi's pricing breakdown notes that past roughly 200k tokens of context, the price difference between the two models compresses to 25-50%, because both models' per-token economics converge at that scale. If your workload is dominated by very long single-shot documents rather than short repeated calls, the pricing argument for Flash weakens.
A concrete example: a support-bot workflow that sends 1M cached input tokens and generates 500K output tokens per day. On Flash, that's $0 for the cache write plus $0.15 x 1 (cached input) + $9 x 0.5 (output) = $4.65/day. On Pro, the same workload costs $0.38 (cache write, one-time) + $0.50 x 1 (cached input) + $12 x 0.5 (output) = roughly $6.88/day on day one, settling to $6.50/day after the first write. Over a month, that's the difference between about $140 and $195 — before counting Pro's deeper reasoning on any request that actually needs it.
Agent loops: why Flash wins on speed, not always on reliability
nxcode's agent-loop benchmark ran an 8-step agent loop and clocked Flash completing the full sequence in roughly 25 seconds against Pro's 100 seconds — a 4x difference that compounds with every additional step. On GDPval-AA, a benchmark built around real-world knowledge-work agent tasks, Flash's Elo score (1656) beats Pro's (1314) by 342 points, the single largest gap in the entire benchmark table.
The caveat: that speed and score advantage assumes the agent loop runs cleanly. The same ARC-AGI-2 and MRCR v2 gaps that show up in reasoning and long-context tasks are a reasonable basis to expect Flash is also less forgiving when a tool call returns something unexpected mid-loop and the agent has to replan — that's an inference from the reasoning-depth data above, not a separately benchmarked claim. If your agent runs supervised, with a human checking output between steps, Flash's speed is close to a free win. If it runs unsupervised for many steps with no human in the loop, Pro's reasoning margin is the safer bet until someone publishes failure-rate data for both.
Which one should you use: a task-based decision matrix
| Task type | Recommended model | Why |
|---|---|---|
| Everyday coding (tests, PR review, translation between languages) | Flash | Speed and cost win, reasoning depth isn't the bottleneck |
| Deep refactors, novel algorithm design | Pro | ARC-AGI-2 gap shows up directly in multi-step logical reasoning |
| Long-document retrieval (contracts, research corpora past 128k tokens) | Pro | Flash has a documented MRCR v2 regression at this length; Pro's isn't published but the safer default is the model without a known weak point |
| High-volume batch generation | Flash | Free cache writes and 2.6x throughput matter most at scale |
| Supervised agent workflows with a human checking output | Flash | Speed advantage without the unsupervised-reliability risk |
| Unsupervised, high-stakes agent chains | Pro | Reasoning-depth margin is the safer bet with no human catching mid-loop errors |
| Frequent multi-turn calls reusing the same context | Flash | Cached-input pricing is roughly a third of Pro's |
A simple default rule covers most of the matrix above: send requests to Flash unless one of three conditions is true — context exceeds 128k tokens and retrieval accuracy matters, the task is abstract/multi-step reasoning (novel algorithms, legal or research synthesis), or the agent runs unsupervised for more than a handful of steps. Any one of those three tips the call toward Pro; none of them present, Flash's speed and cache pricing make it the cheaper default.
FAQ
Is Gemini 3.5 Flash better than 3.1 Pro?
On speed, cost, and general-purpose benchmarks, yes. On abstract reasoning (ARC-AGI-2), Gemini 3.1 Pro still leads by 5 points. On long-context retrieval past 128k tokens, Flash has a documented regression and Pro's equivalent score isn't published, so treat that comparison as unresolved rather than a confirmed Pro win. Which one is "better" depends on which of those categories your task falls into.
How much cheaper is Gemini 3.5 Flash than 3.1 Pro?
About 25% cheaper on base input/output pricing ($1.50/$9 vs $2/$12 per million tokens). The bigger savings show up in caching: Flash's cache writes are free and cached input is roughly a third of Pro's rate, which matters most for multi-turn or high-volume workloads.
Is Gemini 3.5 Flash good for coding?
Yes, for day-to-day work — test generation, PR review, translating code between languages. For deep refactors or novel algorithm design, Pro's edge on abstract reasoning benchmarks tends to show up in output quality.
Does Gemini 3.5 Flash handle long context well?
At shorter context lengths, yes — MRCR v2 retrieval accuracy holds at 84.9%. Past 128k tokens that drops to 77.3%, which is a meaningful gap for tasks like multi-document contract review. Gemini 3.1 Pro's score at the same length hasn't been published, so treat this as a known Flash limitation rather than a confirmed Pro advantage.
Bottom line
Gemini 3.5 Flash is the better default for most day-to-day and high-volume work — it's faster, cheaper on cache, and close enough on general benchmarks that the trade-off rarely matters. Gemini 3.1 Pro earns its higher cost on abstract reasoning and unsupervised agent chains; on long documents past 128k tokens, Flash's own numbers show a weak point that Pro's don't confirm or rule out, so treat that one as worth testing yourself before committing either way.
This comparison is built from public benchmark data (Artificial Analysis, BenchLM, nxcode, and apiyi), not first-hand API testing. Gemini 3.1 Pro launched with a reasoning-focused positioning distinct from Flash's speed focus. As of this writing, Gemini 3.5 Pro has not yet shipped — reporting points to a July 2026 release — so treat this as a snapshot that both models, and this comparison, will need revisiting once Pro's next version lands.