Ling 3.0 Flash Base vs Ling 3.0 Flash: Hetzelfde 124B-model, afgewerkt of onafgewerkt

Ling 3.0 Flash Base and Ling 3.0 Flash are not two different models. They are the same 124-billion-parameter mixture-of-experts model at two exits from the same training pipeline: Ling 3.0 Flash Base is the raw checkpoint that Ant Group's inclusionAI lab published to Hugging Face in a quiet release on August 12, and Ling 3.0 Flash is what the lab's post-training turned that checkpoint into — the agent-tuned chat model that launched in late July, was open-sourced under MIT in early August, and has been independently benchmarked since. Which one you want comes down to one question: are you going to finish the training yourself, or do you want the finished product?

One model, two exits from the same pipeline

Open the two model cards and the specification blocks are identical: 124B total parameters, ~5.1B activated per token, 512 routed experts, a hybrid stack of Kimi Delta Attention and Gated MLA layers, a native 256K-token context window, and an MIT license. The difference is where in the training sequence each checkpoint was taken.

The base card sits in a collection of training-stage checkpoints that inclusionAI published together. Ling-3.0-flash-base-30T is the pretrained checkpoint, Ling-3.0-flash-base-midtrain is the mid-trained stage, and Ling-3.0-flash-base — the model this piece is about — is the merged stage. The merge is the interesting part: instead of finishing pretraining with a conventional learning-rate decay, inclusionAI applied WSM merging (Warmup-Stable-Merge, linked from the card to the paper arXiv:2507.17634), which combines the weights of late-training checkpoints into a single model. The card is explicit that this checkpoint has gone through WSM merging but not through post-training. The flash model is the next step in the same sequence: the base, plus the supervised fine-tuning and reinforcement learning that turn a raw foundation model into something that chats, calls tools, and runs agentic loops.

• Architecture — identical: 124B total / ~5.1B active, 512 routed experts (8 + 1 shared per token), 35 KDA + 7 Gated MLA layers, 256K native context, MIT license.

• Training stage — Ling 3.0 Flash Base: pretraining + mid-training + WSM merge, no post-training. Ling 3.0 Flash: the same, plus SFT and RL alignment.

• What it does out of the box — Base: next-token prediction only; the card says it is not for direct chat deployment. Flash: chat, instruction following, tool calling, thinking and non-thinking modes.

• Hosted API — Base: none, a weights download that is self-host only. Flash: the vendor's first-party API and several third-party platforms.

• Evaluation — Base: the card's own base-model tables, no independent scores. Flash: an Artificial Analysis Intelligence Index of 38 and measured ~368 output tokens/s.

• Price — Base: no list price; you pay the compute. Flash: roughly $0.075 per 1M input / $0.22 per 1M output on the first-party API, with cache reads ~80% cheaper.

The scoreboard makes the divergence visible: the architecture row is identical, and every other row splits on whether post-training happened. Same brain, different finishing — that is the whole comparison.

What you give up by taking the base

Start with what Ling 3.0 Flash Base is not. It is not a chat model. The model card is blunt about it, listing direct end-user chat deployment, safety-critical use without alignment, and production use without post-training as things the checkpoint is not recommended for as-is. There is no hosted API, and at the time of writing the repository shows no announcement, no likes, and no downloads on Hugging Face — a quiet ship with nothing but the weights to judge it by.

Self-hosting the base is a serious proposition: roughly 255GB of BF16 weights, a custom code base for the hybrid KDA + MLA architecture, and the same 124B/5.1B MoE serving profile as the flash model. This is where this pairing's real divergence sits — not in a benchmark where the two score differently, but in the fact that the base has no chat benchmark at all. There is no Artificial Analysis page for it, and nobody has reproduced a score, because there is nothing to prompt as a chat model yet. You cannot put the two side by side on instruction-following tests; the base was never given the training that produces instruction-following behavior.

What the base buys that Flash cannot

Ling 3.0 Flash Base's purpose is to be trained on. The card lists continued pre-training, mid-training, supervised fine-tuning for domain adaptation, preference optimization and RL post-training, distillation research, and long-context and MoE systems research. Because the WSM merge eliminates the decay phase, the card argues the base is better suited for continual pretraining than a conventionally decayed checkpoint would be — the claim being that a merged model keeps learning instead of arriving pre-settled.

Three practical things follow. You own the post-training: if you want a domain specialist — legal, biomedical, code — you can fine-tune and align from the base rather than prompting a generalist to behave like one. The family gives you stage control: the 30T, mid-train, and merged checkpoints are all published, so you can start from the exact training stage you want to build on. And the recipe is shared with the tiny model: inclusionAI publishes the same three-stage layout for Ling 3.0 Tiny, explicitly so teams can validate a strategy on the far smaller Ling-3.0-tiny-base before committing the compute to a 124B base. If you are going to experiment at all, that is the sane first step.

Price, latency, context — where the two actually sit

Because the weights are the same architecture, the serving economics are nearly identical. Running the base yourself costs the same compute as running the flash model yourself — a 124B-parameter MoE with ~5.1B active params needs a serious GPU cluster either way. The difference is on the demand side: Ling 3.0 Flash can be called per token through the vendor's first-party API at roughly $0.075 per 1M input and $0.22 per 1M output, with cache reads about 80% cheaper, while the base has no such price because it has no API. Its cost is the hardware you put under it.

Latency follows the same logic. On the flash model's hosted API, Artificial Analysis measured ~368 output tokens/s with about a 2-second time to first token. The base has no measured serving numbers — nobody has served it publicly — but on the same hardware the architecture is identical, so the realistic expectation is the same profile, not a better one. Context is where the two are perfectly matched: both carry a native 256K-token window (262,144 served), trained up through a schedule that ramps from 8K to 256K. If your decision turned on long-context headroom, this pairing makes it for you: both sides have the same headroom.

Artificial Analysis is where the flash model's independent numbers live — an Intelligence Index of 38 and a measured ~368 output tokens/s — data the base checkpoint does not have because there is nothing public to serve it with yet.

Wie moet welke kiezen

Pick Ling 3.0 Flash Base if you are a training team: you are doing continued pretraining or domain-adaptive training, you plan to SFT and align a custom model, or you are studying checkpoint merging, hybrid attention, or MoE systems and want a clean, MIT-licensed 124B foundation. It is also the cheaper path if you were going to retrain anyway — a lab that will post-train a model regardless should not pay per-token API prices for a model it is about to alter.

Pick Ling 3.0 Flash if you are building products: you need a working text model today — chat, tools, agents — with a hosted API, independent benchmark data, and a 256K context, and you have no interest in operating 255GB of weights yourself. The flash model is a known quantity with months of public track record; the base is an unannounced checkpoint with zero independent evaluation. If you are not sure, run the flash model first and only move to the base when you have a specific training goal the finished model cannot serve.

Why this choice does not have to be permanent

Both weights are MIT-licensed open checkpoints, which means the two are not mutually exclusive in practice. You can self-host a fine-tune of Ling 3.0 Flash Base while keeping Ling 3.0 Flash on a hosted API, and switch traffic between them by configuration instead of by rewrite. That is the pattern a routing layer exists for: one API across 200+ models, automatic failover when the experimental model underdelivers, and provider list prices passed through at 0% markup, as OrcaRouter runs it. You can A/B your own base fine-tune against the finished model on a test path, fall back to the proven one in production, and change the split without touching application code — which is exactly the right posture for a checkpoint as unverified as this one.

Three questions the base card leaves open

Can you chat with Ling 3.0 Flash Base out of the box?

No. It is a pretrained foundation checkpoint with no instruction tuning and no alignment, and the card explicitly warns against direct end-user chat deployment. If you want a chat model, that is Ling 3.0 Flash. If you want a chat model built on the base, you have to post-train it first — which is the entire point of the checkpoint.

Can you fine-tune the base yourself?

Yes — that is its stated purpose. The card lists continued pretraining, mid-training, supervised fine-tuning, and RL post-training as intended uses, and points to the ling-cookbook repository for fine-tuning examples. The recommended cheap first step is to validate your recipe on the shared-stage Ling-3.0-tiny-base before spending the compute on the 124B flash base.

Is the base cheaper than the flash model?

Only if you count the download. Ling 3.0 Flash Base is free to pull and MIT-licensed, but it has no API, so every token you generate costs whatever it costs you to serve a 124B/5.1B MoE — the same hardware bill the flash model would demand if you served it yourself. On a per-token basis the flash model's hosted API is usually the cheaper way to get answers; the base is the cheaper way to get something to retrain.

The honest status: Ling 3.0 Flash Base is a foundation checkpoint the vendor has not announced, and everything beyond its architecture and intended use is unverified until someone post-trains it, benchmarks it, or serves it. What is knowable today is that it and Ling 3.0 Flash are the same model at two stages, and that the choice between them is really a choice about whether the training work is yours or theirs. Watch for an official announcement, a first hosted endpoint, or a first independent evaluation — any of those turns this from a decision about a quiet repository into a decision about a real option.