Ant Group Open-Sources Ling-3.0-flash: 124B Model Activates Only 5.1B Parameters

Ant Group’s Ling large-model team officially open-sourced its next-generation natively hybrid-reasoning model Ling-3.0-flash yesterday (August 7). It uses a 124B-parameter MoE (Mixture-of-Experts) architecture, but activates only approximately 5.1B parameters for each token. It is also available in multiple versions, including base weights, FP8, FP4, and INT4.

This is not simply “yet another tens-of-billions-parameter model being open-sourced.” The key focus of Ling-3.0-flash is compressing a system with the knowledge capacity of a large model into a per-token inference cost closer to that of a medium-sized model. For Agent applications that require long contexts, tool calling, and continuous task execution, this design is more practically significant than simply pursuing a larger parameter count.

Why Does a 124B-Parameter Model Need to Run Only 5.1B Parameters?

The core of Ling-3.0-flash is sparse MoE. It can be thought of as a company with a 124B-sized “team of experts.” However, when processing a given question, it does not bring everyone in at once. Instead, it selects a small number of experts based on the content of the current token and has only those experts participate in the computation.

Therefore, 124B is the model’s total capacity, while 5.1B is the activation scale per token. The former determines how much knowledge the model can store and how many capabilities it can cover; the latter has a more direct impact on the computational load and latency during inference. The two are not contradictory, and Ling-3.0-flash cannot simply be equated with a 5.1B dense model.

According to publicly available information, the Ling-3.0 series also adopts a natively hybrid linear-attention design, combining attention mechanisms such as KDA and MLA to address memory and computational efficiency in long-context scenarios. The model natively supports a 256K context window and can scale to 1M tokens. For tasks such as codebase analysis, long-document review, and complex Agent trajectory compression, this design is more noteworthy than simply expanding the KV cache.

It is important to emphasize that a low number of “activated parameters” in an MoE model does not mean deployment has no barriers at all. The total parameter count still determines the storage requirements for the weights. In multi-GPU services, expert routing, memory distribution, communication overhead, and batching strategies all affect the final throughput. What MoE reduces is computational pressure—not the weight footprint of a 124B model magically becoming that of a 5.1B model.

Three Deployment Options, from API Access to Single-Machine Private Deployment

The most practical aspect of this open-source release is not merely that the model weights are available. It is that the team has also provided relatively clear deployment paths.

1. API: The Fastest Way to Validate Products and Agents

For most developers, an API remains the lowest-barrier option. Teams do not need to prepare a GPU cluster or deal with quantized weights, tensor parallelism, service orchestration, or elastic scaling. They can directly integrate Ling-3.0-flash into existing conversational, coding-assistant, or Agent workflows.

Ant Group provides API access through Ling Studio and announced that from 00:00 on August 7, 2026, through 24:00 on August 31, 2026, usage will be billed at 25% of the regular price, with standard pricing restored on September 1. For development teams, this window is more like an opportunity for low-cost load testing: they can use real requests to observe tool-calling success rates, long-context stability, response speed, and token consumption, rather than looking only at public benchmarks.

For projects that already use the OpenAI-compatible protocol, integration costs generally will not be concentrated in SDK changes, but rather in behavioral differences between models. For example, tool-calling fields, the output of reasoning processes, JSON strictness, end markers in streaming responses, and whether the model repeatedly calls the same tool during long-running tasks all need to be revalidated during the gradual rollout phase.

OpenAI Hub and other aggregation platforms compatible with the OpenAI format can also serve as entry points for developers comparing different models. Under the same business logic, developers can switch among Ling-3.0-flash, GPT, Claude, Gemini, and DeepSeek. The key metric should be the “total cost of completing a task,” rather than the input or output price alone.

2. Single-Machine Private Deployment: It Can Run on a DGX Spark

The second path officially provided is private deployment for enterprises and teams whose data cannot leave their environments. With the MXFP4 and INT4 versions, Ling-3.0-flash can perform end-to-end inference on a single NVIDIA DGX Spark.

This has practical value for scenarios such as internal enterprise knowledge bases, codebase analysis, contract review, and R&D assistants. In the past, running models with tens of billions of parameters or more locally often required multiple data-center GPUs, along with additional work for model sharding and inter-GPU communication. If a 124B MoE model can run on a device such as the DGX Spark, it at least means that small teams may have an opportunity to bring a high-capacity model into a local environment.

However, “can run” and “runs well” are two different things. The INT4 version is more favorable in terms of memory usage and deployment cost, but may incur some accuracy loss on certain tasks. MXFP4, meanwhile, requires hardware and software stacks that are better matched to the format. When choosing a quantized version, enterprises should not only check whether the model can load; they should also measure core workflows such as code generation, tool calling, structured output, and long-context retrieval.

3. High-Performance Deployment: Targeting Low Per-Request Latency

Under a specified GPU test configuration, Ling-3.0-flash achieved an average output rate of more than 1,100 tokens per second. This figure obviously cannot be reproduced directly by every developer; it depends on the specific GPU model, parallelism strategy, context length, batch size, quantization method, and serving framework.

Nevertheless, it still illustrates the model’s design direction. Ling-3.0-flash is not a “large model” intended only for offline batch processing. It is designed to enter production systems that require rapid feedback. Citing data from Artificial Analysis, the official team stated that the model achieves an output speed of 353 tokens per second. In code completion, real-time customer service, browser Agents, and multi-turn tool calling, a speed advantage is more likely to translate into user experience than a higher offline benchmark score.

Speed is particularly important for Agents. A complex task may require the model to perform inference a dozen or even dozens of times in succession, with each step reading the results returned by tools. If each response is shortened by a few seconds, the entire task chain can shift from “feeling like waiting for a program to run” to “approaching real-time operation.” This is the core position that Flash-class models are competing for: they may not replace the strongest flagship models, but they can handle a large volume of high-frequency, repetitive work that requires rapid decision-making.

The Cost Data Looks Good, but Should Not Be Treated as a Direct Invoice

According to the AA Intelligence Index, Ling-3.0-flash has a weighted average invocation cost of approximately $0.04 per task, equivalent to about RMB 0.27. Its weighted average decoding time is approximately 1.4 minutes, placing it in the favorable regions of the “intelligence level vs. task cost” and “intelligence level vs. task duration” charts.

This data is useful as a reference for model selection, but it should not be directly interpreted as the final cost for every application. Leaderboards generally incorporate different task types, context lengths, and output volumes into an aggregate calculation, while real-world business applications also incur the following additional costs:

• Whether input context must be repeatedly included, especially long documents and tool histories;
• Whether the Agent enters ineffective loops or makes repeated calls;
• Whether a more powerful model is needed for failed-task retries;
• Validation and repair costs caused by unstable structured output;
• GPU depreciation, electricity, operations, and concurrency redundancy in private deployments.

In other words, $0.04 is better viewed as a “task-level efficiency metric” than as a fixed price list. What developers should actually measure is how many tokens, model calls, and human fallbacks are required to complete an order, fix an issue, generate a report, or run an automated workflow from start to finish.

When Compared with the Previous-Generation Flagship, Task Allocation Matters More Than Parameter Battles

Ant Group previously positioned Ling-3.0-flash as comparable in capability to larger flagship models such as the previous-generation Ring-2.6-1T. The interesting question is not whether 124B can comprehensively defeat 1T, but whether a sparse architecture can achieve similar task-completion performance to a flagship model at a lower cost.

For general question answering, simple summarization, and routine rewriting, differences in parameter scale often do not translate directly into perceptible differences for users. On complex reasoning, long-chain planning, extreme code debugging, and low-frequency knowledge queries, flagship models generally retain an advantage. Ling-3.0-flash is better suited to the following tasks:

1. High-frequency conversations and real-time responses;
2. Intermediate decision-making nodes in Agent workflows;
3. Large-scale code review, document extraction, and classification tasks;
4. Enterprise applications that are cost-sensitive but do not want to fall back to small models;
5. Scenarios requiring private deployment while retaining the knowledge capacity of a relatively large model.

A more reasonable architecture may not be to “replace the flagship model everywhere,” but to adopt hierarchical routing: let Ling-3.0-flash handle most routine requests, then escalate to a more capable but more expensive model for difficult reasoning, critical decisions, or repeated failures. This kind of model-level scheduling is closer to production reality than simply configuring every request to use the strongest available model.

After Open-Sourcing, the Real Test Is Just Beginning

Ling-3.0-flash is now available on Hugging Face and ModelScope, with a base version as well as FP8, FP4, and INT4 weight options. For the community, the availability of multiple quantized versions lowers the barrier to experimentation and facilitates adaptation to different hardware platforms.

Three things are worth watching next.

First is independent reproduction. The official speed and cost figures were obtained under specific conditions. The community will be more interested in actual performance across different GPUs, inference frameworks, and context lengths—particularly memory consumption and throughput curves when running on a single machine.

Second is Agent capability. Whether a model can reliably use tools, follow JSON Schema, and handle multi-turn error feedback often matters more to production suitability than a one-time benchmark test. Ling-3.0-flash is explicitly positioned as a “production-grade Agent reasoning” model, so tool calling and long-task stability will become key evaluation criteria.

Third is the price gap between open-source weights and hosted APIs. If the API is inexpensive enough during the promotional period, developers may have little incentive to deploy the model themselves. But as usage increases and data-compliance requirements become stricter, the FP4 or INT4 private-deployment versions may regain their appeal. The two options are not mutually substitutive; they correspond to the validation and scaling stages, respectively.

Overall, the value of Ling-3.0-flash does not lie in the number “124B” itself. Rather, it lies in combining high-capacity modeling, sparse activation, hybrid attention, and multiple quantization tiers into a relatively complete deployment solution. It may not be the strongest model for every task, but it is likely to be one of the open-source models most worth testing in Agent production pipelines in the near term.

Sources

• ITHome: Ant Group’s Ling team open-sources the Ling-3.0-flash model — Covers the model’s open-source release, parameter scale, quantized versions, deployment methods, speed, and limited-time discount.
• Hugging Face: inclusionAI/Ling-3.0-flash — Official repository for Ling-3.0-flash’s open-source model weights and related files.