Ling-3.0-flash-VL: Ant opens a multimodal model on the fast Ling line

On September 4, 2026, Ant Group's inclusionAI lab published MIT-licensed weights for Ling-3.0-flash-VL on Hugging Face and, the same day, updated the Ant Ling-platform developer documentation to match. Ling-3.0-flash-VL is the first vision-capable checkpoint in the Ling-3.0-flash family: the same ~124-billion-parameter sparse mixture-of-experts backbone that made the text-only Ling-3.0-flash one of late-summer's most talked-about cheap reasoning models, now reading images and short video clips as well as text. The FP8 quantisation followed on September 8, the morning this is being written. So inside four days the release acquired three surfaces a reader can act on — open weights, an official API on Ant's Ling platform, and a vendor-reported score of 42 on the Artificial Analysis Intelligence Index protocol version 4.1.1, four points above the text sibling's independently measured 38. What it has not yet acquired is a formal announcement: the Hugging Face card and the developer tutorial are the entire launch, which is why this piece separates what the vendor states from what an outsider can verify.

The release matters because of what it does to Ant's product map. Through mid-2026 the multimodal work in Ant's model portfolio sat in the separate Ming line, while Ling-3.0-flash was positioned — including on this blog's own explainer for the text model — as the fast, text-and-tools tier for agents, coding and deep research. Ling-3.0-flash-VL collapses that boundary: it brings visual information into a reasoning model built around an unusually small activated-parameter footprint and long agentic runs, and it hands the result to developers three ways at once. That makes it a genuinely different decision from the earlier domain-tuned variants (Ling-3.0-flash-Fin, Ling-3.0-flash-Sante), which shipped as free APIs with no weights. This one is open, runs on Ant's paid platform, and is young enough that nobody outside the vendor has published an independent run yet. That last fact is the most important one in the piece.

What shipped, and when

Every date below is checkable from the repositories and the docs; none of it rests on a press release that does not exist.

• September 4 — the Hugging Face repository inclusionAI/Ling-3.0-flash-VL was created at 15:24 UTC with 64 bf16 shards of weights, a full custom-code stack for the bailing_moe_v3_vl architecture, a chat template with thinking enabled by default, and an MIT license. Download count is in the dozens at the time of writing: this is a drop that only a repo-watcher would have caught on day one.

• September 4 — Ant's Ling-platform developer portal added the multimodal-understanding tutorial documenting the model on the official API (the page's own "last updated" stamp reads September 4, 2026). Chinese developer media reported the capability the following day, framing it as image and short-video understanding for visual question-answering and content analysis.

• September 5 onward — serving and deployment support appeared fast: an SGLang deployment cookbook for the model, a custom vLLM fork maintained by the inclusionAI org, and a bring-your-own-weights deployment-library listing with a ready-made chat-completions endpoint. These are runtimes and infrastructure, not announcements, but they tell you the model was built to be served, not just published.

• September 8 — the FP8 quantisation inclusionAI/Ling-3.0-flash-VL-fp8 landed (64 shards, ~126 GB), with the vision tower deliberately left in higher precision while the MoE weights are compressed to FP8 E4M3. For self-hosting on fewer or smaller GPUs, this is the checkpoint most people will actually download.

The card above is the closest thing this release has to a launch post — model description, architecture, links to the SGLang and vLLM recipes, and no announcement anywhere else that we can find. Note the mismatch worth flagging up front: the model card says "only 5.5B parameters activated per token", while the SGLang cookbook written around the same release describes a "5.1B active" model. On a brand-new checkpoint the difference is probably vision-tower accounting rather than two different models, but it is exactly the kind of detail that should be labelled unsettled rather than smoothed over.

A 124B model that activates 5.5B — now with eyes

Ling-3.0-flash-VL keeps the hybrid sparse-MoE recipe that defined the text sibling. The card describes a 42-layer backbone alternating Kimi-Delta-Attention and Gated-MLA layers at a 5:1 ratio — the same structural rhythm as Ling-3.0-flash — with total parameters around 124.8 billion and only a small fraction activated per token. What is new is the perception stack: a ViT visual encoder feeding a two-layer MLP projector into the language backbone, plus VideoRoPE to encode both spatial and temporal position so video frames arrive with an order the model can reason over. Input is text, image and video; output is text.

• Parameters — 124B total, ~5.5B activated per token per the vendor card (see the accounting caveat above).

• Context — advertised as "up to 1M tokens"; the deployment recipes that exist today exercise 256K via YaRN rope scaling, which is the honest practical figure to plan around until someone publishes a verified longer run.

• Thinking — reasoning is on by default through the chat template; both the official API examples and the serving recipes show a per-request enable_thinking: false switch for latency-sensitive calls.

• License — MIT, both precision formats, no rider. This is the same clean licence that made the text model's August open-sourcing notable, and it is the entire reason self-hosting is a realistic option rather than a grey area.

The design intent matters as much as the spec sheet. Ant positions Ling-3.0-flash-VL as a model that "brings visual information into the complete process of understanding, reasoning, acting and verification" — which is the language of agentic workloads, not image captioning. A model that can watch a 30-second screen recording, hold a long tool-calling session in context, and keep its activated cost near 5B parameters is aimed squarely at computer-use and short-video-grounded agents. That is a different product than the vision-language models optimised for single-image question-answering, and it is the frame every benchmark below should be read against.

What the official API actually accepts

The Ant Ling platform tutorial documents Ling-3.0-flash-VL on two API shapes: an OpenAI-compatible endpoint at api.ant-ling.com/v1/chat/completions and an Anthropic-compatible one at api.ant-ling.com/anthropic/v1/messages. The constraints are worth knowing before you build against it:

• Images — JPEG and PNG, base64 only, up to 40 images per request, each image up to 16,384 × 784 pixels and each base64 string up to 32 MB. The OpenAI-compatible image_url.detail parameter is ignored; the engine decides resolution internally.

• Video — MP4, MOV or WMV, one clip per request, capped at 30 seconds, sampled at a fixed 2 frames per second up to 32 frames, base64 up to 32 MB. Video works on the OpenAI-compatible endpoint only; the Anthropic-compatible endpoint accepts text and images but no video.

• Model identifier — the tutorial's curl examples call the model Ling-3.0-flash-VL-rc1 rather than Ling-3.0-flash-VL. That -rc1 suffix is a release-candidate marker and a genuine open question: nothing on the docs says which weights the platform is serving or whether the API checkpoint matches the September 4 open-weights build. If you are evaluating the API against the open weights, that is the first thing to test, not an assumption to make.

The page above is where the input constraints live — image and video formats, per-request caps, and the two endpoint shapes. It is also where the model is confirmed to be a live commercial API offering rather than a docs-only stub.

The numbers — and who reported them

The one headline number on the card is 42 on the Artificial Analysis Intelligence Index protocol version 4.1.1, which Ant says is four points ahead of the text-only Ling-3.0-flash's score of 38. The distinction in that sentence is load-bearing. The 38 is an Artificial Analysis measurement — independently run, published on their leaderboard, and quoted approvingly across the industry coverage of the text model. The 42 is a claim on Ant's own model card, made under an AA index protocol but not yet listed by Artificial Analysis, which had no page for Ling-3.0-flash-VL as of this writing. Nobody outside Ant has run this checkpoint yet. Treat 42 as a vendor figure from the same family that produced the text model's genuine 38 — a reason to look, not a number to quote as established.

Everything else in the release is qualitative or methodological. The card describes the model across an "understand, reason, act" capability chart and gestures at an agentic Terminal-Bench evaluation run under an AA-style protocol, but publishes no numeric text results we can reproduce here; the deployment cookbook lists accuracy cells (MMMU-Pro, GSM8K) tied to specific serving configurations that are worth reading but are infrastructure-adjacent measurements, not independent evals. The honest summary is short: a plausible, cheap-to-serve, vision-capable reasoning model with no public independent scoreboard yet.

What it costs, and what the family history suggests

Ant's multimodal tutorial does not list a per-token price for Ling-3.0-flash-VL, so anything here is inference, clearly labelled as such. The useful anchor is the text sibling on the same platform: Ling-3.0-flash's first-party list price is about $0.075 per 1M input tokens and $0.22 per 1M output, with cache reads roughly 80% cheaper, and the Chinese console prices it in renminbi (¥0.40 input / ¥1.20 output per 1M tokens) after an early 75%-off promotion that ended August 31. A 124B-A5.5B multimodal model is more expensive to serve than a 124B-A5.1B text model — the vision tower is dense and runs for every image token — so a price at or modestly above that band is the reasonable prior. The family history also cuts the other way: the Fin and Sante domain variants launched as free APIs, so Ant has shown it will use zero pricing to seed adoption of a Ling variant it wants in the market. Whether the VL follows the paid text-model band or the free variant pattern is simply not public yet.

For the self-host route the numbers are concrete because the files are public. The bf16 release is roughly a 250 GB download across 64 shards — a multi-GPU proposition on anything but the largest single nodes — while the FP8 release (~126 GB, vision tower kept in bf16) fits comfortably on a node with 8 × 80 GB-class accelerators and is the version most teams will actually run. Throughput claims from the serving cookbook exist but are vendor-adjacent; expect the usual caveat that real token/s depends on your hardware and your batch.

Where a routing layer fits — honestly

At launch, no major third-party model gateway we checked lists Ling-3.0-flash-VL, and OrcaRouter — the routing platform this blog belongs to — does not serve it either. Nothing in this piece should read as if it did. That is the honest state of a four-day-old model, and it is worth saying plainly because the options a reader actually has today are exactly two: call Ant's official API, or self-host the MIT weights. The routing angle is what happens next. Once a model like this reaches third-party serving, the economics of a pass-through router are the reason to prefer it for evaluation: provider list price forwarded with 0% markup, so a vendor price cut (or a free-tier experiment like the Fin and Sante launches) is live on the same day it is announced, and automatic failover lets you point a real workload at a days-old open model without betting your stack on one vendor's uptime or one checkpoint's behaviour. For a family that has repriced itself once and fragmented into four variants in six weeks, that is not a hypothetical — it is the difference between re-testing by hand every time Ant moves and re-testing once through one API.

What to watch

This release is young enough that the useful signals are mostly checks anyone can run. First, whether Artificial Analysis (or another independent lab) lists Ling-3.0-flash-VL and confirms or corrects the 42 — that single data point separates "the family's best model" from "another vendor number". Second, whether the -rc1 identifier on the official API resolves to the September 4 open weights; if it does not, the API and the self-host path are different models and every comparison you read needs to say which one it used. Third, pricing: a published VL rate on the Ling platform, and whether it follows the text model's paid band or the Fin/Sante free-API playbook. Fourth, whether the FP8 checkpoint holds the card's accuracy in real serving — the vision tower kept in bf16 is a good sign, but quantised-vision claims need a run, not a config. And fifth, the product-map question: with vision now inside the fast Ling line, watch whether Ant keeps Ming as a separate multimodal brand or lets the two converge.

For a developer the near-term answer is short. If you want to build on this today, the official API is the zero-infrastructure path and the FP8 weights are the self-host path, and both are real as of this week. If you want to build on the number 42, wait for someone outside Ant to reproduce it. Everything genuinely useful about Ling-3.0-flash-VL — MIT weights, a plausible architecture, an aggressive price-to-activation design, and a vendor score worth taking seriously — is in place; everything that would make it a safe default is still outstanding.