Ling-3.0-flash-VL vs DeepSeek V4 Flash Vision Exp: Two Bets on Open Vision

Ling-3.0-flash-VL and DeepSeek V4 Flash Vision Exp are the two open-weight vision models in this weight class that a team can realistically download and serve today, and they were built by people who disagree about what vision is for. Ling-3.0-flash-VL, from Ant Group's inclusionAI lab, activates about 5.5B of its 124B parameters per token and treats vision as something to be applied inside a feedback loop — generate, render, look, correct — at the lowest possible inference cost. DeepSeek V4 Flash Vision Exp, Deep​Seek's first multimodal build, pairs a 1M-token context window with 384K tokens of maximum output and treats vision as one more input an agent reads on its way to finishing a long job. One is optimised for how little it costs to think. The other is optimised for how much it can hold while it does.

That difference, not a benchmark delta, is what should drive the choice. The two models have no shared evaluation protocol to compare against, and only one of them has an independent score at all. What follows is the honest shape of the matchup: the architecture bets, the specs that actually diverge, the benchmark situation including why it is thin, what each costs, and which one wins for which job — plus the part where we say plainly which of the two is on our catalogue.

The two bets, stated precisely

The Ling side of this is a bet on activation sparsity as the primary cost lever. Ling-3.0-flash-VL is a sparse mixture-of-experts with 124B total parameters — the model card shows about 124.8B, and the SGLang cookbook describes 5.1B active where the card says roughly 5.5B — running a 42-layer hybrid trunk that alternates Kimi Delta Attention with gated MLA blocks at a 5:1 ratio. An arbitrary-resolution vision encoder and a two-layer MLP projector feed that trunk, with VideoRoPE handling spatial and temporal position so video frames land in a coherent order. The architectural consequence is a model that costs a small fraction of a dense 124B to run per token, which is the entire reason it appears on the intelligence-versus-active-parameter frontier.

The Deep​Seek side is a bet on context and agentic endurance. DeepSeek V4 Flash Vision Exp takes the DeepSeek-V4-Flash text architecture and adds a vision encoder and an aligner, then continues training — one source puts the result around 305B parameters, which Deep​Seek has not confirmed in detail. It carries a 1,048,576-token context window and 384,000 tokens of maximum output, supports JSON output, tool calls, the Responses API, the Anth​ropic API and conversation-prefix continuation, and Deep​Seek has been explicit that this is not a visual question-answering model. It is perception for agents: reading web screenshots, software interfaces and charts, then continuing into tool calls. Images are converted to tokens and billed as such, capped at 384 tokens per image.

Read those two paragraphs together and the shape of the decision appears. If your workload is "look at this, decide something, act, look again," Ling's active-parameter count is what makes the loop affordable and its vision-feedback design is aimed at exactly that. If your workload is "read this 400-page document with figures in it and keep going," Deep​Seek's context window is the feature and nothing on the Ling side competes with it.

Why the benchmark comparison is thinner than it looks

This is the section most comparisons skip, and skipping it produces a table of numbers that means nothing. Here is the actual state of the evidence.

Ling-3.0-flash-VL has one independent measurement: 25 on the Artificial Analysis Intelligence Index v4.3, ranked #2 of 64 in its size class against a class median of 8. The vendor's card separately claims 42 on the Intelligence Index protocol v4.1.1, which is a retired scale and not comparable — treat the 42 as unreproduced.

DeepSeek V4 Flash Vision Exp has no Artificial Analysis page at all. Every number published for it is Deep​Seek's own, from the release announcement, and several of them are explicitly relative to Opus-4.8 rather than to a fixed protocol. That is not a criticism of the numbers; it is a statement about what you can do with them. You cannot put an independently-scored model and a vendor-only-scored model in the same column and declare a winner, and any page that does is manufacturing a result.

What is legitimate is comparing each model against its own reported record, with the provenance attached:

• Ling-3.0-flash-VL, independent — Intelligence Index 25 on v4.3, #2 of 64 in class, class median 8, per Artificial Analysisbr /> • Ling-3.0-flash-VL, vendor — 42 on the retired v4.1.1 protocol, and 1,441 versus GPT-5.4's 1,440 in the Image-to-WebDev Arena as "linthium"; both vendor-reported and the arena margin is inside Elo noisebr /> • DeepSeek V4 Flash Vision Exp, vendor — Terminal Bench 2.1 83.9; DeepSWE 59.3 against Opus-4.8's 58.0; Agents' Last Exam 27.3 against Opus-4.8's 25.7; Toolathlon-Verified 75.9; Cybergym 75.3; Chartography 64.3; NL2Repo 57.7; DSBench-Hard 63.6; ZeroBench Pass@5 35.0; ApexBench Pass@1 36.5; AutomationBench 25.7br /> • DeepSeek V4 Flash Vision Exp, independent — none published

Notice what the Deep​Seek list is mostly made of: agentic and software-engineering evaluations, not vision evaluations. Deep​Seek's own framing is that on pure-text tasks the vision model matches the official DeepSeek-V4-Flash with no regression, and that the gains are on multimodal agent benchmarks — where Deep​Seek describes the result as approaching Opus-4.8 rather than beating it, and concedes a roughly ten-point gap on the structured data-science and code tasks NL2Repo and DSBench-Hard. That is an unusually careful set of claims, and it tells you the model is being sold as a perception upgrade to an existing agent stack rather than as a new ceiling.

The specs that actually diverge

Most of the two spec sheets agree: both are open-weight under MIT, both take text and images in and return text, both ship BF16 weights with quantized builds, both have serving recipes published, and both handle video in some form. The divergences are concentrated in four places.

• Parameters — Ling-3.0-flash-VL is 124B total with roughly 5.5B active per token; DeepSeek V4 Flash Vision Exp is reported around 305B with no published active-parameter figurebr /> • Context window — Ling-3.0-flash-VL measures 262K tokens per Artificial Analysis against the 256K its own model card states; DeepSeek V4 Flash Vision Exp runs 1,048,576 tokens nativelybr /> • Max output — Ling-3.0-flash-VL is far shorter, in the tens of thousands of tokens; DeepSeek V4 Flash Vision Exp reaches 384,000br /> • Image handling — Ling-3.0-flash-VL accepts up to 40 images per request at up to 16,384 × 784 pixels each, base64 only; DeepSeek V4 Flash Vision Exp accepts base64, external URLs or a Files API reference, and caps image cost at 384 tokens per imagebr /> • Active parameters — Ling-3.0-flash-VL activates roughly 5.5B per token; DeepSeek V4 Flash Vision Exp has published no active-parameter figure

The image-handling row is the one that gets underrated. A hard cap of 384 tokens per image means a dense chart or a full-page screenshot is compressed to roughly the same budget as a thumbnail — cheap, and lossy in a way that matters for fine-grained reading tasks. Ling's approach goes the other way: a very large per-image pixel budget, base64-only transport, and therefore a much heavier request payload. Which one is better depends entirely on whether your images are photographs of documents you need read precisely, or UI screenshots you need understood approximately.

The second underrated row is max output. Ling-3.0-flash-VL's tens-of-thousands-of-tokens ceiling is fine for a describe-then-correct loop and constraining for anything that wants to emit a large artifact — a long generated file, a full document rewrite, a multi-thousand-line diff. Deep​Seek's 384K output exists precisely because its intended workload ends in a large tool-call result or generated artifact. If your pipeline expects the model to hand back something long, that single row decides the matchup before any benchmark does.

Price, and the difference between free and unpriced

DeepSeek V4 Flash Vision Exp has a real number on our catalogue: $0.24 per 1M input tokens and $0.73 per 1M output tokens, with a 1,048,576-token context window and a 384,000-token maximum output, reachable as deepseek/deepseek-v4-flash-vision-exp. That is a published rate, billed the same way as the text V4-Flash, with images converted to tokens at up to 384 per image. It is a rate you can put in a spreadsheet.

Ling-3.0-flash-VL does not have one. The Artificial Analysis page lists it at $0.00 per 1M input and $0.00 per 1M output against peer medians of $0.14 and $0.40 — but that reflects the free trial running on Ant's Ling Studio, not a tariff. Ant's multimodal documentation publishes no per-token price for the vision model, so there is nothing to check the zero against. The text-only sibling Ling-3.0-flash has been listed around $0.075 per 1M input and $0.22 per 1M output, and Ant's domain-specific Ling releases launched as free APIs, which suggests a similar eventual shape — but a suggestion is not a price.

Put those side by side honestly and the cost comparison is: one model has a rate, the other has a promotional window and a plausible guess. Anyone asserting Ling-3.0-flash-VL is cheaper than DeepSeek V4 Flash Vision Exp is comparing a free trial to a list price. The defensible statement is that Ling-3.0-flash-VL is very likely to be cheaper per token once priced, because 5.5B active parameters is a structural advantage no rate change erases — with the caveat that Ling-3.0-flash-VL's verbosity eats into it. Artificial Analysis records it burning 160M output tokens on the Intelligence Index, ranked #8 of 64 against a median of 84M and labelled "very verbose." You pay per token emitted, so a model that says nearly twice as much to reach the same answer gives back part of what its sparse activation wins.

Which one, for what

The honest decision tree splits on context and output length before it splits on anything else, because those are the dimensions where the two models are not substitutes.

Pick DeepSeek V4 Flash Vision Exp when your job is long and ends in an artifact: multi-hundred-page documents with figures, codebases read end to end, agent loops that need to emit a large result, workloads where you want to hand over an image by URL or a Files API reference rather than base64, and pipelines where you need the Responses API, prefix continuation, or a published per-token rate you can budget against. It is also the only one of the two with a vendor claiming parity with its own text model on text tasks, which matters if one model is replacing two in your stack.

Pick Ling-3.0-flash-VL when your binding constraint is cost per call and your loop is short: GUI automation, repeated screenshot inspection, front-end generation with a render-and-correct cycle, medical or financial document spot-checks where you need high per-image resolution and can accept a small output. The 5.5B active parameter count is the reason to choose it, the MIT license is the reason it is safe to self-host, and the vision-feedback-loop design is aimed at exactly the observe-act-verify-correct pattern. Be aware that you are choosing an unpriced model with a free entry path and no commitment about what follows.

And if what you actually need is one model that reads images competently without either extreme — no 5.5B sparsity trick, no million-token window — then neither of these is the interesting answer, and the ordinary mid-range vision models will serve you better and cheaper than either specialist.

Running them, and where we fit honestly

DeepSeek V4 Flash Vision Exp is on our catalogue. You can call it through OrcaRouter's OpenAI-compatible endpoint with the model string deepseek/deepseek-v4-flash-vision-exp, on the same key you use for everything else, at the published $0.24/$0.73 rate with nothing added on top — provider list price is passed straight through, so if Deep​Seek cuts the rate it reaches you the same day rather than at the next contract renewal. If you are putting a vision model into a production path for the first time, this is the safer of the two to start with on a routing layer, because you can configure a fallback chain so a provider error retries against another route before your response begins. Nobody wants their first production vision call to be the one that teaches them about single-provider failure.

Ling-3.0-flash-VL is not on our catalogue, and we are not going to imply otherwise. It is reachable through Ant's own platform, which publishes an OpenAI-compatible endpoint and an Anth​ropic-compatible one, through free trial access on Ling Studio, and through the open weights on Hugging Face, which you can serve yourself with the published SGLang recipe or Ant's own vLLM fork. One thing to verify before you invest in that path: Ant's API examples use the identifier Ling-3.0-flash-VL-rc1, a release-candidate marker, and whether the served checkpoint matches the open weights has not been settled publicly. If you benchmark against the hosted API expecting the numbers to transfer to a self-hosted BF16 deployment, test that assumption first.

The summary that survives scrutiny: these are not rival answers to one question. DeepSeek V4 Flash Vision Exp is a long-context perception layer for agents with a published price and a vendor-reported benchmark sheet that leans on agentic evaluations. Ling-3.0-flash-VL is a cheap-to-serve vision model with one genuine independent score, an unpriced free tier, and a design aimed at short corrective loops. Match the shape of your workload to the shape of the model, and the fact that only one of them has an independent score on the board should inform how much weight you put on the other one's marketing.

The same key reaches the rest of the catalogue, and you can browse the full model catalogue to see what else sits behind one OpenAI-compatible endpoint.