Why We Open-Sourced Ling-3.0 tiny & flash Base Models
Earlier this week, a developer in the Ling-3.0-tiny community asked a question that cut straight through the usual launch noise: “Can we get a Base Model?”
A community request for the Ling-3.0-tiny Base Model.
The request was not for another chat interface, another benchmark chart, or another polished demo. It was for the part of the system that comes before all of that: a model that could still be trained, tested, and shaped around a new problem.
This week, Ant Ling released it. We open-sourced the completed Base Models of Ling-3.0-tiny and Ling-3.0-flash, alongside key weights from their pre-training and mid-training stages. The Base Models are the point. The earlier weights make that point more useful: together, they open a meaningful training path, not only the point at which that path ends.
The model before the product
Most people meet an AI model after its consequential decisions have already been made. They meet it as a chatbot, an API, an agent, or a finished product. It has been shaped to follow instructions, respond in a particular style, and fit a particular interaction model. Those choices are necessary when a model is meant to serve users directly. But they also narrow the starting point.
A team building a code agent for a large repository does not need the same model behavior as a team training for medical research. A financial workflow has different data, validation, and responsibility requirements from an industrial workflow. A long-horizon agent must be evaluated on planning, tool use, recovery, and reliability—not only on the quality of a single answer.
A Base Model preserves room for that work. It gives a research team a foundation for continued pre-training, supervised fine-tuning, preference optimization, reinforcement learning, distillation, and task-specific evaluation. It lets developers decide what success means for the problem they are actually trying to solve.
Beyond black-box imitation
As models become more capable, the AI ecosystem faces a choice. One path treats a strong model primarily as a black-box endpoint: observe its outputs, reproduce its behavior as closely as possible, and measure progress by resemblance.
Distillation has a legitimate role in model development. Used responsibly, it can transfer useful behavior, reduce cost, and make capable systems easier to deploy. But it cannot be the whole logic of progress. An ecosystem built only around reproducing visible outputs spends less effort understanding the task, building original data, defining better evaluation, and developing new methods.
An open Base Model offers a more constructive route. It gives developers a first-party foundation rather than a behavior to infer from the outside. They can begin with their own data, task, and criteria for quality. They can develop systems that are specialized, accountable, and genuinely useful in the environments where they operate.
Key checkpoints released for Ling-3.0-tiny and Ling-3.0-flash.
A training path that can be continued
The pre-training and mid-training weights are not a second release story. They make the Base Models more useful by giving the community meaningful places to begin. A team exploring continued pre-training may choose an earlier stage; a researcher studying training dynamics can compare model behavior across stages; a developer with a defined post-training plan may begin from the completed Base Model.
For both Ling-3.0-tiny and Ling-3.0-flash, we released a pre-training checkpoint, a mid-training checkpoint, and the completed Base Model. After mid-training, Ling-3.0 uses WSM—Warmup-Stable and Merge—a checkpoint-merging approach that supports continued pre-training, dynamic data expansion, and offline exploration of different training trajectories.
The point is not to turn training history into a trophy case. It is to give the community a foundation that can be studied, extended, and adapted rather than treated as fixed.
Two foundations for different work
Ling-3.0-tiny-base has 7.9B total parameters and 1.3B activated parameters. Its sparse architecture makes it a practical foundation for continued pre-training, coding-focused fine-tuning, reinforcement-learning research, model-behavior studies, MoE experiments, and domain validation. Tiny is not merely a smaller model. It is where more teams can test an idea, inspect the result, and learn what is worth scaling.
Ling-3.0-tiny-base benchmark comparison.
Ling-3.0-flash-base has 124B total parameters and 5.1B activated parameters. It is designed for work that needs greater capacity: software engineering, large codebases, complex reasoning, long context, and agentic systems. In finance, healthcare, scientific research, and industry, that capacity still needs to be shaped by domain data, specialist evaluation, and clear responsibility boundaries. Flash is not a shortcut around that work; it is a stronger foundation for doing it.
Ling-3.0-flash-base benchmark comparison.
Tiny and Flash share a unified training approach. A team can validate a method on Tiny and carry a proven direction to Flash when the task requires more scale, stronger reasoning, or longer context. That creates a practical path from experiment to deployment—one in which scale follows understanding.
The work begins here
Ling-3.0-tiny-base and Ling-3.0-flash-base are completed Base Models. They are not instruction-aligned chat products, and they should not be deployed directly to end users without task-specific post-training, evaluation, and validation. That is not a caveat attached to the release. It is central to its purpose.
Open source is not the absence of responsibility. It is the ability for more people to build responsibly, test rigorously, and contribute new knowledge to the field. We open-sourced Ling-3.0 tiny & flash Base Models because we want the community to have more than access to a finished result. We want it to have the freedom to build what comes next.
Start building
Ling-3.0-tiny
Hugging Face
ModelScope
Ling-3.0-flash
Hugging Face
ModelScope