01Context: the Flash cadence war

To understand why Gemini 3.8 Flash exists at all, you have to understand the position Google was in during the summer of 2026. This was not a company comfortably leading the frontier — it was a company under visible pressure, iterating publicly at a pace that reads more like a startup shipping patches than a lab gating releases behind months of alignment reviews.

The pressure came from three directions. First, organizational turbulence: in early August, Google DeepMind CEO Demis Hassabis stepped down from the chief executive role to become chairman of the AI research business, with long-time research lead Koray Kavukcuoglu taking over under the less exalted title of SVP. Second, missed expectations: Google failed to ship Gemini 3.5 Pro in June as promised, and the model it did ship — Gemini 3.5 Flash, unveiled at I/O on May 19 — was fast and cheap but modest in its benchmark metrics, and over the following months was overshadowed on intelligence scores by open-weight models from Chinese AI companies. Third, the coding gap: throughout 2026, Anthropic's and OpenAI's flagships dominated the agentic-coding conversation that developers actually care about.

Google's answer to all three was cadence. The Flash line became the delivery vehicle:

One day before launch, the Wall Street Journal reported that Google's AI research unit was preparing the model — internally codenamed "Skimaki" — as an effort to "narrow the gap on coding ability" against rivals. Two details from that reporting matter for the technical record. First, Google employees had been testing the model internally on Jetski, Google's side-by-side evaluation platform, and engineers reportedly preferred 3.8 Flash to Anthropic's Opus model for coding work. Second, Alphabet shares moved 0.7% higher in after-hours trading on the report alone — a measure of how much narrative pressure had built around Google's model-making reputation.

02What Gemini 3.8 Flash actually is

Gemini 3.8 Flash is a proprietary, API-served multimodal reasoning model from Google DeepMind — not a new architecture. The model card is unusually direct on this point: 3.8 Flash "is the next iteration in the Gemini 3 model family, building on Gemini 3.7 Flash," and for architecture, training dataset, hardware, and software details it simply points readers to the 3.7 Flash model card. Parameter counts are not disclosed, weights are not published, and no self-hosting path exists.

What is new is the behavioral profile and the packaging. The release actually contains two models sharing one foundational intelligence:

• Gemini 3.8 Flash (gemini-3.8-flash) — generally available from day one, positioned as "our most intelligent Flash model, engineered for long-horizon software engineering, autonomous agents, and complex enterprise workflows."
• Gemini 3.8 Flash Cyber — the same core with a cybersecurity-tuned mitigation set, available only to vetted defenders (government authorities, critical infrastructure operators, software maintainers) through the new Fairwind Program. Covered in depth in section 7.

Specification sheet

Sources: Gemini 3.8 Flash model card (Google DeepMind), "What's new in Gemini 3.8 Flash" (ai.google.dev), Gemini API pricing page.

The details that matter to practitioners

The minimal thinking level is gone. Earlier Flash models exposed a minimal effort tier for near-instant responses. On 3.8 Flash it is not merely deprecated — the API errors out if you request it. If your production pipeline was tuned to minimal on 3.5/3.6/3.7, that is a hard breaking change, and the closest migration target is low. The removal is philosophically consistent with the whole release: this model is designed to think, and Google is not pretending otherwise.

The API surface is the new Interactions API. Google's recommended integration is now client.interactions.create() (REST: POST /v1beta/interactions), not the legacy generateContent endpoint. Multi-turn state moves server-side via previous_interaction_id, which changes how you structure conversation history in agents. The full migration checklist is in section 8.

Output pricing includes thinking tokens. There is no separate reasoning-token line item — whatever the model emits, visible reasoning included, bills at the output rate. This matters when you compare 3.8 against a "same-priced" 3.7 workload, because 3.8 thinks longer by design. One independent measurement (The Register, citing Artificial Analysis data) put the effective per-task cost increase at roughly 40% even though the per-token price is identical.

Knowledge cutoff is March 2026 — recent for a September release — but the model card carries an honest caveat inherited from the Gemini 3 family: for some domains, effective knowledge dates to January 2025. For agentic workflows that ground with search tools this barely matters; for offline knowledge work it can, and the card says so explicitly.

03The design change: "works harder"

Every model launch claims intelligence gains. What makes 3.8 Flash technically interesting is that Google is explicit about the mechanism — and the mechanism is not a bigger network, a longer context, or a new attention variant. It is a behavioral contract: the same model, trained to spend more compute per task.

Strip the marketing language and three concrete mechanisms remain:

1. Smaller, more granular reasoning steps. Rather than compressing a chain of thought into fewer, larger leaps, the model decomposes hard problems into finer increments — which reduces compounding errors at the cost of more emitted tokens.
2. Iterative tool invocation. The model calls tools repeatedly in a loop, consuming intermediate results and re-querying when outputs look wrong, instead of one-shotting a tool call and hallucinating around a bad result.
3. Self-verification. The model checks its own work mid-task — re-reading generated code, re-validating constraints — before committing to an answer. Google's developer docs describe this as verifying "its work along the way."

The API docs phrase the trade-off with unusual candor: "Not every workflow needs this level of verification." That sentence deserves attention. It is Google telling you, in an official launch document, that the model's extra diligence is a cost you may not want to pay — and explicitly noting that 3.7 Flash "remains fully supported" for efficiency-first workloads. When a vendor ships an upgrade and simultaneously tells you when not to use it, that is signal, not hedging.

How they trained it: recursive agentic loops

The announcement reveals one genuinely novel training detail: both 3.8 variants are "further accelerated by long-running agentic loops designed to recursively evaluate and refine the underlying models." Read that carefully — the training pipeline itself runs extended agent sessions, uses their outcomes to evaluate the model, and feeds refinements back in. This is reinforcement-through-deployment at a cadence we rarely see acknowledged in launch posts, and it plausibly explains both the three-week turnaround and where the gains landed: agentic loops train agentic behavior, and that is precisely what improved (terminal tasks, tool use, multi-step domain work) while static knowledge exams did not.

The second training lever is the domain: Google attributes the shared core's coding and reasoning gains partly to "rigorous training in the highly demanding domain of cybersecurity." Vulnerability discovery and patching are, mechanically, long-horizon code comprehension and precise editing under adversarial constraints — exactly the skill profile the general model needed. The Cyber variant is the specialist deployment of a training program the whole model family went through; the "two products, one intelligence" framing in the announcement is literal.

The effort dial, quantified

Because "works harder" is tunable, the model you actually buy depends on how you set thinking_level. Artificial Analysis measured the three settings independently on their v4.1.1 Intelligence Index:

Artificial Analysis, "Gemini 3.8 Flash Models — Release Intelligence," Sep 3, 2026. Cost per task is a weighted average across the nine evaluations in the index, including reasoning tokens. Note the price spread: 2.4× from low to high, with 7 index points to show for it.

That table is the release in miniature. The high-effort setting buys seven index points over low and costs 2.4× more per task; medium — the default — sits near the middle on every axis. Speed barely moves across settings (302–313 t/s is a 4% band), which tells you the effort dial changes how much the model thinks, not how fast it streams once it starts. The right mental model is not "three models" but one model with a compute-per-task slider — and the fact that Google defaults it to medium rather than high is itself informative about where they think the value curve bends.

04Benchmarks: 3.8 vs 3.7 Flash

Google published a full head-to-head against 3.7 Flash in its developer documentation, and the pattern in the data is more informative than any single number. Every benchmark that involves executing something — running terminal commands, orchestrating tools, completing banking workflows — jumped by 4 to 9 points. Every benchmark that involves knowing something on paper moved a point and change, or went flat.

Source: Google developer documentation and launch materials as compiled by DataCamp (Sep 2, 2026) and Google's announcement. All scores pass@1, single attempt.

Reading the deltas honestly

The Terminal-Bench jump is the headline and it is real. A 9.2-point gain on a benchmark that measures whether a model can actually complete command-line tasks — run tools, read output, recover from errors, finish the job — is a step change, not noise. For anyone building coding agents, this is the number that predicts fewer failed loops and abandoned sessions. It also matches the design mechanism from section 3: iterative tool calling and error recovery are precisely what Terminal-Bench rewards, and precisely what "works harder" trains.

The τ³-Bench Banking gain (+7.2) is the underrated one. This benchmark is multi-turn and tool-reliant — an agent must hold a conversation, call policy-constrained tools, and integrate results over several exchanges. A model that scores 38.1% where its predecessor scored 30.9% is a model that survives longer horizons without derailing. Google's claim of "substantially reducing failed loops and errors" in autonomous agents maps directly onto this row of the table.

SWE-Bench Pro's +1.2 is the honest counterweight. On repository-level issue fixing — the task that most closely resembles "resolve this GitHub issue in my codebase" — 3.8 Flash is only marginally better than 3.7. The gains that did land in repository-level work went to SWE-Atlas (+3.9), a newer and harder eval. If you were hoping 3.8 Flash would transform straightforward bug-fixing throughput, the data says it won't; if you need it to survive complex multi-file refactors and long agentic sessions, it might.

Humanity's Last Exam is flat, and that is consistent, not damning. HLE rewards deep knowledge and exam-style reasoning under time constraints — a capability profile that has nothing to do with how many tool calls you make or how carefully you verify output. A behavior-focused training push predictably does not move it. The flip side matters for procurement: if your workload is "answer hard open-ended questions," 3.8 Flash is not an upgrade over 3.7 Flash, and paying 40% more tokens for the privilege is a bad trade.

The long-horizon claim

On DeepSWE v1.1 — the long-horizon software engineering benchmark where agents must autonomously solve complex engineering problems end-to-end — Google's published claim is qualitative: 3.8 Flash "outperforms most larger frontier models... at a fraction of the cost." No exact percentage appears in the launch materials. Independent measurements (section 5) put 3.8 Flash around 71% on DeepSWE-family evals — ahead of most of the field, but behind the two flagships it is usually compared against. The word "most" in Google's sentence is doing precise, defensible work.

The strongest long-horizon datapoint is instead a partner claim: Glean, whose product runs document-heavy knowledge workflows, reported that 3.8 Flash completes more than three times as many tasks as 3.7 Flash in their evaluations of long-running workflows. A 3× completion-rate difference at the same token price is a bigger operational delta than any single benchmark score — though as a vendor-partner quote, it deserves the same skepticism you would apply to any launch-day testimonial.

05Against the frontier

Flash-tier positioning means every claim has to survive comparison with models costing 5–13× more per token. Two independent sources — Artificial Analysis and Beam AI's launch-day testing — provide the comparison points.

Source: Beam AI independent launch-day measurements (Sep 2, 2026). Terminal-Bench measured at 89.4% in Beam's harness vs Google's official 90.8% — harness differences of a point or so are normal. "Best" per row in bold.

The pattern repeats with almost mechanical consistency: 3.8 Flash wins or ties wherever the task is domain-bounded agent work, and loses wherever the task is the hardest open-ended engineering. On finance and legal agent benchmarks it doesn't just approach the frontier — it leads it, by 2.8 points over Opus 5 on Vals Finance and by 50% relative margin on Harvey's Legal. On Terminal-Bench it is statistically tied with Opus 5. But on DeepSWE v1, the benchmark designed to be maximally hostile — long horizons, complex dependencies, multi-file coherence — the order restores itself: Opus 5 at 74.0%, GPT-5.6 Sol at 72.7%, 3.8 Flash at 71.0%.

Beam's routing conclusion is the right one: this is not a "replace your frontier model" result, it is a "route the right work to it" result. Finance-and-operations agents, high-volume latency-sensitive calls, and mid-difficulty terminal work belong on 3.8 Flash; the hardest long-horizon engineering and highest-stakes decisions stay on a frontier model — if the frontier model's 6–7× price premium is justified by the marginal task-success rate in your workload.

The independent index: 59, level with the big spenders

Artificial Analysis's Intelligence Index (v4.1.1, nine evaluations including GDPval-AA v2, τ³-Banking, Terminal-Bench 2.1, SciCode, HLE, GPQA Diamond, CritPt, AA-Omniscience, and AA-LCR) provides the cleanest cross-model ladder. At high effort, Gemini 3.8 Flash scores 59 — three points above 3.7 Flash's 56 — and the company it keeps is the interesting part:

Source: The Register (Sep 2, 2026) and Artificial Analysis. Rank context: 3.8 Flash (high) sits at #27 of 636 tracked models. Estimated costs where AA's published per-task figure was not in the source.

Read as a ladder, the table says 3.8 Flash (at its most expensive effort setting) matches GPT-5.6 Sol at extra-high and Grok 4.6 at medium, sits seven points under the general-purpose leader Claude Fable 5.1, and does it at $0.58 per Intelligence Index task — the cheapest cost-to-intelligence ratio in its band. Artificial Analysis's own framing is that 3.8 Flash "reaches the Intelligence vs. Cost per Task Pareto frontier": no cheaper model scores higher, and no higher-scoring model at its level costs less. Fable 5.1, for contrast, costs about six times more per task at 66 points. Whether that 7-point intelligence gap is worth 6× the cost is exactly the routing question your workload should answer.

One more lens: category-level rankings

BenchLM, which aggregates only source-verified benchmark rows, scores 3.8 Flash at 75.4/100 — #11 of 230 tracked models — with a category profile that quietly complicates the launch narrative. Its strongest eligible category is Multimodal & Grounded (#17 of 36, "particularly strong for screenshots, documents, charts, and grounded multimodal workflows"). Agentic lands at #28 of 143 (81st percentile). Coding — the headline claim of the entire release — is actually its lowest eligible category at #36 of 148, albeit on only two source-displayable rows. The caveat matters: 12 published rows is thin coverage, and Google did not publish exact scores for several coding evals, which suppresses category ranks. But taken at face value, it is a useful reminder that "best coding Flash model" is a tier-relative claim, not a field-relative one.

06Speed and cost economics

Flash models are bought on unit economics, so this section is the decision-relevant one. Three numbers define the value proposition: ~305 tokens/second output (Artificial Analysis called it the fastest output speed they have measured — across all models, not just the Flash tier), 0.70 seconds to first answer token at low effort, and $0.58 per Intelligence Index task at high effort. Community latency testing broadly corroborates the speed story: in an r/singularity side-by-side, 3.8 Flash finished benchmark tasks 1.7–2.5 seconds faster than 3.7 Flash (on a ~45-second task) while consuming around 5% more tokens — faster and more verbose, exactly as designed.

One nuance on latency: BenchLM measured a 13.39-second time to first token on some runs, which looks contradictory until you note the difference — their figure includes reasoning tokens streamed before the answer begins, while AA's 0.70s measures time to the first answer token. At high effort, this model thinks for a while before it speaks. Budget for time-to-answer, not time-to-first-byte, when you set agent timeouts — the model card itself flags "occasional slowness or timeout issues" as a known limitation.

The full price sheet

Source: Google AI for Developers pricing page, Sep 2026. Output pricing includes thinking tokens. Batch limits: 200,000 requests per job, 100 concurrent jobs, 2 GB input files, 20 GB file storage.

Several structural facts are buried in that sheet and deserve to be surfaced:

• The intro price is a clock, not a category. Every Flash price shown — including the 50%-off batch tier — reverts to its full standard rate on January 1, 2027. The standard rate is exactly double the intro rate. Any unit-economics model built on $0.75 input needs a second model for January. The Register's framing — "doesn't cost too much (yet)" — is the correct reading.
• Batch at $0.375/$1.875 is the actual floor. For evals, backfills, and any workload that tolerates hours of latency, batch pricing makes 3.8 Flash one of the cheapest capable reasoning models on the market — and if you are running the eval suites from section 4 yourself, this is the tier to do it on.
• Caching reads at $0.075 are 90% off the intro input price. Agent loops that re-send large system prompts or document context on every turn — which is exactly what "iterative tool calling" workloads do — should treat context caching as mandatory, not optional, or the token overhead of the harder-working model compounds.
• The effort dial is a pricing tier in disguise. Section 3's table already showed the 2.4× per-task spread between low and high. Combined with batch vs standard, the real price surface of this "one model" spans from roughly $0.12 per task (batch + low effort) to $0.58 (standard + high), before caching optimizations.

Competitive price context

Rival pricing as compiled by DataCamp, Beam AI, and OpenRouter-community data (Sep 2026). Qwen3.8 Flash pricing from OpenRouter listings; capability comparison not like-for-like.

Two honest observations about this table. First, the "cheapest at its intelligence level" claim survives contact with the data — nothing between 59 and 66 index points is in 3.8 Flash's price neighborhood, and the only meaningfully cheaper option (Qwen3.8 Flash at $0.15) plays in a lower capability class. Second, the comparison that flatters 3.8 Flash the most is against the flagships' list prices; enterprise commitments, committed-use discounts, and agentic-bundle pricing can compress those gaps materially at scale, so treat the multiples as ceilings rather than quotes.

07Flash Cyber and the Fairwind Program

The second half of the release is, in some ways, the more strategically interesting half. Gemini 3.8 Flash Cyber shares the general model's foundational intelligence but ships with a "more permissive set of mitigations for cybersecurity" — a deliberately lowered guardrail set that makes the model willing to engage with vulnerability analysis, exploitation patterns, and security-sensitive code at a depth the standard model refuses. Because that same relaxation would be an attack surface in the wrong hands, access is not sold: it is granted, through a vetted program called Fairwind, to "trusted government authorities, as well as critical infrastructure operators and software maintainers," with prioritized access for applicants. Think of it as Google's answer to the dual-use dilemma that has kept every major lab's most security-capable models behind policy gates: same weights, different constitution, gated distribution.

The launch post is explicit about an ethical ordering that deserves note: Google "prioritized [vulnerability fixing] over offensive capabilities like exploitation." That choice is visible in the benchmark profile — Cyber's headline results are in finding and fixing flaws, not weaponizing them — and it aligns the product with defender workflows (patch, verify, ship) rather than red-team theatrics.

The cyber benchmark record

Source: Google blog announcement, Sep 2, 2026. Note that all three rows are vendor-reported at launch; no independent reproduction existed at publication time.

The field evidence

More persuasive than the benchmarks are four deployment claims from teams already running the model inside Google and at partners:

The Cloud Vulnerability Research claim deserves a pause, because it is the difference between a benchmark and a capability statement: a critical foundational vulnerability found end-to-end in under two hours, where the human research baseline is months. If that generalizes — and one anecdote does not establish that it does — the economics of defensive security research change shape: continuous autonomous scanning of an entire codebase stops being a cost question and becomes an always-on background process. The Wiz numbers, measured on an external partner's internal benchmark rather than Google's, are the strongest independent-ish evidence in the set.

Safety posture of the pair

The standard 3.8 Flash ships with safeguards against CBRN (chemical, biological, radiological, nuclear) misuse and cyber offense, per Google's Frontier Safety Framework, and the model card records a "significant leap in prompt injection robustness as measured by Gray Swan" — a defense-relevant improvement for exactly the agentic workloads the model targets, since prompt injection is the attack surface of tool-using agents. On the framework's capability ladder, 3.8 Flash did not reach any Tracked or Critical Capability Levels (T/CCLs) — Google's assessment reasons from 3.7 Flash's assessment, on the grounds that 3.8 shows no meaningful new capabilities in the framework's domains.

Cyber, by contrast, is the deliberate exception: more permissive cyber mitigations, no general availability, vetted-defender access only. The Fairwind Program is thus the load-bearing policy structure of the whole release — if the gating works, Google gets to claim frontier cyber capability for defenders without putting it in the open market; if it leaks, the mitigation differential becomes the story. Security researchers will reasonably want to know what Fairwind's vetting actually entails over time; at launch, Google has described the eligibility classes but not the verification mechanics.

08API and migration guide

3.8 Flash arrives GA on the new Interactions API — Google's recommended surface, designed around agent workflows rather than single-shot generation. The minimal call is genuinely minimal:

# Python — google-genai SDK
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Write a three.js script that renders a realistic 3D black hole."
)

print(interaction.output_text)

// JavaScript — @google/genai SDK
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
  model: "gemini-3.8-flash",
  input: "Write a three.js script that renders a realistic 3D black hole.",
});

console.log(interaction.output_text);

# REST — curl
curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "Write a three.js script that renders a realistic 3D black hole."
  }'

Controlling the effort dial is equally direct — and this is the parameter that most affects your bill:

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Analyze this payment processing pipeline for race conditions during retry attempts and rewrite the transaction locks safely.",
    generation_config={
        "thinking_level": "medium"  # low | medium (default) | high — minimal is NOT valid
    }
)

Google's guidance maps the levels to use cases: low for latency-critical paths (incident response pipelines, real-time chat, drafts, fast analysis), medium for most work including complex code and agentic use ("higher first-pass accuracy"), high for deep reasoning, mathematics, and difficult multi-step tasks. Requesting minimal returns an error, not a fallback.

Migration checklist: 3.7 Flash (or earlier) → 3.8 Flash

Google published an official checklist, including an automated path — if you use a coding agent that supports skills (like Antigravity), install the gemini-api-dev skill and run /gemini-api-dev migrate my app to Gemini 3.8 Flash. The manual checklist:

Source: "What's new in Gemini 3.8 Flash," Google AI for Developers, updated Sep 2, 2026.

The Antigravity angle

For agent builders, the more consequential change may be what Google did inside its own stack: the Antigravity managed agent now runs 3.8 Flash by default, and the Antigravity SDK follows. A single natural-language instruction can drive a build loop through the agent with tools, sub-agents, and verification — Google's launch demos include a fully playable DOS-style Google Maps built from one prompt, a 3D wizard-castle game with Nano Banana-generated textures, a USGS topographic-data explorer, and an interactive 3D hardware-teardown visualizer. The pitch is that the effort-dial and tool-loop behavior from section 3 were designed for this runtime: an agent that keeps refining rather than stopping at a first draft, billed per token while it works.

09Limitations, regressions, caveats

A breakdown that only repeats the launch claims is marketing with citations. This section collects everything the primary sources say when read against the grain.

The safety ledger, verbatim

Source: Gemini 3.8 Flash model card, "Ethics and Content Safety" section. Deltas are automated-eval percentage-point changes; Google notes these use improved eval harnesses and are not directly comparable to older model cards.

Two framing notes on that ledger. First, Google's own caveat matters: these are automated evaluations run with improved harnesses, so cross-card comparisons are approximate, and their manual review "confirmed losses were overwhelmingly either a) false positives or b) not egregious." Second, the multilingual regression is the one item that deserves an engineering follow-up if your traffic is non-English-heavy — a +5.4pp movement on safety evals is a behavioral change in the model, whatever its real-world severity, and it landed in the same training push that produced the coding gains.

Reading the benchmarks with appropriate skepticism

DataCamp's launch-day verdict is the right calibration: "I'd want to see independent reproductions before taking the CyberGym and CWE-Bench numbers at face value, since almost all the data so far comes from Google itself." The same applies with different force to each tier of evidence in this article: the 3.7-delta table comes from Google's developer docs but has been cross-confirmed by third-party compilations; the frontier comparisons come from two independent labs (AA, Beam) using their own harnesses; the cyber results and partner quotes are vendor-reported at publication time; and the community latency observations are single-user anecdotes that nonetheless match the official claims' direction. Every number above is labeled with its tier of evidence — treat the labels seriously when you make procurement bets.

Finally, the deepest caveat is structural, and it is the same one that has applied to every reasoning model since the effort dial was invented: benchmarks measure the model, deployments measure the system. Beam's launch note puts it well — most enterprise agent pilots that fail do so on evaluation, governance, and reliability, not on the model underneath. A Flash model with no eval harness, no audit trail, and no exception handling is a cheaper demo, not a cheaper deployment. Nothing in 3.8 Flash changes that; it just lowers the price of the component.

10Who should switch

Everything above compresses into a routing decision. The model's own evidence profile — strong where tasks are domain-bounded and tool-reliant, flat-to-behind where tasks reward raw knowledge or maximal-depth engineering — maps cleanly onto workload archetypes:

The community's early read converges on the same picture from the other direction. The dominant themes in launch-week discussion (r/singularity, Hacker News) are: it is slightly faster than 3.7 in real use while using a few percent more tokens; it "does the evals cheaper and faster" in agentic contexts; and the pre-release framing that stuck — "Fable 5 level performance at Flash pricing" — is directionally right for agentic work and overstated for pure reasoning. There is no community controversy about the speed claim; the skepticism is concentrated, correctly, on the vendor-reported cyber numbers and on the January price doubling.

Q&AFrequently asked questions

※Sources

• OfficialDoshi, T. & Popa, R. A. — Introducing Gemini 3.8 Flash and 3.8 Flash Cyber — Google Blog, Sep 2, 2026 — blog.google
• OfficialGemini 3.8 Flash — Model Card — Google DeepMind, Sep 2026 — deepmind.google/models/model-cards/gemini-3-8-flash
• OfficialWhat's new in Gemini 3.8 Flash — Google AI for Developers, updated Sep 2, 2026 — ai.google.dev/gemini-api/docs/latest-model
• OfficialGemini Developer API pricing — Google AI for Developers — ai.google.dev/gemini-api/docs/pricing
• OfficialGemini 3.8 Flash — model page — deepmind.google/models/gemini/flash
• OfficialDoshi, T. — Introducing Gemini 3.7 Flash: our most intelligent workhorse model — Google Blog, Aug 13, 2026
• IndependentGemini 3.8 Flash: Release Intelligence, Performance & Price — Artificial Analysis, Sep 3, 2026 — artificialanalysis.ai
• IndependentClaburn, T. — With Gemini 3.8 Flash, Google reminds everyone it's still in the race — The Register, Sep 2, 2026
• IndependentFalk, F. — Gemini 3.8 Flash for AI Agents: What the Early Benchmarks Show — Beam AI, Sep 2, 2026
• IndependentGemini 3.8 Flash — model record — BenchLM.ai, Sep 2, 2026
• PressNew Google AI Model Said to Narrow Gap on Coding Ability — Wall Street Journal, Sep 2, 2026 (incl. "Skimaki" codename, Jetski internal testing)
• PressGoogle's Gemini 3.8 Flash: Four Models in Four Months — 247wallst.com, Sep 2, 2026
• AnalysisCrabtree, M. — Gemini 3.8 Flash and 3.8 Flash Cyber: Features, Benchmarks, and Pricing — DataCamp, Sep 2, 2026
• AnalysisGemini (language model) — Wikipedia (release chronology) — en.wikipedia.org
• Communityr/singularity — Gemini 3.8 Flash Benchmarks thread (hands-on latency/token observations, Sep 2026); Hacker News — Gemini 3.8 Flash and 3.8 Flash Cyber discussion, Sep 2, 2026