Ling-3.1-flash-1019 vs Ling-3.1-flash: Same Size, Same Price, a Bigger Token Bill

If you rent by the token, Ling-3.1-flash-1019 is a free upgrade over Ling-3.1-flash. Both list at $0.30 per million input tokens and $0.90 per million output, both carry an MIT licence, both are 560B-parameter mixture-of-experts models with 25B active, and both occupy 573.8 GB on disk. If you pay by the finished task, the upgrade is closer to 47% more expensive: Artificial Analysis measured $1.49 per Intelligence Index task for the 1019 build against $1.01 for its predecessor, because the newer model generates about 59% more output tokens to reach its answers. The three-point index gain between them — 44 against 41 — is real. The question this page answers is who should pay for it.

The dates matter for reading the rest. Ling-3.1-flash went open under MIT in mid-October, with its repository created on 13 October and Ant's announcement following on 15 October. The 1019 build was announced on 22 October with a score and no download, and its weights plus a base checkpoint landed on 27 October. So this is not a generation gap. It is one post-training run applied to the same architecture, shipped five days after the number that describes it.

What the two checkpoints share

The overlap is large enough that migration cost is effectively zero, which is the main argument for the newer build:

• Architecture — 72 layers, split into 63 KDA linear-attention layers and 9 gated MLA layers at a 7:1 ratio, plus 4 dense layers.

• Experts — 512 routed, 8 activated per token, 1 shared; hidden size 4,096; vocabulary 157,184.

• Weights on disk — 573.8 GB of FP8 safetensors across 54 shards for both, by our count from the two repository file listings.

• Licence — MIT for both, including commercial redistribution.

• Price — $0.30 input, $0.90 output, $0.06 cache read, a blended $0.19 at a 7:2:1 cache-hit/input/output mix.

• Declared context — a 1M-token window on both model cards; 262,144 positions and no RoPE scaling in both config.json files.

That last line is the first thing to internalise before comparing them. On paper both models offer a million tokens. In the shipped configuration both top out at 256K unless you add a scaling scheme Ant has not included. The limitation is identical on both sides, so it does not decide the matchup — but it does mean neither build is the million-token model the cards advertise, and anyone planning a 1M-token workload is choosing between two models that will both need work to get there.

Where the three points come from

Artificial Analysis measures the headline gap itself: 41 for Ling-3.1-flash and 44 for Ling-3.1-flash-1019 on Intelligence Index v4.3.2, with the older model ranked eighth of 122 and the newer fourth. That is an independent measurement of both endpoints, which makes the three-point delta the most trustworthy number in this comparison.

The per-benchmark breakdown is vendor-reported and should be read as such — it comes from Ant's model card, not from a public harness:

• AA-Briefcase — roughly 1,400 Elo to 1,524 Elo. This is the knowledge-work artifact benchmark, and a 124-point move is the largest relative gain in the set.

• AutomationBench-AA — 62% to 68%, a six-point improvement on agentic task automation.

• CritPt — 18% to 26%, the biggest proportional jump: eight points on a physics reasoning set where the absolute scores are low for everyone.

• SciCode — 54% to 57%, the smallest move of the four, and the one to weight most cautiously; Artificial Analysis flags SciCode as under review for this model.

Read together, the pattern is consistent with what Ant says it did: more post-training on reasoning and multi-step agent work, not a new capability surface. The gains concentrate where chains of decisions are long and where a partially right answer earns partial credit. They are thinnest on straight scientific code generation, which is exactly where you would expect a post-training refresh rather than an architecture change to move least.

The bill: 59% more thinking

This is where the two models stop being interchangeable. Artificial Analysis recorded 220M output tokens for the Ling-3.1-flash index run and 350M for the 1019 run — a ratio of 1.59 — and ranks the newer build last of 48 models on verbosity, against a median of 140M. The cost to complete the index rose from $1.01 to $1.49 per task.

Scale that to a workload. At 10,000 index-shaped tasks, the per-task figures imply about $10,100 on the older checkpoint and $14,900 on the newer one. The token side scales the same way: a workload that consumes 2.2 billion output tokens on Ling-3.1-flash would consume about 3.5 billion on the 1019 build at the measured ratio, which at $0.90 per million is $1,980 against $3,150. The rest of the per-task gap comes from input and cache pricing, but the direction is set by the token count: you are buying three index points with roughly six tenths of an extra answer per answer.

Whether that is a good trade depends on the failure mode you are insuring against. In an agent loop where a wrong tool call triggers a retry, a re-read of context, or a human review, an extra 59% of tokens is cheap against one avoided loop. In classification, extraction, short chat, or any high-volume task where the answer is one or two sentences, the same ratio is pure overhead — and the index will never show it, because the index rewards the hard cases that post-training was aimed at.

The other half of the cost picture is rate stability. OrcaRouter puts 200+ models behind one key at 0% markup over provider list, so a vendor price change passes through the same day for the models we route. The Ling line is not in that catalogue today, which means the figures above are Ant's list rate and nothing else. That is precisely why the per-task arithmetic matters more than the per-token rate: the rate is identical between these two models, so it cannot help you choose.

Speed: one number exists, and it belongs to the older model

Artificial Analysis measured Ling-3.1-flash at 215.7 output tokens per second with a 1.73-second time to first token, ranking it sixth of 78 models on speed. For Ling-3.1-flash-1019, the same page carries no output-speed figure — at measurement time there was no publicly available API to time, and the weights only appeared today. So the faster model is not a matter of opinion; it is the only one of the two with a measurement.

Combine that with the token ratio and you get a defensible estimate, clearly labelled as arithmetic rather than a benchmark. If both builds decoded at 215.7 tokens per second, a response that runs 1,000 tokens on Ling-3.1-flash would take about 4.6 seconds of decode; the equivalent 1,590-token answer on the 1019 build would take about 7.4 seconds. Time to first token is a separate variable and could move in either direction. The point is that a 59% token increase cannot be free in wall-clock terms unless the newer model also decodes meaningfully faster, and nobody has published evidence that it does.

Self-hosting: identical footprint, different README

On your own hardware the choice is simpler, because the deployment target does not change. Both checkpoints need the same documented configuration — eight H200s at TP8 plus EP8, or four GB300s at TP4 plus EP4 — and the same SGLang day-0 image, with a vLLM recipe using tensor parallelism of 8, expert parallelism and three speculative tokens. Because the architectures and file sizes are identical, 1019 is a drop-in replacement: swap the weight path, keep the serving stack, and nothing else in your infrastructure needs to know.

Two practical warnings. First, the 1019 model card's Quickstart still points at inclusionAI/Ling-3.1-flash in its SGLang command and sends "model": "Ling-3.1-flash" in its client example; copy it verbatim and you will serve the 41-point model while believing you are testing the 44-point one. Second, the base checkpoint Ant released alongside 1019 is Ling-3.1-flash-base — the base of the older model, not a pre-post-training snapshot of 1019. If your plan is to fine-tune the upgrade, the recipe that produced it is not in the download. If your plan is to build something of your own from a 560B foundation under MIT, the base is the right starting point and the index gap between these two checkpoints is irrelevant to you.

Calling them: one name, two builds

The API story is messier than the weights story. The 1019 build is a date-stamped checkpoint under a name that most serving code treats as the same model string as its predecessor — including Ant's own examples, which send Ling-3.1-flash to both. If you call a hosted endpoint, pin the build explicitly or you will not know which one answered. Artificial Analysis listed no publicly available API for 1019 at measurement, so availability today runs through the vendor's own API and several third-party platforms rather than a settled, widely mirrored endpoint.

That ambiguity is the strongest argument for self-hosting if you care about reproducibility, and the strongest argument for waiting if you do not. A model whose name does not identify its build is a model you cannot audit after the fact, and "44 on the index" is not a version number.

Which one, by job

• Hard reasoning and long-horizon agent work — take Ling-3.1-flash-1019. The gains are concentrated exactly there, and the extra tokens are the mechanism, not a side effect.

• High-volume extraction, classification and short chat — stay on Ling-3.1-flash. You would be paying 47% more per task for capability those workloads do not exercise.

• Latency-sensitive products — stay on Ling-3.1-flash until an independent throughput figure for 1019 exists. It is the only one of the two with a measured speed.

• Fine-tuning or domain adaptation — start from Ling-3.1-flash-base and ignore this matchup. Neither aligned checkpoint ships a training recipe.

• One model, mixed traffic — Ling-3.1-flash-1019 as the default, with the older build behind it for the cheap, short requests. The two share an architecture, a price and a serving stack, so splitting traffic between them costs you nothing operationally.

What would change this verdict is a measured decode speed for the 1019 build. If it turns out to be materially faster than 215.7 tokens per second, the wall-clock penalty shrinks and the token bill becomes the only real objection. If it is the same or slower, then the 59% shows up twice — once on the invoice and once in the latency — and the case for running both checkpoints rather than upgrading wholesale gets stronger. Until someone publishes that number, the honest summary is that Ling-3.1-flash-1019 buys quality with tokens, and Ling-3.1-flash sells throughput at the same rate. Neither is the wrong answer; they are different products wearing the same architecture.