Ant Bailing’s New Model Activates Just 5.1B Parameters

On July 24, Ant Group’s Bailing large-model team released Ling-3.0-Flash, a new-generation native hybrid reasoning model. The model has 124B total parameters but activates only 5.1B parameters per computation. According to the official announcement, its overall capabilities match—and in some areas surpass—those of the previous-generation Ring-2.6-1T flagship reasoning model.

The numerical contrast is striking: total parameters have been reduced to 12.4% of the previous generation, while activated parameters have fallen to approximately 8.1%, yet capabilities have not declined proportionally. Put another way, Ling-3.0-Flash uses only about 4.1% of its total parameters during each inference pass.

This is not a matter of brute-force quantizing a hundred-billion-parameter model into a smaller one. Instead, it separates “knowledge capacity” from “per-inference compute cost” through sparse MoE, hybrid attention, and caching systems. In today’s large-model competition, this path is far more practical than continuing to scale models to tens of trillions of parameters.

124B Is Capacity; 5.1B Is Closer to the Inference Bill

When evaluating an MoE model, looking only at its total parameter count can be misleading.

Ling-3.0-Flash has 124B total parameters, representing the scale of experts, knowledge, and patterns the model can accommodate. However, when processing a token, the router does not engage all parameters simultaneously. It activates only a small number of experts. Therefore, the 5.1B activated parameters reflect the computational burden of each inference step more accurately than the 124B total parameters.

Of course, activating 5.1B parameters does not mean the model is as lightweight as a 5.1B dense model in every respect.

There are at least three differences:

• VRAM usage is still affected by the total parameter count. The 124B weights must be loaded or distributed across multiple accelerator cards, so the deployment threshold does not magically fall to that of a 5B model.
• Communication costs cannot be ignored. When experts are distributed across different devices, token routing generates inter-card or inter-node communication. This overhead can consume part of MoE’s theoretical computational advantage.
• Throughput depends on engineering implementation. Batch scheduling, expert load balancing, quantization precision, and the inference framework all affect the final tokens-per-second rate and concurrency capacity.

Therefore, the most accurate interpretation of “activates only 5.1B parameters” is that it substantially reduces the effective amount of computation required per token. It does not mean developers can run the full weights easily on a single consumer GPU, as they could with an ordinary 7B model.

Even so, this activation ratio remains highly aggressive. For a model to preserve its reasoning, instruction-following, and long-context capabilities while using only about 4.1% of its parameters, the training process must solve problems involving expert specialization, routing stability, and load balancing. Otherwise, an MoE model can easily end up frequently invoking only some experts while leaving others idle for long periods, resulting in “a large parameter count on paper but underutilized capacity in practice.”

The Key Is Not a Single Architecture but a Three-Layer Combination

The core changes in Ling-3.0-Flash can be divided into three layers: the model backbone, the expert network, and server-side caching.

1. KDA and MLA Interleaved at a 5:1 Ratio

Starting from pretraining, the model uses a hybrid linear-attention architecture that alternates KDA and MLA layers at a 5:1 ratio. It does not first train a conventional Transformer and then add a temporary “thinking mode” during post-training. This is also why the company emphasizes “native hybrid reasoning.”

The two mechanisms can be understood as different memory channels: the linear-attention path is better at controlling the computational cost of long sequences, while MLA preserves stronger content addressing and fine-grained association capabilities. Using standard attention exclusively causes long-context costs to grow rapidly with sequence length; relying entirely on linear attention may sacrifice complex retrieval and precise local associations. Interleaving the two is an engineering compromise between efficiency and expressiveness.

This generation of KDA also introduces more fine-grained diagonal gating. The gates act like learnable valves: the model can determine more precisely which states should be preserved and which information should decay, rather than allowing all historical information to flow through the context in the same way.

This is important for long-running tasks. When an agent performs dozens of consecutive tool calls, the real challenge is not “how many tokens can fit,” but whether it can preserve the task objective, constraints, and key intermediate results while filtering out repetitive logs and irrelevant webpage content.

2. 1/64 Sparse MoE Reduces Expert Activation Even Further

Ling-3.0-Flash uses a 1/64 sparse MoE architecture. In simple terms, the model contains a large pool of expert parameters but selects only a very small subset for each computation.

The goal of this design is to give the model hundred-billion-parameter capacity without requiring all 124B parameters to run whenever it generates a token. It is particularly well suited to agent scenarios involving diverse task types: coding, web retrieval, mathematical reasoning, tool planning, and text summarization can rely on different combinations of experts instead of forcing one dense parameter set to handle everything.

However, greater sparsity is not always better. The fewer experts selected, the cheaper each computation becomes—but the cost of routing errors also rises. If the model continuously sends code-completion tokens to unsuitable experts, output quality can deteriorate rapidly. Whether this metric ultimately provides value therefore depends on real-world task performance, expert load distribution, and the ability of the inference framework to keep up—not merely on the architectural ratio.

3. HiCache and Mooncake Reduce Repeated Computation in Long Tasks

Bailing has also integrated SGLang HiCache and Mooncake’s hierarchical caching architecture into its serving system. Through physically separated dual pools and a cluster-shared L3 cache, the system can reuse long-context states. Official figures indicate that time to first token (TTFT) can be reduced by 60% to more than 80% in long-input scenarios.

This is useful, but an important distinction must be made: the benefit is jointly produced by the model’s capabilities and the inference infrastructure; it does not come entirely from the model weights themselves.

In Deep Research or Coding Agent scenarios, system prompts, code-repository context, tool definitions, and previous conversation turns are often transmitted repeatedly. Without caching, every request must recompute the long prefix. With hierarchical caching, the server can reuse existing KV caches or states, making the incremental computation closer to “processing only what changed in the current turn.”

This is similar to incremental compilation in software development: the compiler has not suddenly become smarter; it simply no longer needs to recompile unchanged portions.

Therefore, a TTFT reduction of 60% to 80%+ cannot be directly extrapolated to every deployment environment. Cache hit rate, prefix stability, concurrency scale, cache eviction policies, and cluster networking all affect the results. Developers who later download and self-host the weights will not automatically obtain the same latency performance as the official service.

The Target This Time Is Agent Economics

For Ling-3.0-Flash, Bailing expanded its training to more than 10,000 interactive environments, focusing on Coding, General Agent, and Deep Research Agent tasks. The aim is for the model not only to answer static questions but also to complete long-horizon loops involving “planning—tool invocation—result reading—error correction—continued execution.”

This training direction is closer to real production environments.

Traditional benchmarks usually involve one question and one answer, and the cost of failure is simply losing points on a single problem. Agents are different: if a model selects the wrong tool at step three, the problem may not become apparent until step 20. Every unnecessary webpage fetch or uncontrolled code retry increases token, tool, and time costs. Even if a model scores highly on individual questions, unstable long-horizon state management can still make it difficult to deploy in production.

Ling-3.0-Flash’s architectural choices effectively address three cost categories for agents:

1. Per-step inference cost: Reduce per-token computation by activating only 5.1B parameters;
2. Long-context cost: Use hybrid linear attention to control the overhead caused by sequence growth;
3. Repeated multi-turn cost: Use hierarchical caching to reduce recomputation of shared prefixes and historical states.

This has more practical significance than simply claiming that “the model is smarter.” The cost of an agent product is not a single API call but the sum of dozens or even hundreds of model calls within one task. Making each step 20% cheaper may not be enough to change the product’s viability. Only by simultaneously optimizing activation volume, long-context processing, and caching can automated research, code maintenance, and back-office operations that previously failed the cost-benefit test potentially become routine.

Matching a 1T Flagship Should Still Be Treated as an Official Claim for Now

According to the official announcement, Ling-3.0-Flash can match or even surpass Ring-2.6-1T across conventional reasoning, instruction following, long-context processing, and agent tasks.

If these results can be reproduced in public evaluations and real deployments, their significance would be considerable. They would indicate that capabilities previously obtained through massive parameter counts are now being compressed into a much smaller activation footprint through better architecture, data, and post-training methods.

At this stage, however, it would be premature to draw conclusions based solely on the claim that it “matches the previous-generation flagship.”

What developers really need to examine includes:

• Whether the benchmarks contain enough independent evaluations rather than only tasks that favor the model;
• Whether response length and reasoning tokens are fairly included in cost calculations under hybrid reasoning mode;
• Whether the Coding Agent can modify real repositories and pass tests rather than merely generate individual functions;
• Whether Deep Research can cite sources correctly, cross-check claims, and handle conflicting information;
• Whether long-context performance comes from the model itself or depends heavily on the official caching cluster;
• Whether expert routing remains balanced under high concurrency, with stable throughput and tail latency.

In other words, parameter efficiency is a strongly positive signal, but it is not a complete conclusion. This is especially true for MoE models: there is no simple conversion between laboratory activation counts, single-request latency, and the cost per million tokens in a production cluster.

Free Until August 3, With Open Weights to Follow

Ling-3.0-Flash is now available through a limited-time free API on Bailing’s official platform and third-party model-routing platforms. The free-access period ends at 11:00 p.m. Beijing Time on August 3, 2026. The company plans to officially open-source the model weights after the free period concludes.

This free window is better suited to targeted stress testing than casual chat. Developers can prioritize the following scenarios:

• Cross-file modifications and test fixes in very large code repositories;
• Multi-turn web retrieval, synthesis, and citation verification;
• Function-selection accuracy with large toolsets;
• The ability to preserve constraints over long conversations;
• Changes in TTFT when repeatedly calling the model with the same long prefix;
• Differences in quality, latency, and token consumption between reasoning mode and fast-answer mode.

Because the model weights have not yet been officially released, it is also too early to judge local deployment costs based solely on API performance. After the weights are open-sourced in August, weight precision, licensing, quantization support, context length, inference-framework compatibility, and multi-GPU deployment options will determine whether the model can truly enter private enterprise environments.

Assessment: It Demonstrates the Next Stage of “Low Activation, High Capacity”

The most noteworthy aspect of Ling-3.0-Flash is neither the large 124B figure nor the contrast created by highlighting 5.1B in isolation. It is Bailing’s attempt to optimize model training and the inference system as a unified whole.

Competition among flagship models used to focus mainly on parameter counts, leaderboard rankings, and context-window sizes. The question has now become: at the same task success rate, who can complete the job with fewer activated parameters, less repeated computation, and more stable long-horizon state?

By this standard, Ling-3.0-Flash is moving in the right direction, and it offers more product value than simply building another 1T model. It concentrates compute on the experts that are actually selected by the router, then uses linear attention and caching to reduce the cost of long-running tasks. Its objective is clearly aimed at agents that can operate sustainably.

However, the claim that “5.1B activated parameters can outperform a 1T flagship” still requires verification through open-source weights, third-party benchmarks, and real cluster data. If community deployments can reproduce most of the official service’s capabilities after the open-source release while maintaining reasonable VRAM requirements, throughput, and communication costs, it could become one of the more competitive Chinese MoE models this year. If its advantages depend heavily on the official cache and specific cluster configuration, then 5.1B will be more of an attractive compute metric than a promise of accessible deployment.

In any case, the model industry is shifting from “more parameters mean greater capability” toward “how much capability can be obtained from each activated parameter.” Ling-3.0-Flash is the latest example of that transition.

References

• ITHome: Ant Group Releases Bailing Native Hybrid Reasoning Model Ling-3.0-Flash—Includes the model’s parameter scale, hybrid linear architecture, sparse MoE design, caching solution, free-access deadline, and subsequent open-source plans.