Ling-3.0-flash: More Useful Work per Token

A 124B hybrid-linear MoE built for token efficiency and sustainable intelligence

The next useful frontier for AI models is not just more tokens. It is more useful work per token.

That distinction matters because agents do not answer once. They loop. A production agent plans, calls tools, reads outputs, retries failed steps, keeps context alive and often runs many turns before the user sees a finished result. Every extra token, cache miss and recomputed context window shows up as latency, infrastructure cost and energy use.

Ling-3.0-flash is AntLing’s attempt to push token efficiency into the model design itself. It is a 124B-parameter Mixture-of-Experts model with only 5.1B active parameters per token. In an MoE model, active parameters are the part that actually runs for each token, so this number maps directly to serving cost, latency and throughput.

The point is not simply to make a smaller model. The point is sustainable intelligence: enough capability for real agent workflows, with less active compute spent on every step of the loop.

Why Token Efficiency Matters

For chat, teams often compare models by answer quality. For agents, the more useful metric is useful work per completed task.

A coding agent might inspect a repo, modify several files, run tests, read failures and patch again. A research agent might search, cross-check sources, maintain an evidence trail and synthesize a report. An office automation agent might read Word and Excel files, apply formulas, generate tables and export a final PDF. In each case, the model spends many tokens before the user gets the artifact they actually wanted.

This is where Ling-3.0-flash’s positioning becomes concrete:

• 5.1B active parameters per token means lower compute per generated token.
• Native 256K context, extendable to 1M, gives agents room for long histories, large codebases and document-heavy tasks.
• Agent-focused training and serving work targets the failure modes that matter in real loops: planning, tool use, long-horizon correction and context reuse.

The message is not simply ‘fast and cheap.’ The sharper claim is that Ling-3.0-flash is built to increase the amount of useful work each token can carry.

Active Compute Is the Real Efficiency Lever

Total parameters describe the capacity of the model. Active parameters describe how much of that capacity is used for a token. Developers who are building agent systems should care about the second number because it affects the serving path every time the agent thinks, calls a tool or writes output.

Ling-3.0-flash has 124B total parameters, but only 5.1B active parameters per token. The MoE design also lowers expert activation from 1/32 in previous generations to 1/64, so each token uses only a small slice of the expert pool. The practical translation: the model can keep a larger pool of capacity available without paying for all of it on every token.

That is the core of sustainable intelligence: capability should scale faster than the compute required to serve it.

The Architecture Behind the Claim

The main architectural move is native hybrid-linear attention. Ling-3.0 is pretrained from the start with a 5:1 alternation of Kimi Delta Attention (KDA) linear-attention layers and MLA layers. Every six layers include five KDA layers and one MLA layer.

For readers who do not live inside attention mechanisms, the product implication is simple: the architecture is designed to keep long-context interaction deployable instead of letting memory pressure, latency and token waste grow out of control.

KDA upgrades the previous Lightning Attention mechanism by adding fine-grained diagonal gating to Delta Rule state updates. In plain English, different feature channels get more control over what to keep, what to decay and what to write. That matters for long documents, large repos and research workflows where the model has to preserve important state across many steps.

Ling-3.0-flash architecture: hybrid KDA + MLA attention with fine-grained MoE.

The Evidence: Capability Without Wasteful Scale

Benchmarks are not the whole story, but they are useful if they support the product thesis. The important question is not whether Ling-3.0-flash wins every column. It is whether a 5.1B-active model can stay competitive across the kinds of tasks agents actually hit: coding, tool use, long-context retrieval, instruction following and multi-turn execution.

Benchmark overview. Thinking mode is enabled by default.

The full table gives a more detailed view across coding agents, general agents, search agents, reasoning, instruction following and long-context dialogue.

Detailed benchmark table covering agent, reasoning, instruction-following and long-context tasks.

Built for Closed-Loop Work

The strongest developer-facing claim is that Ling-3.0-flash is optimized for closed-loop work. It is meant to plan, call tools, observe intermediate results, adjust the path and deliver a verifiable output.

The team expanded interactive training environments for Coding Agent, General Agent and Deep Research Agent tasks to more than 10,000 environments. For long-horizon tasks, reinforcement learning incorporates full-trajectory review and step-level contribution assessment, giving the model more granular signals about where execution succeeds or fails.

One concrete example is MiniAppBench. Ling-3.0-flash reaches a 25.3% pass rate on a benchmark where the model must generate a complete usable app from a single user request. The article notes that the average pass rate across 16 mainstream models is 17%, and that Ling-3.0-flash is competitive with open-source models roughly twice its total parameter size.

Cache Reuse Is Token Efficiency Too

A model can be efficient at the parameter level and still feel slow if the serving system keeps recomputing long histories. That is why the HiCache + Mooncake work is strategically important.

In long-running agent sessions, previous context can be evicted from local cache or routed to a different compute node. Traditional serving then has to reprocess tens of thousands of tokens before generating the next answer. Ling-3.0-flash uses SGLang HiCache and Mooncake to build a cluster-level hierarchical cache, turning context from instance-private state into recoverable shared state.

The reported result: on long inputs, hitting L3 Cache can reduce time to first token by 60% to more than 80% compared with direct recomputation. For users, this means faster continuation, lower compute waste and smoother long-session interaction. For developers, it means token efficiency is not only a model metric. It is a system property.

HiCache impact on TTFT as prompt length grows.

Multi-Agent Is the Next Scaling Surface

Ling-3.0-flash also introduces Ling Multi-Agent, a multi-agent collaboration architecture built on the Delegation Intelligence paradigm explored in SearchSwarm. The practical idea is simple: complex work benefits from decomposition, cross-checking, information supplementation, collaborative correction and competitive routing across multiple agents.

On BrowseComp and BrowseComp_zh, the article reports log-linear performance gains as the number of agents scales. This is an important signal for sustainable intelligence: the next step is not only spending more tokens inside one reasoning trace. It is coordinating specialized agents so the system gets more useful work from the compute it spends.

Multi-agent scaling results on BrowseComp and BrowseComp_zh.

What Developers Can Test

The strongest way to evaluate Ling-3.0-flash is not a single chat prompt. Put it inside an agent loop and measure whether it finishes work with fewer wasted steps.

Three test cases are especially useful:

• Repo or app generation: ask the model to inspect context, write code, run feedback loops and produce a working result. MiniAppBench is one public signal here: Ling-3.0-flash reaches a 25.3% pass rate where the average across 16 mainstream models is 17%.
• Deep research: give it a topic that requires search, evidence tracking, contradiction checking and synthesis. This is where long context, state retention and multi-agent decomposition matter.
• Office and workflow automation: connect the model to document, spreadsheet or browser tools and ask it to transform messy inputs into a final deliverable. This tests tool use, formatting control and long-horizon reliability.

The launch demos also cover Blender automation, batch web design, marketing copy generation and course scheduling. Those examples are useful because they show the same pattern in different domains: the model is expected to use tools, preserve context, revise work and finish the task.

Limits and Roadmap

The article is candid about tradeoffs. Because Ling-3.0-flash compresses active parameters aggressively and prioritizes agent and core reasoning capabilities, it makes some compromises in broad knowledge coverage. Multilingual control also remains an area for improvement, especially in long conversations or high-pressure interactions where Chinese-English mixing may occasionally appear.

That honesty matters. It avoids the generic ‘best at everything’ trap and positions Ling-3.0-flash as a deliberately engineered agent model with a focused iteration path: targeted knowledge injection, stronger multilingual alignment and deeper optimization for complex long-horizon tasks. Sustainable intelligence is not a slogan; it is a set of tradeoffs.

How to Try It

Try Ling-3.0-flash in an agent loop, not just a chat window. The most useful test is whether it can complete more useful work per token, with less latency and less recomputation.

AntLing is opening limited-time free API access for Ling-3.0-flash through multiple developer gateways, including OpenRouter, Vercel AI Gateway and the official Bailing platform, until August 3 at 23:00 Beijing time.

• OpenRouter: https://openrouter.ai/inclusionai/ling-3.0-flash:free 
• Vercel AI Gateway: https://vercel.com/ai-gateway/models/ling-3.0-flash-free 

The model weights are planned to be open-sourced after the free access period.