Ling 3.1 Flash Guide: A Point Release With Five Times the Compute

Version numbers usually signal the size of a change. Ling 3.1 Flash ignores that convention. Its predecessor, Ling 3.0 Flash, is a 124B mixture-of-experts model with about 5.1B active parameters. Ling 3.1 Flash is 560B total with 25B active. That is roughly four and a half times the total and five times the compute per token, under a name that suggests a tune-up.

So treat it as what it is: a new, larger model in the same architectural family, which inclusionAI says builds on 3.0 Flash and which OpenRouter lists from 2 October 2026. The question is not whether it is better than 3.0 Flash. It should be. The question is whether it is better by enough to justify the cost of running five times the active parameters.

Same recipe, scaled up

The model card describes the same hybrid-linear design as 3.0, stretched in every direction. There are 63 Kimi Delta Attention layers and 9 gated MLA layers, a 7:1 ratio where 3.0 used 5:1. There are four dense layers, 512 routed experts with eight active plus one shared, a hidden size of 4,096 and 64 attention heads.

The shift from 5:1 to 7:1 is worth noticing. More of the stack is linear attention, which keeps long inputs cheaper, and that fits the card's claim of a 1M-token context window. Not every host serves the full window, though: the OpenRouter listing showed 262,144 tokens at the time of writing. Check the limit your provider actually exposes before you design around it.

Weights are on Hugging Face under the MIT licence, like the rest of the Ling 3.0 family. Self-hosting is a different class of job from 3.0: the recommended SGLang set-up is eight H200s with tensor and expert parallelism, or four GB300s.

The numbers, next to 3.0 Flash

The card's evaluation metadata lists the following, all vendor-reported:

• SWE-bench Pro: 68.74, against 56.6 for Ling 3.0 Flash
• SWE-bench Multilingual: 88.5 resolved, against 72.4
• Humanity's Last Exam: 37.44, against 22.7
• Terminal-Bench 2.1: 81.18
• Terminal-Bench 4: 46.03
• Deep SWE: 59.7
• SkillsBench: 68.7

The largest relative jump is on Humanity's Last Exam, which is mostly knowledge and reasoning rather than tool use. That matches what you would expect from scaling: a 25B-active model can hold more than a 5B-active one, and agent training alone does not fix a knowledge gap.

Put the SWE-bench Pro figure in context carefully. GLM-5.2 reports 62.1 on the same benchmark, which would put Ling 3.1 Flash ahead on paper. But both figures come from their vendors on their own scaffolds, and the SWE-bench Pro, Deep SWE and Terminal-Bench 4 entries carry an asterisk the card does not explain. Read it as a reason to test, not as a ranking. The GLM-5.2 guide is the obvious comparison if you are choosing an MIT-licensed model for long agent loops.

Hybrid reasoning and the LingCode harness

inclusionAI calls 3.1 a native hybrid reasoning model. Thinking is controlled with enable_thinking in chat_template_kwargs, and the card recommends leaving it on for better results, with temperature 1.0, top_p 0.95 and top_k 20.

The card also introduces LingCode, a harness built on the open-source Pi coding agent for coding tasks that run for hours, involve hundreds of tool calls and need repeated context compaction. inclusionAI claims significant gains on some coding-agent tasks but gives no figures, and says only that it is considering open-sourcing it. That matters for reading the benchmarks: if a vendor harness contributed to a score, your harness will not reproduce it.

What the price gap looks like

Hosted prices for a new model are set per host. Our OpenRouter catalogue sync listed it at about $0.075 per million input tokens and $0.225 per million output at the time of writing, with other hosts free to charge more. At that listing it costs several times what Ling 3.0 Flash does per token, and it is still far below the frontier.

Per-token price is only half the comparison. A stronger model that finishes in fewer turns can cost less per completed task than a cheaper one that flails. Equally, if 3.0 Flash already solves a task in one pass, 3.1 is paying for capacity you did not use.

When to move up from 3.0

• Stay on 3.0 Flash for short, bounded work: extraction, classification, single-file edits, high-volume summarisation.
• Move to 3.1 Flash when the task needs knowledge as well as procedure, when agent runs exceed a few dozen turns, or when 3.0's failures cost you a human review.
• Run both when the split is not obvious. Send everything to 3.0 first and escalate failures; the pattern is in model routing and fallbacks.

To decide with evidence, take fifteen tasks from your own history, run both models on the same harness with thinking on, and compare cost per completed task rather than price per token. How to benchmark LLMs on your own work has the set-up.