Gemini 3.7 Flash: 340 Tokens/Sec Hides a 9.8s Catch

13 min read

Google shipped Gemini 3.7 Flash on August 13, 2026, and the number everyone is quoting is 340 tokens per second.

That number is real. It is also the most misread spec of the year.

Short version: Gemini 3.7 Flash streams output at 340.1 tokens per second, about five times the 68.6 t/s median for reasoning models and roughly six times faster than Claude Opus 5 at max effort. It scores 56 on the Artificial Analysis Intelligence Index, four points above Gemini 3.6 Flash. But its time to first token is 9.83 seconds against a median of 2.87 seconds. It is a sprinter that needs ten seconds to get off the blocks.

That one gap decides whether this model belongs in your product or in your terminal. Most of the coverage this week got it backwards.

Key takeaways

• Speed: 340.1 output tokens/sec, roughly 5x the reasoning-model median of 68.6 t/s
• Intelligence: 56 on the Artificial Analysis index, up 4 points from Gemini 3.6 Flash, still below Opus 5 (63)
• The catch: 9.83 second time to first token, about 3.4x slower to start than the 2.87s median
• Price: $0.75 / $3.75 per 1M input/output tokens, but that is introductory and doubles on January 1, 2027
• Counter-take: peer-reviewed 2026 research found users rate instant AI answers as less thoughtful than slow ones
• Same day, DeepSeek open-sourced its own agent harness under MIT, and it runs in your browser

What actually changed from Gemini 3.6 Flash?

Gemini 3.6 Flash landed only a few weeks ago. That is the part that should mess with your head a little. We are now getting meaningful model upgrades on a cadence measured in weeks.

Here is the honest comparison:

Spec	Gemini 3.6 Flash	Gemini 3.7 Flash (high)
Intelligence Index	52	56
Output speed	225.1 t/s	340.1 t/s
Time to first token	18.68s	9.83s
Input price	$1.50 / 1M	$0.75 / 1M (intro)
Output price	$7.50 / 1M	$3.75 / 1M (intro)
Context window	1M tokens	1M tokens
Cost per index task	$0.57	$0.40

On coding specifically, Google's own numbers show FrontierCode 1.1 Main going from 34.4% to 43.6%, and DeepSWE v1.1 jumping from 49.0% to 65.3%. That DeepSWE number is a 16 point swing between two releases weeks apart. You can read the details on the Gemini 3.7 Flash model card and Google's announcement post.

It also beats Opus 5 on one metric that matters more than people realise. On pass^5, which measures whether a model can solve a task correctly five times out of five instead of getting lucky once, Gemini 3.7 Flash hits 60% against Opus 5 max at 54%. Consistency is the thing agents actually need, because an agent that is right once and wrong four times will happily corrupt your codebase.

So it got smarter, cheaper per task, and dramatically faster at streaming.

Now the part nobody puts in the headline.

So what is the 9.8 second catch?

There are two completely different kinds of "fast" and the marketing blurs them on purpose.

Time to first token is how long you stare at a blinking cursor before anything appears. Output speed is how fast text flows once it starts.

Gemini 3.7 Flash is elite at the second one and below average at the first. 9.83 seconds to first token, against a 2.87 second median. That is not a rounding error. That is roughly 3.4x the wait before you see a single character.

Give Google credit where it is due: this is a genuine improvement. Gemini 3.6 Flash took 18.68 seconds to first token. They nearly halved it. The model got faster on both axes at once, which is not the usual trade.

But "much better than before" and "good enough for a user" are different bars. It is still more than three times the median wait.

Why is it slow to start? It is a reasoning model. It thinks before it speaks, and that thinking happens before the stream opens.

Here is why this matters more than the benchmark chart suggests. The usability thresholds for interactive systems have been stable for forty years: about 0.1 seconds feels instant, 1 second keeps your train of thought intact, and 10 seconds is where attention breaks and people switch tabs.

Gemini 3.7 Flash starts talking at 9.83 seconds. It lands right on the edge of the attention cliff before it says anything at all.

A model that streams at 340 tokens per second but waits 9.8 seconds to start is not a chatbot model. It is a throughput model wearing a speed costume.

If you are building a customer support bot and you swap in Gemini 3.7 Flash because you read "340 tokens per second," your users will feel it get slower. The gold standard for chat interfaces is sub-600ms to first token. You would be shipping something 16 times over that budget.

[Image: Side-by-side timeline diagram showing two models, one with short TTFT and slow stream, one with long TTFT and fast stream, both finishing at the same time]

Does faster AI actually make a better product?

This is where I have to push back on the entire narrative, including the version of it I believed a week ago.

The assumption everyone repeats is simple: response time goes down, user experience goes up. Cut a 14 second wait to 2 seconds and people are happier. It sounds obviously true.

A study published at CHI 2026 tested it properly and got the opposite result.

Researchers ran a 2x3 between-subjects experiment with 240 participants. They varied the task type (creative work versus advice) and the response latency: 2 seconds, 9 seconds, or 20 seconds. Same model. Same quality of output. Only the wait changed.

Participants who waited 2 seconds rated the answers as less thoughtful than participants who waited 9 or 20 seconds.

The actual numbers, on a 7 point scale:

• Thoughtfulness at 2s: 5.76
• Thoughtfulness at 9s: 6.09 (statistically significant, p = .008)
• Thoughtfulness at 20s: 6.11 (p = .040)

Usefulness followed a similar curve and peaked in the middle, at 6.44 for the 9 second group versus 6.19 for the 2 second group.

The researchers call it the effort heuristic. We judge quality by visible effort. An answer that appears instantly reads as a lookup. An answer that takes nine seconds reads as thinking. You can read the full paper on arXiv.

One more detail worth sitting with: prompting frequency showed no significant effect from latency. People did not give up or interact less when it was slow. They just respected the slow answers more.

So the "instant is always better" instinct is wrong for consumer-facing AI, and it is wrong in a measurable way.

Does that mean speed does not matter? No. It means speed matters enormously in one place and can actively hurt you in another. Which brings us to the split.

Where does the speed actually pay off?

Speed pays off when a human is not watching the stream.

That is the whole rule. Write it on a sticky note.

When you fire off an agentic task and go make chai, you do not care about time to first token. You care about total wall-clock time to a finished result. That is where a 340 t/s model demolishes a 52 t/s model.

Run the math honestly. Opus 5 at max effort streams at 52.7 t/s. Gemini 3.7 Flash streams at 340.1 t/s. That is 6.45x on the generation phase.

But do not pretend that means "6x faster work." Real agentic runs are mostly tool calls, file reads, and searches, and those run at network speed regardless of your model. A realistic long task might be 40% generation and 60% waiting on tools. Apply Amdahl's law and your actual speedup is closer to 1.6x, not 6.45x.

Still worth having. Just not the number the hype implies.

There is a second cost too. Gemini 3.7 Flash scores 56 on intelligence. Opus 5 scores 63. On hard architectural work, you will spend some of your saved time re-prompting. The Artificial Analysis Time per Task figure of 1.7 (40% faster than GPT-5.6 Terra at max) already bakes some of this in, which makes it a more honest metric than raw t/s.

I have not put this into my own production pipeline yet, so I am not going to invent a benchmark for you. What I did do is work out the routing rule I am going to use, because the real skill in 2026 is not picking the best model. It is knowing which of six models to send each request to.

// Route on one question: is a human waiting for the first token?
function pickModel(task) {
  // Human staring at a cursor. TTFT is the only metric that matters.
  // Every reasoning model is disqualified here. Drop the effort tier
  // or use a non-reasoning model and eat the intelligence hit.
  if (task.userFacing) return 'non-reasoning-low-latency';

  // Background agent. Nobody is watching. Throughput wins.
  if (task.longHorizon && task.complexity < 0.7) {
    return 'gemini-3.7-flash';   // 340 t/s, index 56, 9.83s TTFT
  }

  // Architecture, security, anything expensive to get wrong.
  return 'claude-opus-5';        // 52.7 t/s, index 63
}

Notice the first branch does not name a Gemini Flash tier. That is deliberate. Neither 3.6 nor 3.7 Flash is a chat-latency model, and pretending otherwise is how you ship a support bot that feels broken.

That is genuinely how I think about it now. Time to first token for humans. Tokens per second for machines.

Is the price really 50% off?

Yes, and also no, and the "no" part is going to bite people.

The $0.75 input and $3.75 output per million tokens is introductory pricing that expires December 31, 2026. On January 1, 2027, it becomes $1.50 and $7.50. That is a 100% increase, and it arrives in about four and a half months.

And $1.50/$7.50 is exactly what Gemini 3.6 Flash lists at today. So "half the price of 3.6 Flash" really means "half price until December, then identical." The discount is a launch promo, not a permanent price cut. Cute framing.

What is genuinely good is the 90% cache discount. If you are running an agent that re-reads the same large codebase or system prompt on every turn, that is where your bill actually gets cut, and it is a bigger real-world saving than the headline rate. Per Artificial Analysis, the cost per Intelligence Index task is $0.40, about 30% below Gemini 3.6 Flash.

Budget for the January cliff now. If your unit economics only work at $0.75, you do not have a business model, you have a coupon.

What is DeepSeek Harness and why did it drop the same day?

Same day, August 13, DeepSeek open-sourced DeepSeek Harness v0.1 under an MIT license. It is not a model. It is the agent layer, the thing that turns a model into something that can edit your files.

Their framing is a formula: Model + Harness = Agent.

The interesting choice is that it runs in a browser:

npx @deepseek-ai/dsh web
# then open http://localhost:3080

You point it at a workspace folder, drop in an API key, and go. It ships four modes:

1. Standard for the full agent with file editing, shell, search, planning, subagents and workflows
2. Code which exposes tools through a TypeScript SDK so the model composes multi-step operations in one program
3. Minimal which is a two-tool agent with persistent bash and str_replace_editor
4. Creator for authoring your own agent presets

The feature I actually care about is Trajectory. It logs every single thing the model sees: the system prompt, its reasoning, tool calls, tool results, subagent scheduling, and context injection. Append-only. You can resume, fork, search and replay from the same event stream.

That is a big deal, and not for the reason people think.

Most developers using AI agents right now have no idea what is in their context window. You are debugging a black box. When your agent does something insane, you have no log to inspect. Trajectory turns that into a readable event stream, which means you can finally answer "why did it do that" with evidence instead of vibes.

It is also plugin-first, built on the Cordis kernel. Models, tools, sessions, sandboxes, storage, the agent loop, even the UI are all plugins you can swap in config without touching the source. Source is on GitHub.

And because it supports OpenRouter, you can run Gemini 3.7 Flash inside DeepSeek's harness. The model and the harness fully decoupled. That is the actual story of August 13, and it is bigger than either release on its own.

The thing worth paying attention to

Speed became a spec sheet line item this week. Not a footnote.

For two years the only question was "how smart is it." Now there is a second axis, and Artificial Analysis literally published a Pareto frontier chart for intelligence versus time per task. When benchmark sites start plotting a second axis, the market has decided that axis matters.

Here is my honest read. Gemini 3.7 Flash is not the best model available. It is number 17 out of 188 on intelligence. But being 6x faster than the smartest model at 89% of its capability is a real trade, and for background agentic work, that trade is usually correct.

The thing I would not do is swap it into anything with a user waiting at the other end. The TTFT will hurt you, and the CHI research says the perceived quality benefit you were hoping for might not even exist.

What to actually do with this

• Check your TTFT before your t/s. If a human is waiting, first token is the only number that counts.
• Stop looking for one model. Build a routing layer. Cheap and fast for volume, slow and smart for hard problems.
• Put a calendar reminder on December 31, 2026. Model your costs at $1.50/$7.50, not the intro rate.
• Turn on prompt caching. The 90% cache discount will save you more than the intro pricing did.
• Try DeepSeek Harness for one afternoon, just to read a Trajectory log. Seeing your actual context window changes how you prompt.
• Stop optimising perceived speed in consumer apps. A visible "thinking" state may score better than an instant answer.

If you are building anything with AI in the loop, the skill that compounds from here is not prompt engineering. It is knowing the cost, speed and accuracy profile of six models well enough to route between them without thinking. That is the job now.

While you are wiring up API calls and staring at raw payloads, our JSON Formatter will save you from reading minified model responses in a terminal, and if you are debugging auth on those endpoints, the JWT decoder does the boring part for you.

Frequently Asked Questions

How fast is Gemini 3.7 Flash?

Gemini 3.7 Flash generates output at 340.1 tokens per second, roughly five times the 68.6 tokens per second median for reasoning models and about 6.5x faster than Claude Opus 5 at max effort. However, its time to first token is 9.83 seconds, which is slower than the 2.87 second median. It is fast at streaming but slow to start.

Is Gemini 3.7 Flash better than Claude Opus 5?

Not on raw intelligence. Gemini 3.7 Flash scores 56 on the Artificial Analysis Intelligence Index while Claude Opus 5 at max effort scores 63. Gemini 3.7 Flash is around 6.5x faster and far cheaper, and it beats Opus 5 on pass^5 consistency at 60% versus 54%. For hard architectural work Opus 5 is still the better pick, and for high-volume background tasks Gemini 3.7 Flash usually wins on cost and time.

How much does Gemini 3.7 Flash cost?

Introductory pricing is $0.75 per million input tokens and $3.75 per million output tokens, valid through December 31, 2026. From January 1, 2027, standard pricing of $1.50 and $7.50 per million tokens applies. There is also a 90% cache discount, which matters more than the headline rate for repeated long-context agent runs.

Is DeepSeek Harness free to use?

Yes. DeepSeek Harness v0.1 was released on August 13, 2026 as open source under the MIT license. You run it with npx @deepseek-ai/dsh web and it opens in your browser at localhost:3080. You still pay for whatever model API you connect it to, and it supports multiple providers including OpenRouter.

Does faster AI mean a better user experience?

Not always. A CHI 2026 study with 240 participants found that people rated AI answers delivered after 2 seconds as significantly less thoughtful than identical answers delivered after 9 or 20 seconds. Users read a delay as deliberation. Speed clearly helps developer feedback loops and background agents, but for consumer-facing AI, an instant answer can lower perceived quality.

Building something with AI in the loop and drowning in raw API responses? Clean them up fast with our free developer tools.

Written by Adithya Guttha, Founder of Art of Code.