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

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/ling-3-0-flash-fin
> date: 2026-09-08
> tags: finance, mixture-of-experts, benchmarks, agents, open-weights, explainer
[Ling-3.0-flash-Fin](https://huggingface.co/inclusionAI/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](/articles/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](/articles/ling-3-0-flash) 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.

<ModelCard repo="inclusionAI/Ling-3.0-flash-Fin" />

## 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:

```text
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:

```python
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](/articles/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:

| | total params | share |
|---|---:|---:|
| 42-layer backbone (embeddings + 42 layers + final norm) | 124,414,211,552 | 97.6% |
| layer 42 — the MTP head | 3,072,194,048 | 2.4% |
| **all 65 shards** | **127,486,405,600** | 100% |

**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:

```python
# 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](https://huggingface.co/inclusionAI/Ling-3.0-flash#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:

```bash
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:

```json
{
  "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:

```text
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:

<Figure
  src="/articles/ling-3-0-flash-fin/fig2.png"
  alt="A worked example from the FinFIRST dataset card: the Meta advertising-revenue question, its reference answer of 72.45%, and a table of seven atomic criteria grouped by capability -- source verification, raw-information acquisition, and computation and answer formation -- each with its point weight, summing to 100."
  caption="FinFIRST's own worked example: one task decomposed into seven atomic, independently-graded criteria (inclusionAI, FinFIRST dataset card)."
/>

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

<GradingChain />

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:

| Model | Atomic | Loose Pass | Strict Pass | Raw-info | Source verif. | Comp. &amp; answer |
|---|---:|---:|---:|---:|---:|---:|
| Claude-Opus-5 | 87.59 | 87.61 | 69.11 | 88.98 | 89.59 | 82.72 |
| GPT-5.6-Sol | 85.45 | 85.92 | **71.54** | 86.85 | 88.68 | 81.58 |
| Kimi-K3 | 84.45 | 80.83 | 59.35 | 84.84 | 70.70 | 77.98 |
| Qwen3.8-Flash | 82.31 | 81.23 | 61.79 | 84.29 | 83.36 | 71.93 |
| GLM-5.3-Flash | 79.60 | 76.64 | 56.91 | 79.50 | 80.77 | 66.44 |
| GLM-5.3 | 79.32 | 80.61 | 60.98 | 83.11 | 78.56 | 75.77 |
| Qwen3.8-Max | 78.17 | 77.40 | 54.47 | 80.33 | 77.75 | 69.72 |
| Qwen3.8-27B | 78.03 | 77.28 | 55.28 | 81.49 | 76.83 | 66.92 |
| DeepSeek-V4-Pro | 76.03 | 75.41 | 51.22 | 80.09 | 73.57 | 64.88 |
| **Ling-3.0-Flash-Fin** | 75.89 | 75.07 | 52.85 | 78.43 | **82.45** | 61.25 |
| Gemini-3.7-Flash | 75.89 | 76.75 | 44.72 | 81.19 | 66.62 | 72.80 |
| DeepSeek-V4-Flash | 72.90 | 71.37 | 48.78 | 77.49 | 71.65 | 55.69 |
| GLM-5.2 | 70.61 | 65.89 | 43.09 | 69.75 | 68.30 | 54.37 |
| Hunyuan3-Thinking | 65.76 | 65.22 | 40.65 | 70.43 | 68.01 | 50.02 |
| MiniMax-M3 | 63.05 | 60.70 | 37.40 | 65.51 | 62.97 | 46.87 |

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:

<SourceVerificationBoard />

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":

| Model | Correct, partial evidence (Q3) | Correct, fully traceable (Q4) | UCR (%) ↓ |
|---|---:|---:|---:|
| GPT-5.6-Sol | 8 | 84 | 8.70 |
| Claude-Opus-5 | 9 | 82 | 9.89 |
| **Ling-3.0-Flash-Fin** | **7** | 63 | **10.00** |
| GLM-5.3-Flash | 9 | 68 | 11.69 |
| Qwen3.8-Flash | 11 | 73 | 13.10 |
| GLM-5.3 | 14 | 70 | 16.67 |
| DeepSeek-V4-Flash | 12 | 58 | 17.14 |
| DeepSeek-V4-Pro | 13 | 59 | 18.06 |
| Qwen3.8-27B | 17 | 65 | 20.73 |
| Hunyuan3-Thinking | 12 | 47 | 20.34 |
| Qwen3.8-Max | 17 | 63 | 21.25 |
| Kimi-K3 | 19 | 70 | 21.35 |
| MiniMax-M3 | 12 | 45 | 21.05 |
| GLM-5.2 | 14 | 51 | 21.54 |
| Gemini-3.7-Flash | 27 | 51 | 34.62 |

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

<Figure
  src="/articles/ling-3-0-flash-fin/fig1.png"
  alt="A nine-panel grouped bar chart from Ling-3.0-flash-Fin's model card, comparing Ling-3.0-flash-Fin (124B total, 5.1B active) against Hy3 (295B, 21B active), MiniMax-M3 (428B, 23B active), DeepSeek-V4-Pro-0813 (1.6T, 49B active), GLM-5.2 (753B, 40B active), Kimi-K3 (2.8T, 104B active), Gemini-3.7-Flash, Claude-Opus-5 and GPT-5.6-Sol across FinFIRST, FinSearchComp Verified, FinCRAFT, Finance Agent v1.1, Finance Agent v2, APEX-Agents, SpreadsheetBench V1, SpreadsheetBench V2, and tau-cubed-Banking. Ling-3.0-flash-Fin is highlighted in blue and shown first in every panel, and is broadly mid-pack to competitive rather than leading any individual panel."
  caption="Ling-3.0-flash-Fin against seven larger open models and two closed frontier models, across nine finance benchmarks (inclusionAI, Ling-3.0-flash-Fin model card)."
/>

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:

<BenchBars
  title="FinFIRST — Strict Pass (%), inclusionAI launch chart"
  bars={[
    { label: "GPT-5.6-Sol", value: 73.17 },
    { label: "Claude-Opus-5", value: 69.11 },
    { label: "Kimi-K3", value: 62.60 },
    { label: "Gemini-3.7-Flash", value: 57.72 },
    { label: "DeepSeek-V4-Pro", value: 54.47 },
    { label: "Ling-3.0-flash-Fin", value: 52.85, highlight: true },
    { label: "Hy3", value: 44.72 },
    { label: "MiniMax-M3", value: 41.46 },
    { label: "GLM-5.2", value: 40.65 },
  ]}
/>

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:

<BenchBars
  title="τ³-Banking (%), inclusionAI launch chart — scores sourced from Artificial Analysis"
  bars={[
    { label: "Kimi-K3", value: 46.00 },
    { label: "GPT-5.6-Sol", value: 44.30 },
    { label: "Claude-Opus-5", value: 42.10 },
    { label: "Ling-3.0-flash-Fin", value: 41.00, highlight: true },
    { label: "DeepSeek-V4-Pro", value: 39.60 },
    { label: "GLM-5.2", value: 34.60 },
    { label: "Gemini-3.7-Flash", value: 32.80 },
    { label: "Hy3", value: 22.90 },
    { label: "MiniMax-M3", value: 15.30 },
  ]}
/>

## 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.

<Callout type="warn">
**Read these as vendor numbers, checked where checkable.** (1) Table 3, Table 4, and the FinFIRST rubric
statistics above come from FinFIRST's own paper and public `test.jsonl` — independently reproducible, and
reproduced here. (2) The nine-panel launch chart is inclusionAI's own evaluation, run at their listed
settings; APEX-Agents mixes sources (some models scored via Mercor, others via inclusionAI's own testing per
the chart's footnotes), which the chart discloses but this article can't independently audit. (3) The
parameter counts in this piece come from real tensor shapes read directly off all 65 published safetensors
shards, cross-checked against a closed-form computation from `config.json` and against Hugging Face's own
API total — but the "5.1B active" figure still depends on one convention choice (how to count the two
untied embedding matrices) that isn't specified anywhere in inclusionAI's materials. (4) The "Intelligence
Index 38 to 41" claim is flagged above as unverifiable, not debunked — it may simply not be published yet.
</Callout>

## 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](https://huggingface.co/inclusionAI/Ling-3.0-flash-Fin)
(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](https://huggingface.co/datasets/inclusionAI/FinFIRST) 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](https://huggingface.co/inclusionAI/Ling-3.0-flash) 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.*