DeepSeek V4.1 Flash vs Gemini 3.8 Flash: Benchmarks, Pricing, and Which to Use

Google shipped Gemini 3.8 Flash on September 2, 2026, its third Flash release in six weeks. Eight days later, DeepSeek answered with DeepSeek V4.1 Flash, an MIT-licensed 552B mixture-of-experts model that activates 8B parameters on input and 16B on output.

Both vendors call their model a workhorse for coding agents and achieve similar scores in the most important benchmarks. That makes this a harder call than the usual open-versus-closed framing suggests, because the cheaper model is not the weaker one on the benchmarks the two share.

In this article, I'll compare DeepSeek V4.1 Flash and Gemini 3.8 Flash across benchmarks, pricing, openness, multimodality, and in a hands-on build test I ran on both.

For deeper coverage of each model individually, see our DeepSeek V4.1 Flash guide and our Gemini 3.8 Flash and 3.8 Flash Cyber guide.

TL;DR

• DeepSeek V4.1 Flash matches or edges Gemini 3.8 Flash on every agentic coding benchmark both vendors publish, and won our hands-on scheduler test in half the turns.
• Gemini 3.8 Flash costs 2.5x more per input token and 3.1x more per output token today, and its price doubles on January 1, 2027.
• Gemini 3.8 Flash is the broader model: it takes audio, video, and PDF input, and ships with Google's hosted tools.
• Choose DeepSeek V4.1 Flash for high-volume coding agents, batch jobs, cache-heavy loops, or anything you need to self-host.
• Choose Gemini 3.8 Flash when your inputs are multimodal, when you build inside Google AI Studio or Antigravity, or when you need knowledge-work agents with published domain scores.

What Is DeepSeek V4.1 Flash?

DeepSeek V4.1 Flash is an open-weight, MIT-licensed mixture-of-experts model released by DeepSeek on September 10, 2026, and the smallest member of a new architecture family.

According to the V4.1 technical report, its KV cache needs 890 bytes per token, roughly a quarter of what DeepSeek V4 Flash needed, which is where most of the cost saving comes from.

For the full breakdown, read our DeepSeek V4.1 Flash guide, and for a local setup of the previous generation, our tutorial on running DeepSeek V4 Flash with Unsloth Studio and OpenCode.

What Is Gemini 3.8 Flash?

Gemini 3.8 Flash is Google's most capable Flash-tier model, released September 2, 2026, three weeks after Gemini 3.7 Flash and built on it.

Its defining design choice is that it "works harder": on complex tasks, it runs extra reasoning steps and calls tools iteratively, and Google says it may spend more tokens at higher effort levels.

Our Gemini 3.8 Flash guide covers the launch and the limited-access Cyber variant, and our Gemini 3.8 Flash API tutorial walks through the Interactions API, thinking levels, and function calling in Python.

DeepSeek V4.1 Flash vs Gemini 3.8 Flash: Head-to-Head Comparison

Across the six dimensions below, DeepSeek V4.1 Flash wins on price and openness and ties on coding, while Gemini 3.8 Flash wins on input types, tooling, and published knowledge-work results.

Coding and agentic workflows

DeepSeek V4.1 Flash leads on all three agentic benchmarks that appear in both vendors' tables, though two of the gaps are small enough to call a tie.

The gap that really matters is Terminal-Bench 4.0, the harder general-agent suite: 31.2% for DeepSeek against 19.1% for Gemini. Both vendors admit this suite exposes them; DeepSeek says a gap with giant models remains on science-oriented agentic tasks, and Google's own table puts Claude Opus 5 at 51.8%.

Two caveats:

• DeepSeek's scores are at its maximum effort tier, which the tech report says costs roughly 2.5x the output tokens of a low setting. The same report notes that efforts of 60 to 80 recover most of that accuracy at well under half the tokens, so max is worth reserving for hard tasks.
• The harnesses differ, but the rival columns line up almost exactly, so these tables are closer to comparable than most cross-vendor pairs.

For terminal-heavy coding agents, treat the two as equals and let price and deployment decide; on the hardest agent tasks, DeepSeek's published edge is the only one on the board.

Pricing: what you actually pay

Pricing is the one dimension with no contest, so the interesting question is how much the gap changes with the shape of your workload.

DeepSeek V4.1 Flash is cheaper on every line, and the gap widens the more your workload leans on output tokens or cached prefixes. The multiple is not uniform, which is the finding: 2.5x on input, 3.1x on output, and 12.5x on cached reads.

Token rates side by side

The difference is shaped like an output premium. Gemini's output rate is 3.1x DeepSeek's while its input rate is 2.5x, so generation-heavy and thinking-heavy work pays the most, and both vendors bill reasoning tokens at the output rate.

What a real workload costs

The formula is (volume ÷ 1M) × rate, summed across input and output, at DeepSeek's peak rates and Gemini's introductory rates. The cache-heavy row uses each vendor's cached-read rate for the 1,000 reads and assumes the Gemini cache is held for 1 hour, which adds $0.05 of storage.

The cache-heavy row is the headline, because DeepSeek's $0.006 cached-read rate makes a 100K-token prefix nearly free to re-read, while Gemini charges $7.50 for the same 100M cached tokens.

Schedule DeepSeek off-peak and every row halves; wait until January and every Gemini row doubles, so the balanced assistant becomes $3.38 against $0.60.

Openness, architecture, and deployment

DeepSeek V4.1 Flash is the only one of the two you can download, and its architecture is why it is cheap. The tech report describes a 20-layer causal encoder feeding a 20-layer decoder, Compressed Sparse Attention 2 with FP4 KV caching, and a KV cache of 890 bytes per token, down from 3,514 bytes for V4 Flash.

Serving those MIT-licensed weights is still early, though, with vLLM and SGLang support still in nightly and preview builds, and Transformers not yet supported.

If you need data residency, on-prem inference, or fine-tuning, DeepSeek is the only candidate here. If you want zero infrastructure, Gemini's GA hosted endpoint is the simpler path.

Multimodality, context, and built-in tools

Gemini 3.8 Flash accepts text, images, video, audio, and PDF, while DeepSeek V4.1 Flash accepts text and images. Both offer a 1M-token context window, but DeepSeek allows up to 384K output tokens, compared to Gemini's 64K, which matters for long code generation and full-document rewrites.

Gemini's model page also lists hosted tools DeepSeek has no equivalent for: code execution, Google Search and Maps grounding, file search, URL context, and computer use in preview. DeepSeek's API side offers JSON output, tool calls, a Responses API, an Anthropic-format endpoint, and prefix and fill-in-the-middle completion.

If your inputs include audio or video, or you want grounding without building retrieval, Gemini is the pick; if you want long outputs and drop-in compatibility with existing OpenAI or Anthropic client code, it is DeepSeek.

How DeepSeek V4.1 Flash and Gemini 3.8 Flash Performed

Benchmarks from two different vendors only go so far, so I ran one build task against both models with an identical prompt and identical tooling.

The test

I asked both to build a stateful single-file web app for a community orchestra rehearsal scheduler. Two features we explicitly asked for are interval-overlap conflict detection and persistence. Both models sit near 90% on Terminal-Bench 2.1, but DeepSeek's 31.2% against Gemini's 19.1% on Terminal-Bench 4.0 suggests a gap in harder agentic work, and this task is a compact way to look for it.

Both models ran inside OpenCode with an identical pinned tool surface: file reading and editing only, no shell and no network. Both ran at high reasoning effort, one attempt each, no retries, and the prompt was delivered byte-for-byte to a fresh session.

One asymmetry to keep in mind: high is Gemini's top effort tier, while on DeepSeek, it maps to 75 on a 1-to-100 scale, whose maximum matches the one used for its published benchmark scores.

This was the prompt:

Build a single-file HTML page (inline CSS and JS, no build step, no external dependencies, no network) for a rehearsal scheduler used by a community orchestra. 
It needs:
- a week view (Mon–Sun) showing rehearsal blocks by section: strings, brass, woodwind, percussion;
- a conflict indicator that flags when two sections are booked in the same room at overlapping times (not merely the same slot);
- an add-rehearsal form with section, room, day, start time, and end time;
- localStorage persistence, so rehearsals survive a page reload.

Ship it as one working file named `index.html`. Do not install packages. Do not open, screenshot, or headless-render the page (no Playwright, Puppeteer, or Chrome). 
Do not ask me clarifying questions — make reasonable assumptions and note them briefly in a comment at the top of the file.

I graded both on runnability (fail/pass) and on the following three rubrics, with scores from 1 to 5:

• Spec adherence: Does it implement all the features I asked for?
• Conflict logic: Does it successfully detect and display overlaps, but treat adjacent bookings or bookings in different rooms as non-conflicting?
• Usability and layout: Does it fit on one page, can it be used intuitively, and does it look good?

What DeepSeek V4.1 Flash produced

DeepSeek finished in 2 turns with a single tool call: it wrote a 13 KB index.html and declared done. The page is a dark two-panel layout, an add-rehearsal form on the left, a Monday-to-Sunday grid on the right, with a conflict-check panel underneath. Its header comment spells out the overlap rule, strict overlap with back-to-back bookings exempt, and the probe confirmed it flags only the overlapping pair.

Everything asked for is present and works, the layout reads at a glance, and its one unasked-for extra, deleting entries, helps. It does not allow editing an entry, which the prompt did not ask for either. This is a clean 5 for all three rubrics.

What Gemini 3.8 Flash produced

Gemini took 4 turns and 3 tool calls (a glob, a read, then a write) to ship a 76 KB index.html (almost 6x DeepSeek's file), and it was much slower. The result looks more polished: a branded header with a live overlap-flag counter, a preloaded sample week with an intentional Wednesday double-booking so the conflict indicator shows immediately, section and room filters, a conflicts-only toggle, column and timeline views, editing and deleting of entries, a repertoire notes field, and a live warning preview while you type a new booking.

The conflict logic is correct, and the probe flagged only the overlapping pair. The extras are the problem: a Sections and Balance panel with per-section session counts forced the form column to scroll (which contradicts the prompt) and sits awkwardly under the rest, and the sheer number of controls makes the week harder to read than DeepSeek's. That's why I need to deduct one point each for spec adherence and layout, although the overall result is very good.

Results

DeepSeek V4.1 Flash wins this test. Both got the hard part right, the interval-overlap logic, so the difference came down to judgment: DeepSeek built what was asked in one write, while Gemini built a small product, and one unrequested feature damaged the layout it was graded on. Gemini's version is the one I would demo to an orchestra manager; DeepSeek's is the one I would rather be handed by a colleague.

This is a single run of one task at one effort setting, so it says nothing about token usage or cost, and it probes only stateful UI plus overlap logic, not long-horizon repository work.

When to Choose DeepSeek V4.1 Flash vs Gemini 3.8 Flash

Neither model is the default for everyone, so here is the decision by workload.

The fork is inputs, infrastructure, and budget: the two are level on agentic coding, so DeepSeek wins whenever cost or control decides, and Gemini wins whenever your data or your stack is something DeepSeek cannot ingest or host for you.

Choose DeepSeek V4.1 Flash if...

• You run coding agents at volume. It is level with Gemini on Terminal-Bench 2.1 and DeepSWE v1.1, ahead on Terminal-Bench 4.0, and charges $1.20 rather than $3.75 per 1M output tokens.
• Your agent loop re-reads a large prefix. Cached input costs $0.006 per 1M tokens against Gemini's $0.075 plus hourly storage, a 12.5x gap that dominated our cache-heavy workload row.
• You need to self-host or fine-tune, and you have a node to do it on. The MIT-licensed weights run on vLLM and SGLang from their nightly and preview images, but the checkpoint is ~511 GB, and the verified layouts are one GB200 NVL4 tray or one 8×H200 node.
• You can schedule work off-peak or need very long outputs. Off-peak halves every rate, and the 384K output ceiling is 6x Gemini's 64K.

Choose Gemini 3.8 Flash if...

• Your inputs are audio, video, or PDFs. DeepSeek V4.1 Flash takes text and images only.
• You want hosted tools without building them. Code execution, Google Search and Maps grounding, file search, URL context, and computer use are all available on the same model ID.
• You build in Google's stack. It is GA in AI Studio and Gemini Enterprise, and it is now the default model in Antigravity.
• You need knowledge-work agents with published evidence. Google reports 61.4% on Vals Finance Agent v2 and 10.0% on Harvey's Legal Agent Benchmark; DeepSeek publishes nothing comparable.

How to Get Started With DeepSeek V4.1 Flash and Gemini 3.8 Flash

Where you can reach each model differs more than what it can do, so check the matrix before the benchmarks.

The biggest availability difference is that DeepSeek is downloadable and Gemini is not, while Gemini is the one with a consumer app and a managed enterprise platform on record. The IDs you type are deepseek-flash and gemini-3.8-flash; the legacy deepseek-v4-flash name still resolves but is served by V4.1 Flash.

Making your first API call

The two SDKs differ, so this is not a one-string swap. DeepSeek's endpoint is OpenAI-compatible, which means the standard openai client works with a base URL change, while Gemini 3.8 Flash uses the google-genai Interactions API with a thinking_level setting instead of sampling parameters.

from openai import OpenAI

client = OpenAI(api_key="YOUR_DEEPSEEK_KEY", base_url="https://api.deepseek.com")
response = client.chat.completions.create(
    model="deepseek-flash",  # DeepSeek V4.1 Flash
    messages=[{"role": "user", "content": "Refactor this function..."}],
)
print(response.choices[0].message.content)

from google import genai

client = genai.Client()  # reads your Google AI Studio API key
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Refactor this function...",
    generation_config={"thinking_level": "medium"},  # low, medium, or high
)
print(interaction.output_text)

For the full setup, PDF extraction, and function calling on Gemini, follow our Gemini 3.8 Flash API tutorial; for DeepSeek's thinking mode and a local deployment of the previous generation, see our DeepSeek V4 API tutorial and our guide to running DeepSeek V4 Flash with Unsloth Studio and OpenCode.

Final Thoughts

If your workload is coding agents, batch jobs, or anything that re-reads long prefixes, use DeepSeek V4.1 Flash: it is level with Gemini 3.8 Flash on the published agentic benchmarks, it won our build test in 2 turns, and it costs a third as much before Gemini's January price rise. If your inputs are audio, video, or PDFs, or you want grounding, code execution, and computer use from one hosted endpoint, use Gemini 3.8 Flash and accept the premium.

If you want to build agent systems around models like these, our Associate AI Engineer for Developers track covers APIs, tool use, and the Model Context Protocol in 29 hours, and our Building AI Agents with Google ADK course is a 1-hour start on the Gemini side.