Ling-3.0-flash-Fin: a finance finetune, and a benchmark that grades where the numbers came from

Ling-3.0-flash-Fin, published by inclusionAI (Ant Group) on 2026-09-03, is the first finance-specialized release in the Ling family: continued training of Ling-3.0-flash — the 124B-total / 5.1B-active hybrid KDA + Gated-MLA attention stack over a 512-expert MoE this site already covered in depth — on financial data, "developed by Ant Group with leading financial institutions and domain experts." This piece doesn't re-derive that architecture; read the base article for KDA's constant-size linear-attention state, the 5:1 KDA-to-Gated-MLA interleave, and the E512A8-plus-shared-expert MoE. What's new here is what the finance specialization actually changed (short answer: nothing structural — this piece shows the receipts), what the parameter count actually is once measured rather than quoted, and FinFIRST, the benchmark inclusionAI open-sourced alongside it — a design worth taking seriously on its own, because it grades an agent's sourcing, not just its final number.

A finetune, byte for byte

The model card states it plainly: Ling-3.0-flash-Fin "extends Ling-3.0-flash through continued training on high-quality financial data," and its tags carry base_model:finetune:inclusionAI/Ling-3.0-flash. That's a checkable claim, not just a label. Hugging Face's own safetensors.parameters API reports the identical per-dtype breakdown for both repositories:

inclusionAI/Ling-3.0-flash-Fin   F32: 165,472   BF16: 127,486,240,128   total: 127,486,405,600
inclusionAI/Ling-3.0-flash       F32: 165,472   BF16: 127,486,240,128   total: 127,486,405,600

Same tensor count, same dtypes, same element counts, to the last digit. config.json matches too — hidden_size, num_experts, layer count, everything — and usedStorage differs by only about 457KB between the two repositories, which is README and asset text, not weights. That's about as strong a confirmation as a model card claim gets: this is a pure continued-training run on the same 42-layer backbone, not an architecture change wearing a new name.

Where "124B" and "5.1B active" actually come from

The announcement calls this a "124B-parameter MoE" with "5.1B active." The number above — 127,486,405,600 — is 127.49B, not 124B. Both figures are real; they're just counting different things, and the base article's already-published "124B / ~5.1B" numbers turn out to be reproducible from first principles rather than taken on faith.

Where the total comes from. Every one of the model's 65 safetensors shards (64 main shards plus one model-mtp-00001-of-00001.safetensors) opens with an 8-byte header length and a JSON tensor-shape map — readable with two HTTP range requests per shard, without downloading a single weight:

import json, struct, urllib.request
 
def shard_header(url: str) -> dict:
    req = urllib.request.Request(url, headers={"Range": "bytes=0-7"})
    n = struct.unpack("<Q", urllib.request.urlopen(req).read(8))[0]
    req = urllib.request.Request(url, headers={"Range": f"bytes=8-{8 + n - 1}"})
    return json.loads(urllib.request.urlopen(req).read(n))

Unioning all 65 headers gives the shape of every one of the model's 63,783 tensors. Summed directly, element counts land on 127,486,405,600 — matching the Hugging Face API to the last digit, with no fp8 scale-factor tensors to subtract this time (everything here is plain BF16 or F32).

Where the split comes from. Ninety-nine of those tensor names are outside model.layers.* — the two embedding matrices and the final norm. Every other tensor belongs to a layer index from 0 to 42 — one more than config.json's num_hidden_layers: 42. Layer 42 carries tensors no other layer has: eh_proj.weight, enorm.weight, hnorm.weight — the embedding/hidden fusion of a multi-token-prediction head, exactly the pattern this site found in GLM-5.3's own MTP layer — plus its own full attention block and its own complete 512-expert MoE. It's a 43rd, auxiliary layer riding along on the checkpoint, not part of the 42-layer backbone config.json describes. Split it out:

124,414,211,552 is 124.41B — the backbone-only count rounds cleanly to the announced "124B" once the ~3.07B MTP module is excluded. That's the same reconciliation the GLM-5.3 piece found for Z.ai's "744B" figure (backbone-only, within 0.1%): a marketing headline that turns out to be a real, specific accounting choice — drop the auxiliary head — rather than an arbitrary round number.

Active parameters take one more step: of the 42 backbone layers, 35 run KDA (linear attention) and 7 run Gated MLA (full attention, one per group of 6 — the base article's 5:1 interleave, confirmed directly in the tensor names: layers 5, 11, 17, 23, 29, 35 and 41 carry kv_a_proj_with_mqa / kv_b_proj, everything else carries A_log / b_proj / k_conv1d). The first 2 layers run a dense feed-forward (first_k_dense_replace: 2); the other 40 run the MoE, 8 of 512 routed experts plus 1 always-on shared expert. Every parameter outside the routed-expert tensors is active on every token; the routed experts are active at 8/512. The whole computation is reproducible from config.json alone, without fetching a single shard header:

# Verified against the real tensor shapes above; matches to the last digit.
cfg = dict(
    hidden_size=2560, num_attention_heads=32, head_dim=128,
    qk_nope_head_dim=128, qk_rope_head_dim=64, qk_head_dim=192,
    v_head_dim=128, kv_lora_rank=512, short_conv_kernel_size=4,
    vocab_size=157184, num_hidden_layers=42, layer_group_size=6,
    first_k_dense_replace=2, intermediate_size=6144,
    moe_intermediate_size=768, num_experts=512, num_experts_per_tok=8,
    num_shared_experts=1,
)
H, NH, HD = cfg["hidden_size"], cfg["num_attention_heads"], cfg["head_dim"]
D, K = NH * HD, cfg["short_conv_kernel_size"]        # D = 4096, KDA's inner width
 
def kda_layer():
    return (NH + D + NH * H + 5 * (D * H) + 3 * (D * K) + HD + H * D)
 
def mla_layer():
    qk, kvl, vh = cfg["qk_head_dim"], cfg["kv_lora_rank"], cfg["v_head_dim"]
    return (NH * qk * H + (kvl + cfg["qk_rope_head_dim"]) * H + kvl
             + NH * (cfg["qk_nope_head_dim"] + vh) * kvl + NH * H + H * (NH * vh))
 
def moe_ffn():
    per_expert = 3 * H * cfg["moe_intermediate_size"]
    routed, shared = cfg["num_experts"] * per_expert, cfg["num_shared_experts"] * per_expert
    router = cfg["num_experts"] * H + cfg["num_experts"]        # gate.weight + expert_bias
    return routed, shared, router
 
n_mla, n_dense = cfg["num_hidden_layers"] // cfg["layer_group_size"], cfg["first_k_dense_replace"]
n_kda, n_moe = cfg["num_hidden_layers"] - n_mla, cfg["num_hidden_layers"] - n_dense
embed = 2 * cfg["vocab_size"] * H                                # word_embeddings + lm_head, untied
attn = n_kda * kda_layer() + n_mla * mla_layer()
routed, shared, router = moe_ffn()
norms = cfg["num_hidden_layers"] * 2 * H + H
 
total = embed + attn + n_dense * (3 * H * cfg["intermediate_size"]) + n_moe * (routed + shared + router) + norms
active = (embed - cfg["vocab_size"] * H + attn + n_dense * (3 * H * cfg["intermediate_size"])
          + n_moe * (shared + router + routed * cfg["num_experts_per_tok"] / cfg["num_experts"]) + norms)
 
print(f"backbone total  {total:,}  ({total/1e9:.2f}B)")   # 124,414,211,552  (124.41B)
print(f"backbone active {active:,.0f}  ({active/1e9:.3f}B)")  # 5,103,302,112  (5.103B)

5.103B active is a near-exact match to the announced "5.1B." One judgment call sits inside that number: embed - vocab_size * H drops one of the two 402,391,040-parameter embedding matrices from the active count — word_embeddings is a single-row lookup per token, so it's cheap in a way lm_head (a full matmul over 157,184 logits, every token) is not, and treating only one of the pair as "active" is the convention that lands on 5.1B. Count both matrices as fully active — defensible, since tie_word_embeddings: false means they really are two separate 402M-parameter weights the checkpoint carries — and the number is 5.51B, about 8% higher. I'd trust 5.1B is the intended reading precisely because it's the one that reproduces the announced figure this cleanly; the honest caveat is that "active parameters" isn't a single unambiguous quantity once embeddings are in the mix, on this model or any other.

What continued training on financial data actually ships

Since the architecture is unchanged, deployment is unchanged too — the card points straight at the base model's own quickstart for SGLang and vLLM, with one specific difference: Ling-3.0-flash-Fin recommends temperature=1.0 for general inference, against the base model's temperature=0.6. Same runtimes, adjusted sampling defaults:

vllm serve inclusionAI/Ling-3.0-flash-Fin \
    --port "$PORT" \
    --trust-remote-code \
    --tensor-parallel-size 4 \
    --gpu-memory-utilization 0.85 \
    --enable-prefix-caching \
    --mamba-cache-mode align \
    --tool-call-parser ling3 \
    --reasoning-parser ling3 \
    --speculative-config '{"method":"mtp","num_speculative_tokens":3}'

--trust-remote-code is load-bearing: the repository ships modeling_bailing_moe_v3.py and configuration_bailing_moe_v3.py as custom code (model_type: bailing_hybrid), 77 files, ~255.0GB in BF16, under MIT — permissive enough that "private deployments" in the card's pitch is a straightforwardly true claim about licensing and self-hosting, not marketing language. What that pitch actually demonstrates is narrower than what it asserts. The card's highlights list five capabilities — end-to-end research linking retrieval to report prep, source-grounded search, multi-document reconciliation across filings, valuation and spreadsheet workflows down to "editable financial-model delivery," and reviewable research outputs — and the benchmark suite backing them is uneven, not uniform: strong on FinFIRST-style search and on SpreadsheetBench V1 (86.50%, competitive with the field), noticeably weaker on SpreadsheetBench V2 (21.81%, the launch chart's weakest showing among the panels it runs) and on APEX-Agents (29.17%, well off Claude-Opus-5's 43.50%). The "editable financial-model delivery" bullet is a real, tested capability, not an invented one — it just isn't the model's strongest one.

FinFIRST: grading where the numbers came from, not just the numbers

The more interesting release ships alongside the model. FinFIRST — Financial Information Retrieval, Sourcing and Traceability — is a 123-task benchmark "developed by Ant Group, with professional support from the investment banking team at [CICC]," open-sourced on Hugging Face under Apache 2.0. Its premise: a financial research answer isn't just a number, it's a number tied to a specific entity, reporting period, currency, unit, definition and data version — get the number right off a stale filing or the wrong fiscal quarter and a final-answer-only grader can't tell the difference between that and a fully sourced one. FinFIRST's fix is to decompose every task's reference solution into atomic criteria — independently gradable yes/no checks — spread across three capability groups: raw-information acquisition, source verification, and computation and answer formation.

The dataset ships as a single 123-row test.jsonl, 24 fields per record. Here's an actual record — id 34, original_id: "v1_49", the same task FinFIRST's own README uses as its worked example:

{
  "id": "34",
  "original_id": "v1_49",
  "language": "英文",
  "source_count": "多个",
  "query": "Using the latest official and industry data available as of June 30, 2026, and Meta's official disclosures together with the IAB/PwC Internet Advertising Revenue Report, calculate Meta's 2025 United States & Canada advertising revenue as a percentage of 2025 U.S. social media advertising revenue. Report the result as a percentage rounded to two decimal places.",
  "answer": "72.45%"
}

Even in an English-language task, the taxonomy fields are Chinese labels (语言: 英文 — "language: English"; 来源数量: 多个 — "source count: multiple") — a bilingual schema over a bilingual dataset (74 Chinese tasks, 60.2%, and 49 English, 39.8%), not translated for the release. The grading lives in rubric_annotated, a plain numbered list, one line per atomic criterion, each closing with a parenthesized capability tag. One line, verbatim:

2. Correctly Identifies that Meta reports advertising revenue by user geography, in millions of U.S.
   dollars. For U.S. & Canada, the 2025 quarterly advertising revenue figures were $18,259 million,
   $20,045 million, $21,331 million, and $25,643 million, 30 points（原始数据查询）

原始数据查询 is "raw-information acquisition" — the criterion is binary and specific: did the agent find these exact four numbers, or didn't it. FinFIRST's own README publishes this exact task as its worked example, typeset as a capability-by-criterion table:

expand

Made interactive, with the same seven criteria and the aggregate split across all 701:

Parsing every rubric_annotated field across all 123 tasks — a five-minute script over the public JSONL, not a number taken from the README — turns up exactly 701 atomic criteria, matching the card's own count to the row. Weighted by FinFIRST's own points (each task's rubric sums to 100, for 12,300 total across the set), the paper reports the three groups at 59.5% / 17.0% / 23.5% (raw-information / source-verification / computation-and-answer). Counting criteria instead of points gives a different split — 51.1% / 19.8% / 29.1% — because a source-verification check is worth about 15 points on average against roughly 20 for a raw-information one; source verification is a larger share of the work than it is a share of the score. Both counts are real, and they're the two views the GradingChain toggle above switches between.

Two more numbers worth stating plainly. The dataset's construction pipeline — scenario-driven task design, expert authoring, then a six-stage quality-control pass (value-and-scope review, independent re-solving by a second expert, cross-validation, rubric audit, LLM-based stress testing against Claude-Opus-5, GPT-5.6-Sol and GLM-5.3, and a final consistency check) — accepted 9.78% of candidate tasks, 123 out of roughly 1,258. And the rubric judge is GLM-5.1, not a held-out human panel for every run: validated once, against 50 sampled instances independently annotated by eight finance professionals, at item-level agreement of Cohen's κ = 0.816 with the human labels — strong agreement, and a number the paper reports rather than asserts.

How Ling-3.0-flash-Fin does on it

FinFIRST evaluated 15 model configurations under one shared harness — ReAct-style, the same web-search, page-visit and Python tools for every model, temperature 1.0. Four metrics come out of the 701 criteria: Atomic (unweighted pass rate across all criteria), Loose Pass (the same 12,300-point weighting used above), Strict Pass (a task only counts if every one of its criteria passes), and, per capability group, a weighted pass rate. The full table:

The claim in the announcement — "82.45% on FinFIRST source verification" — is the Source verif. column, not Atomic or Strict Pass, and checks out exactly against the paper. The paper's own text is more precise than the marketing line: "LING-3.0-FLASH-FIN stands out in source verification, reaching 82.45% — the highest among open-weight models in the lower block of Table 3." That "lower block" is the paper's own grouping, not a cut this article drew — Table 3 draws a dashed rule after DeepSeek-V4-Pro, separating six models the paper calls closed from nine it calls open-weight, Ling-3.0-Flash-Fin among the latter. Made interactive, sorted both ways:

The qualifier is load-bearing. Sorted across all 15, Ling-3.0-Flash-Fin's 82.45% is 4th, behind Claude-Opus-5, GPT-5.6-Sol, and Qwen3.8-Flash — none of which ship weights. Restricted to the nine open-weight models, it's 1st, 1.68 points ahead of GLM-5.3-Flash. Both are true readings of the same number; "standing out among the open models evaluated" is the honest version of the claim, not a hedge added after the fact.

One more result worth pulling out: FinFIRST also separates correct answers from fully supported ones. Of 1,150 correct final answers across all models, 201 (17.48%, micro-averaged) lack complete supporting evidence — the Unsupported-Correct Rate, or UCR. Ling-3.0-Flash-Fin's UCR is 10.00% — third-lowest of the 15, and, per the paper, "below every evaluated open-weight model":

Together, the source-verification score and the low UCR describe the same underlying strength: when Ling-3.0-Flash-Fin gets an answer right, it's unusually likely to have cited the right document to get there — a narrower, more specific claim than "it's a good finance model," and one FinFIRST is specifically built to distinguish from the alternative.

The launch chart: competitive, not dominant

expand

Read the field on this chart: Hy3 (295B total / 21B active), MiniMax-M3 (428B / 23B), DeepSeek-V4-Pro-0813 (1.6T / 49B), GLM-5.2 (753B / 40B), and Kimi-K3 (2.8T / 104B active) — every one of them larger than Ling-3.0-Flash-Fin's 124B/5.1B, several by an order of magnitude on active parameters alone — plus Gemini-3.7-Flash, Claude-Opus-5, and GPT-5.6-Sol. Ling is drawn first and highlighted in every panel, which reads as leading at a glance; it isn't. On FinFIRST specifically, this chart's number is Strict Pass (52.85%, matching the paper's Table 3 exactly, not the 82.45% source-verification figure from the section above) and Ling sits mid-pack, ahead of GLM-5.2, MiniMax-M3, and Hy3, behind Claude-Opus-5 and GPT-5.6-Sol:

The same pattern holds across all nine panels: Ling never posts the top number, but it is consistently in the upper half against models many times its size — the actual claim the "124B beating a 1T-class field" framing is reaching for, stated more precisely. One panel is explicitly sourced outside inclusionAI's own testing — τ³-Banking, whose footnote reads "scores for all models are sourced from Artificial Analysis," the one place this chart's own notes name AA directly:

The "Intelligence Index 38 to 41" claim: unverifiable as of this writing

One more figure circulates about this release, worth checking precisely because it's the kind of claim that's easy to repeat and hard to trace: that financial training lifted Ling-3.0-Flash-Fin's Artificial Analysis Intelligence Index score from the base model's 38 to 41. The base number is solid — Artificial Analysis posted it themselves for Ling-3.0-flash. The "41" for the Fin variant is not something this piece could confirm. It is absent from the model's own Hugging Face card, which never mentions the Intelligence Index at all. Artificial Analysis's own site returns no model page for ling-3-0-flash-fin as of this writing. A live third-party AA tracker checked directly lists Ling-3.0-Flash-Fin's Intelligence Index as unranked, with an "Overall Score: Coming soon" note and only 3 of 422 benchmark rows populated — a state inconsistent with a published "41." The "38 to 41" figure appears in a handful of low-authority aggregator posts, and when those specific pages were fetched directly rather than read through a search summary, the claim wasn't actually present in their text. That's a strong enough signal to say plainly: treat "Intelligence Index 38 to 41" as unconfirmed, not as a verified result of financial training, until Artificial Analysis publishes it themselves.

The take

The honest one-line summary: Ling-3.0-Flash-Fin is exactly what it says on the label, a continued-training run on an unchanged architecture, and the interesting release this week is the benchmark that shipped with it, not the model. FinFIRST's bet — that grading how an agent got to an answer, atomically, across sourcing and raw data and computation, catches failures a final-answer grader can't — is the kind of benchmark design that's more valuable than another leaderboard number, and it's specifically checkable: 701 criteria, 123 tasks, a public JSONL, and a κ = 0.816 human-agreement number the paper reports rather than asserts. Judged against it, Ling-3.0-Flash-Fin's actual result is narrow and real: the best-sourced open-weight model FinFIRST tested, by a real margin, on the specific skill — knowing where a number came from — that the whole benchmark was built to isolate. That is a smaller claim than "the best open finance model," and a more useful one.

Sources: the Ling-3.0-flash-Fin model card (architecture claims, Local Serving section, evaluation chart), its config.json and model.safetensors.index.json, and per-shard safetensors headers read directly from all 65 published shards; the FinFIRST dataset card and its public test.jsonl (701 atomic criteria, parsed directly), and the FinFIRST paper shipped in the same repository (Sections 2.4, 3.3–3.4, 4.1–4.2, Tables 3–4); the base Ling-3.0-flash model card for the shared quickstart and architecture this piece builds on; and Hugging Face's model API (safetensors.parameters, usedStorage) for the base-vs-Fin byte-level comparison. The "Intelligence Index 38 to 41" section reflects a search across Artificial Analysis's own site, the model's card, and independent trackers, none of which confirmed the Fin-variant figure as of 2026-09-08.